rules-anthropic

AI-generated code uses `os.system` which is prone to command injection vulnerabilities if any part of the command string originates from untrusted input. This allows attackers to execute arbitrary shell commands. Use `subprocess.run` with `shell=False` and pass arguments as a list to prevent injection.

AI-generated code appears to hardcode an API key (e.g., 'sk-...') directly in the source. Hardcoding secrets is a severe security risk, leading to credential compromise. Store API keys securely using environment variables, a dedicated secret management service (e.g., AWS Secrets Manager, HashiCorp Vault), or a secure configuration file, and load them at runtime.

RISK: hardcoded Anthropic API key (sk-ant-...) in TypeScript/JavaScript source. Any repository clone, npm publish, or bundle exposes the key. FIX: load via process.env.ANTHROPIC_API_KEY at runtime; never commit the literal key value. Rotate the key immediately at console.anthropic.com if already committed.

AI-generated code uses `pickle.loads` which is highly vulnerable to arbitrary code execution if deserializing untrusted data. This is a critical security risk. Replace `pickle` with safer serialization formats like JSON or YAML, and ensure all input is validated against a strict schema. For complex objects, consider custom serialization or secure alternatives.

AI-generated code uses the `random` module for security-sensitive operations like generating tokens, passwords, or salts. The `random` module is not cryptographically secure. For security-critical randomness, use the `secrets` module (e.g., `secrets.token_hex()`, `secrets.randbelow()`) which provides cryptographically strong random numbers.

AI-generated code uses `os.path.join` with a variable that might contain untrusted user input, potentially leading to path traversal vulnerabilities (e.g., `../../etc/passwd`). Always sanitize user-provided path components by removing '..' or absolute path indicators, and validate that the final path resolves within an allowed base directory using `os.path.abspath` and `os.path.commonprefix`.

RISK: f-string interpolation directly into the 'user' role message content can allow prompt injection — if the interpolated variable contains adversarial text like 'Ignore previous instructions', the model may follow those instructions. FIX: treat all external input as untrusted; wrap user-supplied content in a delimited block (e.g., <user_input>...</user_input>) and instruct the model in the system prompt to treat delimited content as data, not instructions.

RISK: executing streaming LLM output via exec()/eval() before the full response is received makes prompt-injection-to-RCE trivial — a partial token stream can satisfy the regex that triggers execution. FIX: never exec/eval LLM output. Buffer the complete response, validate it against an explicit allowlist or schema, then dispatch to a safe handler.

AI-generated code uses `eval()` or `exec()`. These functions are extremely dangerous when processing untrusted input, as they allow arbitrary code execution. This is a fundamental security anti-pattern. Refactor the code to avoid dynamic execution of untrusted strings; use safer alternatives like AST parsing, explicit function calls, or a sandboxed environment if absolutely necessary.

AI-generated code uses weak hashing algorithms like MD5 or SHA1 for security purposes. These algorithms are cryptographically broken and vulnerable to collision attacks. For password hashing, use `hashlib.sha256` or `hashlib.sha512` with a robust key derivation function like `pbkdf2_hmac` and a unique salt. For data integrity, use stronger algorithms like SHA256 or SHA3.