Improper Control of Generation of Code ('Code Injection')
The product constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the syntax or behavior of the intended code segment.
When software allows a user's input to contain code syntax, it might be possible for an attacker to craft the code in such a way that it will alter the intended control flow of the software. Such an alteration could lead to arbitrary code execution.
보급률
높음
자주 악용됨
영향
치명적
6개의 치명적 심각도 규칙
예방
문서화됨
10개의 수정 예시
2 예방
2 예방
이 취약점을 수정하는 방법
10개의 Shoulder 탐지 규칙을 기반으로 한 Code Injection 예방 전략.
Code Injection via os/exec
CRITICAL
Pass user input as template data, never use template.HTML with unsanitized input
package main import ( "html/template" "net/http" ) func handler(w http.ResponseWriter, r *http.Request) { userContent := r.FormValue("content") - // Vulnerable: user input cast to template.HTML bypasses escaping - unsafe := template.HTML("<div>" + userContent + "</div>") - tmpl, _ := template.New("page").Parse(`<html>{{.}}</html>`) - tmpl.Execute(w, unsafe) + // Safe: pass as template data, html/template auto-escapes + data := struct{ Content string }{Content: userContent} + tmpl, _ := template.New("page").Parse(`<html><div>{{.Content}}</div></html>`) + tmpl.Execute(w, data) }
LLM Insecure Output Handling
HIGH
Validate and sanitize LLM outputs before using in dangerous operations like exec or SQL
resp, _ := client.CreateChatCompletion(ctx, openai.ChatCompletionRequest{ Messages: []openai.ChatCompletionMessage{{Content: "Generate command for: " + task}}, }) cmd := resp.Choices[0].Message.Content - exec.Command("bash", "-c", cmd).Run() + + validCommands := map[string]bool{"ls": true, "pwd": true, "date": true} + if !validCommands[cmd] { + return fmt.Errorf("invalid command: %s", cmd) + } + exec.Command(cmd).Run()
Server-Side Template Injection
CRITICAL
Use predefined templates and pass user input as template data, never as template code
package main import ( "html/template" "net/http" ) - func handler(w http.ResponseWriter, r *http.Request) { - tmplStr := r.FormValue("template") - // Vulnerable: user input parsed as template code - tmpl, _ := template.New("page").Parse(tmplStr) - tmpl.Execute(w, nil) + // Safe: template is predefined, not from user input + var pageTmpl = template.Must(template.ParseFiles("templates/page.html")) + + func handler(w http.ResponseWriter, r *http.Request) { + name := r.FormValue("name") + // Safe: user input passed as data, not template code + pageTmpl.Execute(w, map[string]string{ + "name": name, + }) }
JavaScript
모두 보기 JavaScript 자세히 →
Code Injection via eval() and Function constructor
CRITICAL
Replace eval/Function constructor with safe alternatives like JSON.parse or predefined function maps
const express = require('express'); const app = express(); - app.post('/calculate', (req, res) => { - const expression = req.body.expression; - const result = eval(expression); - res.json({ result }); + const operations = { + add: (a, b) => a + b, + subtract: (a, b) => a - b, + multiply: (a, b) => a * b, + }; + + app.post('/calculate', (req, res) => { + const { op, a, b } = req.body; + const fn = operations[op]; + if (!fn) return res.status(400).json({ error: 'Invalid operation' }); + res.json({ result: fn(Number(a), Number(b)) }); });
TypeScript Unsafe Decorator Usage
HIGH
Use static values for decorator parameters and avoid eval(), global modifications, or user input in decorators
- function DynamicRole(roleExpression: string) { - return function (target: any, key: string, desc: PropertyDescriptor) { - const original = desc.value; - desc.value = function (...args: any[]) { - if (eval(roleExpression)) { - return original.apply(this, args); - } - throw new Error('Unauthorized'); - }; - }; - } - - class AdminController { - @DynamicRole("user.role === 'admin'") + enum Role { Admin = 'admin', User = 'user' } + + function RequireRole(...roles: Role[]) { + return function (target: any, key: string, desc: PropertyDescriptor) { + const original = desc.value; + desc.value = function (...args: any[]) { + if (!roles.includes(this.currentUser?.role)) { + throw new Error('Unauthorized'); + } + return original.apply(this, args); + }; + }; + } + + class AdminController { + @RequireRole(Role.Admin) deleteUser() { /* ... */ } }
Python
모두 보기 Python 자세히 →
Code Injection via eval/exec
CRITICAL
Use ast.literal_eval() for safe evaluation or avoid eval/exec entirely
- from flask import request - - @app.route('/calc') - def calculate(): - expression = request.args.get('expr') - result = eval(expression) + import ast + from flask import request, abort + + @app.route('/calc') + def calculate(): + expression = request.args.get('expr', '') + try: + result = ast.literal_eval(expression) + except (ValueError, SyntaxError): + abort(400, 'Invalid expression') return str(result)
Dangerous Function Usage
CRITICAL
Replace eval/exec with ast.literal_eval, JSON parsing, or subprocess with shell=False
- from flask import request - - @app.route('/calculate') - def calculate(): - expr = request.args.get('expr') - result = eval(expr) + import ast + from flask import request + + @app.route('/calculate') + def calculate(): + expr = request.args.get('expr') + result = ast.literal_eval(expr) return {'result': result}
LLM Insecure Output Handling
HIGH
Validate and sanitize LLM outputs with Pydantic before using in dangerous operations like eval, exec, or SQL
- response = openai.chat.completions.create( - model='gpt-4', - messages=[{'role': 'user', 'content': user_request}] - ) - generated_code = response.choices[0].message.content - result = eval(generated_code) + from pydantic import BaseModel, validator + import re + + class ValidatedOutput(BaseModel): + expression: str + + @validator('expression') + def validate_expression(cls, v): + if not re.fullmatch(r'[a-zA-Z0-9\s\+\-\*\/\(\)\.]+', v): + raise ValueError('Invalid expression format') + return v + + response = openai.chat.completions.create( + model='gpt-4', + messages=[{'role': 'user', 'content': user_request}] + ) + validated = ValidatedOutput(expression=response.choices[0].message.content) + result = process_validated_expression(validated.expression)
핵심 실천 사항
- treated as untrusted input since: - Prompt injection attacks can manipulate AI responses - LLMs can hallucinate and produce unexpected outputs - Model behavior may change between versions Dangerous operations include: - Code execution (eval, Function, vm
- avoided or heavily restricted
- treated as untrusted input since: - Prompt injection attacks can manipulate AI responses - LLMs can hallucinate and produce unexpected outputs - Model behavior may change between versions Dangerous operations include: - Code execution (eval, exec, compile) - Command execution (os
3 탐지
3 탐지
코드에서 취약점 찾기
Shoulder를 사용하여 코드에서 Improper Control of Generation of Code ('Code Injection') 패턴을 스캔하세요. 10 규칙.
# Scan with Shoulder CLI npx @shoulderdev/cli trust --cwe=94 # Or scan entire project npx @shoulderdev/cli trust .
탐지 규칙 (10)
🐍
Python
4 rules
Code Injection via eval/exec
CRITICAL
Detects untrusted user input flowing into code evaluation functions
(eval, exec, compile).
Dangerous Function Usage
CRITICAL
Detects usage of dangerous Python functions that can lead to arbitrary code
execution: eval(), exec(), compile(), __import__() with user input, or
pickle deserialization. These should be avoided or heavily restricted.
LLM Insecure Output Handling
HIGH
Detects LLM/AI outputs being used directly in dangerous operations without proper
validation or sanitization. OWASP LLM02 - Insecure Output Handling.
LLM outputs should be treated as untrusted input since:
- Prompt injection attacks can manipulate AI responses
- LLMs can hallucinate and produce unexpected outputs
- Model behavior may change between versions
Dangerous operations include:
- Code execution (eval, exec, compile)
- Command execution (os.system, subprocess)
- SQL queries (cursor.exe
Server-Side Template Injection (SSTI)
CRITICAL
Detects user input used directly in template rendering, allowing arbitrary
code execution.
🐹
Go
3 rules
Code Injection via os/exec
CRITICAL
Detects user input flowing to template functions that bypass HTML escaping.
LLM Insecure Output Handling
HIGH
Detects LLM outputs used directly in dangerous operations like command execution or SQL queries without validation.
Server-Side Template Injection
CRITICAL
User input passed directly to template.Parse without sanitization.
🔷
Typescript
3 rules
Code Injection via eval() and Function constructor
CRITICAL
Detects user input flowing to code execution functions like eval() or Function constructor.
LLM Insecure Output Handling
HIGH
Detects LLM/AI outputs being used directly in dangerous operations without proper
validation or sanitization. OWASP LLM02 - Insecure Output Handling.
LLM outputs should be treated as untrusted input since:
- Prompt injection attacks can manipulate AI responses
- LLMs can hallucinate and produce unexpected outputs
- Model behavior may change between versions
Dangerous operations include:
- Code execution (eval, Function, vm.runInContext)
- Command execution (exec, spawn, execSync)
- SQL queries
TypeScript Unsafe Decorator Usage
HIGH
Decorators that use eval(), modify global state, or accept user input as parameters
enable code injection, prototype pollution, and authorization bypass.
🟨
Javascript
2 rules
Code Injection via eval() and Function constructor
CRITICAL
Detects user input flowing to code execution functions like eval() or Function constructor.
LLM Insecure Output Handling
HIGH
Detects LLM/AI outputs being used directly in dangerous operations without proper
validation or sanitization. OWASP LLM02 - Insecure Output Handling.
LLM outputs should be treated as untrusted input since:
- Prompt injection attacks can manipulate AI responses
- LLMs can hallucinate and produce unexpected outputs
- Model behavior may change between versions
Dangerous operations include:
- Code execution (eval, Function, vm.runInContext)
- Command execution (exec, spawn, execSync)
- SQL queries
4 경고 신호
4 경고 신호
코드 리뷰에서 주의할 점
이 패턴은 잠재적인 Improper Control of Generation of Code ('Code Injection') 취약점을 나타냅니다. 코드 리뷰와 보안 감사 중에 찾아보세요.
LLM output flows to ... without validation
go-llm-insecure-output-handling
LLM outputs used directly in dangerous operations like command execution or SQL queries without vali
go-llm-insecure-output-handling
LLM/AI outputs being used directly in dangerous operations without proper
validation or sanitization
javascript-llm-insecure-output-handling
Decorator '...' executes unsafe code or accesses global state. This can lead to code injection or unauthorized access.
typescript-unsafe-decorator
user input flowing to template functions that bypass HTML escaping
go-code-injection
user input flowing to code execution functions like eval() or Function constructor
javascript-code-injection
untrusted user input flowing into code evaluation functions
(eval, exec, compile)
python-code-injection
usage of dangerous Python functions that can lead to arbitrary code
execution: eval(), exec(), compi
python-dangerous-functions
코드베이스를 스캔하세요: Improper Control of Generation of Code ('Code Injection')
Shoulder CLI는 전체 코드베이스에서 취약한 패턴을 찾아냅니다.