prompt stringlengths 202 459 | response dict |
|---|---|
Review this Python code for security issues:
def get_user(username):
import sqlite3
conn = sqlite3.connect('users.db')
cursor = conn.cursor()
query = "SELECT * FROM users WHERE username = '" + username + "'"
cursor.execute(query)
return cursor.fetchone() | {
"vulnerability_type": "SQL Injection",
"location": "Line 5 — string concatenation used to build SQL query with unsanitized user input `username`",
"remediation": "Use parameterized queries (prepared statements). Replace the query with: `query = 'SELECT * FROM users WHERE username = ?'` and call `cursor.execute(... |
Review this Python code for security issues:
from flask import Flask, request
import subprocess
app = Flask(__name__)
@app.route('/ping')
def ping():
host = request.args.get('host')
result = subprocess.check_output('ping -c 1 ' + host, shell=True)
return result | {
"vulnerability_type": "Command Injection",
"location": "Line 8 — user-controlled `host` parameter directly concatenated into a shell command with `shell=True`",
"remediation": "Avoid `shell=True`. Use a list of arguments and validate/whitelist input: `subprocess.check_output(['ping', '-c', '1', host])`. Also va... |
Review this Python code for security issues:
from flask import Flask, request, render_template_string
app = Flask(__name__)
@app.route('/greet')
def greet():
name = request.args.get('name', '')
return render_template_string('<h1>Hello, ' + name + '!</h1>') | {
"vulnerability_type": "Cross-Site Scripting (XSS)",
"location": "Line 8 — unsanitized user input `name` is directly embedded into HTML returned to the browser",
"remediation": "Use Jinja2 template auto-escaping. Pass `name` as a template variable: `render_template_string('<h1>Hello, {{ name }}!</h1>', name=name... |
Review this Python code for security issues:
from flask import Flask, request, session
app = Flask(__name__)
@app.route('/transfer', methods=['POST'])
def transfer():
amount = request.form['amount']
to_account = request.form['to_account']
# perform transfer without any token check
do_transfer(session[... | {
"vulnerability_type": "Cross-Site Request Forgery (CSRF)",
"location": "Lines 6-10 — the `/transfer` POST endpoint performs a sensitive action without verifying a CSRF token",
"remediation": "Implement CSRF token validation using a library such as `flask-wtf`. Generate a unique token per session, embed it in fo... |
Review this Python code for security issues:
import os
from flask import Flask, request, send_file
app = Flask(__name__)
@app.route('/download')
def download():
filename = request.args.get('file')
return send_file('/var/www/files/' + filename) | {
"vulnerability_type": "Path Traversal",
"location": "Line 9 — user-supplied `filename` is concatenated directly to a base path without sanitization, allowing `../../etc/passwd` style traversal",
"remediation": "Use `os.path.basename(filename)` to strip directory components, then use `os.path.abspath` and verify... |
Review this Python code for security issues:
import pickle
from flask import Flask, request
app = Flask(__name__)
@app.route('/load', methods=['POST'])
def load_data():
data = request.data
obj = pickle.loads(data)
return str(obj) | {
"vulnerability_type": "Insecure Deserialization",
"location": "Line 9 — `pickle.loads()` is called on untrusted user-supplied bytes, which can execute arbitrary code during deserialization",
"remediation": "Never deserialize untrusted data with `pickle`. Use a safe data format like JSON (`json.loads`) or a sche... |
Review this Python code for security issues:
from flask import Flask, request
import yaml
app = Flask(__name__)
@app.route('/config', methods=['POST'])
def load_config():
config_data = request.data
config = yaml.load(config_data)
return str(config) | {
"vulnerability_type": "Insecure Deserialization / Code Execution via YAML",
"location": "Line 9 — `yaml.load()` without a safe Loader can execute arbitrary Python objects embedded in malicious YAML input",
"remediation": "Replace `yaml.load(config_data)` with `yaml.safe_load(config_data)`. The `safe_load` funct... |
Review this Python code for security issues:
from flask import Flask, request, redirect
app = Flask(__name__)
@app.route('/redirect')
def do_redirect():
url = request.args.get('next')
return redirect(url) | {
"vulnerability_type": "Open Redirect",
"location": "Line 7 — the `next` parameter is used directly as the redirect target without validation, allowing redirection to arbitrary external URLs",
"remediation": "Validate the redirect target against an allowlist of trusted URLs or domains. Use `urllib.parse.urlparse... |
Review this Python code for security issues:
from flask import Flask, request
import subprocess
app = Flask(__name__)
@app.route('/convert')
def convert():
filename = request.args.get('file')
os.system('convert ' + filename + ' output.png')
return 'Done' | {
"vulnerability_type": "Command Injection",
"location": "Line 9 — `os.system` is called with unsanitized user input `filename` concatenated into the shell command string",
"remediation": "Replace `os.system` with `subprocess.run(['convert', filename, 'output.png'])` using a list (no shell interpolation). Additio... |
Review this Python code for security issues:
from flask import Flask, request, make_response
app = Flask(__name__)
@app.route('/setlang')
def set_language():
lang = request.args.get('lang', 'en')
resp = make_response('Language set')
resp.set_cookie('lang', lang)
return resp | {
"vulnerability_type": "Cookie Injection / Missing Secure Cookie Flags",
"location": "Line 9 — the cookie is set with user-controlled content without `HttpOnly`, `Secure`, or `SameSite` flags",
"remediation": "Set cookies with security flags: `resp.set_cookie('lang', lang, httponly=True, secure=True, samesite='S... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/eval')
def run_expr():
expr = request.args.get('expr')
result = eval(expr)
return str(result) | {
"vulnerability_type": "Remote Code Execution (RCE) via eval()",
"location": "Line 7 — `eval()` executes arbitrary Python expressions provided by the user via the `expr` query parameter",
"remediation": "Never use `eval()` or `exec()` on user input. If mathematical expression evaluation is needed, use a safe lib... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/search')
def search():
term = request.args.get('q')
import re
results = db.execute(f"SELECT * FROM products WHERE name LIKE '%{term}%'")
return str(results.fetchall()) | {
"vulnerability_type": "SQL Injection",
"location": "Line 8 — f-string interpolation embeds the unescaped `term` variable directly into the SQL query",
"remediation": "Use a parameterized query: `db.execute(\"SELECT * FROM products WHERE name LIKE ?\", (f'%{term}%',))`. This ensures the database driver handles e... |
Review this Python code for security issues:
import hashlib
from flask import Flask, request
app = Flask(__name__)
@app.route('/login', methods=['POST'])
def login():
password = request.form['password']
hashed = hashlib.md5(password.encode()).hexdigest()
user = db.query('SELECT * FROM users WHERE password... | {
"vulnerability_type": "Weak Password Hashing (Use of MD5)",
"location": "Line 9 — MD5 is used to hash passwords; it is cryptographically broken and susceptible to rainbow table and brute-force attacks",
"remediation": "Replace MD5 with `bcrypt`, `argon2`, or `scrypt`. Use the `bcrypt` library: `bcrypt.hashpw(pa... |
Review this Python code for security issues:
from flask import Flask, request, session
app = Flask(__name__)
app.secret_key = 'secret'
@app.route('/admin')
def admin():
if session.get('role') == 'admin':
return render_admin()
return 'Forbidden', 403 | {
"vulnerability_type": "Hardcoded Secret Key / Weak Session Security",
"location": "Line 3 — `app.secret_key` is set to a hardcoded, trivially guessable string `'secret'`, compromising all session tokens",
"remediation": "Generate a strong random secret key and load it from an environment variable: `app.secret_k... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/upload', methods=['POST'])
def upload():
f = request.files['file']
f.save('/var/www/uploads/' + f.filename)
return 'Uploaded' | {
"vulnerability_type": "Unrestricted File Upload / Path Traversal",
"location": "Line 8 — `f.filename` is used directly without sanitization, allowing directory traversal or upload of malicious file types (e.g., `.py`, `.php`)",
"remediation": "Use `werkzeug.utils.secure_filename(f.filename)` to sanitize the fil... |
Review this Python code for security issues:
from flask import Flask, request
from lxml import etree
app = Flask(__name__)
@app.route('/parse', methods=['POST'])
def parse_xml():
xml_data = request.data
parser = etree.XMLParser()
tree = etree.fromstring(xml_data, parser)
return tree.find('name').text | {
"vulnerability_type": "XML External Entity (XXE) Injection",
"location": "Lines 8-9 — the XML parser is configured without disabling external entity resolution, allowing attackers to read local files or trigger SSRF via DOCTYPE declarations",
"remediation": "Disable external entity processing: `parser = etree.X... |
Review this Python code for security issues:
from flask import Flask, request
import requests as http
app = Flask(__name__)
@app.route('/fetch')
def fetch_url():
url = request.args.get('url')
resp = http.get(url)
return resp.text | {
"vulnerability_type": "Server-Side Request Forgery (SSRF)",
"location": "Line 8 — the `url` parameter is user-controlled and passed directly to `requests.get()`, allowing requests to internal services, metadata endpoints, or localhost",
"remediation": "Validate `url` against an allowlist of permitted domains. U... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/log')
def log_action():
user = request.args.get('user')
with open('app.log', 'a') as f:
f.write(f'User {user} accessed the page\n')
return 'Logged' | {
"vulnerability_type": "Log Injection",
"location": "Line 8 — unsanitized `user` input is written directly to log files; an attacker can inject newlines to forge log entries",
"remediation": "Sanitize log entries by stripping or escaping newline characters: `user = user.replace('\\n', '').replace('\\r', '')`. Us... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/render')
def render():
template = request.args.get('template')
from jinja2 import Environment
env = Environment()
return env.from_string(template).render() | {
"vulnerability_type": "Server-Side Template Injection (SSTI)",
"location": "Lines 7-9 — user-supplied `template` string is compiled and rendered directly by Jinja2, allowing arbitrary Python code execution via expressions like `{{ ''.__class__.__mro__[1].__subclasses__() }}`",
"remediation": "Never render user-... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/user/<int:user_id>')
def get_user_data(user_id):
current_user = get_current_user()
user = db.get_user(user_id)
return jsonify(user.to_dict()) | {
"vulnerability_type": "Insecure Direct Object Reference (IDOR)",
"location": "Lines 6-8 — the endpoint returns data for any `user_id` without verifying that the requesting user is authorized to access that record",
"remediation": "Add an authorization check before returning data: `if current_user.id != user_id ... |
Review this Python code for security issues:
from flask import Flask
app = Flask(__name__)
DB_PASSWORD = 'SuperSecret123'
API_KEY = 'sk-prod-abc123xyz'
@app.route('/')
def index():
return 'Hello' | {
"vulnerability_type": "Hardcoded Credentials / Secrets in Source Code",
"location": "Lines 4-5 — database password and API key are hardcoded as plaintext string literals in the source file",
"remediation": "Store secrets in environment variables or a secrets manager (e.g., AWS Secrets Manager, HashiCorp Vault).... |
Review this Python code for security issues:
from flask import Flask, request
import re
app = Flask(__name__)
@app.route('/validate')
def validate_email():
email = request.args.get('email', '')
pattern = r'^([a-zA-Z0-9]+)*@[a-zA-Z0-9]+\.[a-zA-Z]{2,}$'
if re.match(pattern, email):
return 'Valid'
... | {
"vulnerability_type": "Regular Expression Denial of Service (ReDoS)",
"location": "Line 8 — the regex pattern `^([a-zA-Z0-9]+)*@...` contains a nested quantifier `(group)+*` which causes catastrophic backtracking on crafted inputs",
"remediation": "Rewrite the regex to avoid nested quantifiers: `r'^[a-zA-Z0-9._... |
Review this Python code for security issues:
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/debug')
def debug():
import traceback, sys
return jsonify({
'env': dict(os.environ),
'traceback': traceback.format_exc()
}) | {
"vulnerability_type": "Sensitive Data Exposure / Information Disclosure",
"location": "Lines 7-9 — the `/debug` endpoint exposes all environment variables (including secrets) and stack traces to any unauthenticated caller",
"remediation": "Remove or restrict the debug endpoint entirely in production. If needed ... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/query')
def query_mongo():
username = request.args.get('user')
result = db.users.find({'username': username, 'active': True})
return str(list(result)) | {
"vulnerability_type": "NoSQL Injection",
"location": "Line 7 — `username` is inserted directly into a MongoDB query dict; an attacker can pass a JSON object (e.g., `{\"$gt\": \"\"}`) to manipulate the query logic",
"remediation": "Validate that `username` is a plain string before querying: `if not isinstance(us... |
Review this Python code for security issues:
from flask import Flask, request, session
app = Flask(__name__)
@app.route('/reset', methods=['POST'])
def reset_password():
token = request.form.get('token')
stored_token = get_reset_token(request.form.get('email'))
if token == stored_token:
update_pas... | {
"vulnerability_type": "Timing Attack on Token Comparison",
"location": "Line 8 — `token == stored_token` uses a non-constant-time string comparison, allowing timing-based enumeration of valid reset tokens",
"remediation": "Use `hmac.compare_digest(token, stored_token)` for constant-time comparison. Additionally... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/import', methods=['POST'])
def import_module():
mod_name = request.form.get('module')
mod = __import__(mod_name)
result = mod.run()
return str(result) | {
"vulnerability_type": "Remote Code Execution via Dynamic Import",
"location": "Line 7 — `__import__()` is called with a user-supplied module name, allowing an attacker to import and execute arbitrary installed Python modules (e.g., `os`, `subprocess`)",
"remediation": "Never import modules based on user input. ... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/data')
def get_data():
response = make_response(jsonify({'secret': 'data'}))
response.headers['Access-Control-Allow-Origin'] = '*'
response.headers['Access-Control-Allow-Credentials'] = 'tr... | {
"vulnerability_type": "Misconfigured CORS (Cross-Origin Resource Sharing)",
"location": "Lines 7-8 — setting `Access-Control-Allow-Origin: *` together with `Access-Control-Allow-Credentials: true` is invalid per the spec and, in some browsers/configs, may allow credential-bearing cross-origin requests from any si... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/execute', methods=['POST'])
def execute_code():
code = request.form.get('code')
exec(code)
return 'Executed' | {
"vulnerability_type": "Remote Code Execution via exec()",
"location": "Line 7 — `exec()` executes arbitrary Python code supplied by the user, allowing complete server compromise",
"remediation": "`exec()` must never be called on user-supplied input. Remove this endpoint entirely. If sandboxed code execution is ... |
Review this Python code for security issues:
import sqlite3
from flask import Flask, request
app = Flask(__name__)
@app.route('/delete', methods=['POST'])
def delete_record():
record_id = request.form.get('id')
conn = sqlite3.connect('data.db')
conn.execute("DELETE FROM records WHERE id = " + record_id)
... | {
"vulnerability_type": "SQL Injection",
"location": "Line 9 — `record_id` from user input is concatenated directly into a DELETE statement without sanitization",
"remediation": "Use a parameterized query: `conn.execute('DELETE FROM records WHERE id = ?', (record_id,))`. Also validate that `record_id` is a valid ... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/headers')
def show_headers():
user_agent = request.headers.get('User-Agent')
return f'<html><body>Your agent: {user_agent}</body></html>' | {
"vulnerability_type": "Cross-Site Scripting (XSS) via HTTP Header Reflection",
"location": "Line 7 — the `User-Agent` HTTP header is reflected into the HTML response without escaping, allowing header-based XSS",
"remediation": "Escape the output using `markupsafe.escape(user_agent)` before embedding it in HTML,... |
Review this Python code for security issues:
from flask import Flask, request
import ldap
app = Flask(__name__)
@app.route('/login', methods=['POST'])
def ldap_login():
user = request.form['username']
password = request.form['password']
conn = ldap.initialize('ldap://corp.local')
conn.simple_bind_s(f'... | {
"vulnerability_type": "LDAP Injection",
"location": "Line 11 — `user` is interpolated directly into an LDAP distinguished name string without escaping, allowing DN injection attacks",
"remediation": "Escape user input using `ldap.dn.escape_dn_chars(user)` before constructing the DN. Validate the username to onl... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/profile')
def profile():
user_id = request.cookies.get('user_id')
user = db.get_user(user_id)
return render_profile(user) | {
"vulnerability_type": "Insecure Authentication via Unverified Cookie",
"location": "Lines 6-7 — `user_id` is read directly from a cookie with no signature or integrity verification, allowing attackers to forge arbitrary user IDs",
"remediation": "Use Flask's signed session cookies (`session['user_id']`) which a... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/status')
def status():
ip = request.args.get('ip')
result = os.popen(f'nmap -sV {ip}').read()
return result | {
"vulnerability_type": "Command Injection via os.popen()",
"location": "Line 7 — `os.popen()` is called with user-controlled `ip` embedded in a shell command; `;`, `&&`, `|` can chain arbitrary commands",
"remediation": "Use `subprocess.run(['nmap', '-sV', ip], capture_output=True, text=True)` without `shell=Tru... |
Review this Python code for security issues:
from flask import Flask, session, request
app = Flask(__name__)
@app.route('/logout')
def logout():
session.clear()
return redirect('/')
@app.route('/admin')
def admin():
return 'Admin panel' | {
"vulnerability_type": "Missing Authentication on Sensitive Endpoint",
"location": "Lines 10-11 — the `/admin` route has no authentication or authorization check; any user (or anonymous visitor) can access it",
"remediation": "Add an authentication decorator: check `session.get('user_id')` and `session.get('role... |
Review this Python code for security issues:
import random
from flask import Flask
app = Flask(__name__)
@app.route('/token')
def generate_token():
token = str(random.randint(100000, 999999))
return token | {
"vulnerability_type": "Use of Cryptographically Weak PRNG for Security Token",
"location": "Line 7 — `random.randint` uses a predictable Mersenne Twister PRNG; tokens generated this way can be predicted or brute-forced",
"remediation": "Use the `secrets` module: `token = secrets.token_urlsafe(32)`. The `secrets... |
Review this Python code for security issues:
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/api/update', methods=['POST'])
def update_user():
data = request.json
user_id = data.get('user_id')
updates = data.get('updates')
db.users.update_one({'_id': user_id}, {'$set': upd... | {
"vulnerability_type": "Mass Assignment / MongoDB Operator Injection",
"location": "Line 9 — the `updates` dict from user input is passed directly to `$set`; an attacker can overwrite any field (e.g., `role`, `is_admin`) or inject MongoDB update operators",
"remediation": "Define a strict allowlist of updatable ... |
Review this Python code for security issues:
from flask import Flask, request
from jinja2 import Template
app = Flask(__name__)
@app.route('/report')
def report():
name = request.args.get('name')
t = Template('Hello ' + name + '!')
return t.render() | {
"vulnerability_type": "Server-Side Template Injection (SSTI)",
"location": "Line 8 — user-supplied `name` is concatenated into a Jinja2 `Template` source string before compilation, allowing injection of template directives",
"remediation": "Pass `name` as a variable to a static template string: `t = Template('H... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api', methods=['POST'])
def api():
content_type = request.content_type
raw = request.data
if 'xml' in content_type:
data = parse_xml(raw) # uses lxml without disabling entities
re... | {
"vulnerability_type": "XML External Entity (XXE) Injection",
"location": "Line 9 — `parse_xml` uses lxml without disabling external entity resolution; attacker can include a `<!DOCTYPE>` with an entity referencing `/etc/passwd` or internal URLs",
"remediation": "In `parse_xml`, use: `etree.XMLParser(resolve_ent... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/search')
def search():
q = request.args.get('q', '')
results = [item for item in catalog if q in item['name']]
return render_template('results.html', q=q, results=results) | {
"vulnerability_type": "Cross-Site Scripting (XSS) — Reflected",
"location": "Line 8 — the raw query string `q` is passed to the template; if the template outputs `{{ q | safe }}` or uses `Markup(q)`, the input is rendered unescaped",
"remediation": "Ensure the template renders `q` without the `| safe` filter: `... |
Review this Python code for security issues:
from flask import Flask, request, session
app = Flask(__name__)
@app.route('/2fa', methods=['POST'])
def verify_2fa():
code = request.form.get('code')
if session.get('2fa_code') == code:
session['authenticated'] = True
return redirect('/dashboard') | {
"vulnerability_type": "Timing Attack and Missing Rate Limiting on 2FA",
"location": "Line 7 — non-constant-time comparison for the OTP code, and no rate limiting allows unlimited brute-force of the 6-digit code (1,000,000 possibilities)",
"remediation": "Use `hmac.compare_digest` for constant-time comparison. I... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/env')
def show_env():
import os
key = request.args.get('key')
value = os.environ.get(key, 'Not found')
return value | {
"vulnerability_type": "Sensitive Data Exposure via Environment Variable Leakage",
"location": "Lines 7-8 — an attacker can query any environment variable by name (e.g., `?key=DATABASE_URL`, `?key=SECRET_KEY`) exposing secrets",
"remediation": "Remove this endpoint entirely. If environment inspection is needed f... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/proxy')
def proxy():
url = request.args.get('url')
import urllib.request
with urllib.request.urlopen(url) as resp:
return resp.read() | {
"vulnerability_type": "Server-Side Request Forgery (SSRF)",
"location": "Lines 7-8 — `urllib.request.urlopen` is called with a fully user-controlled URL, allowing access to internal services, cloud metadata endpoints (169.254.169.254), and localhost",
"remediation": "Validate the URL scheme (allow only `https`)... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/setcookie')
def setcookie():
user = request.args.get('user')
from flask import make_response
resp = make_response('OK')
resp.set_cookie('user', user, expires=None)
return resp | {
"vulnerability_type": "Session Fixation / Missing Secure Cookie Attributes",
"location": "Line 9 — cookie is set without `HttpOnly`, `Secure`, or `SameSite` attributes; `expires=None` makes it a session cookie that can be manipulated",
"remediation": "Set security flags: `resp.set_cookie('user', user, httponly=... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/comments', methods=['POST'])
def post_comment():
body = request.form.get('body')
db.execute('INSERT INTO comments (body) VALUES (?)', (body,))
return redirect('/comments')
@app.route('/comment... | {
"vulnerability_type": "Stored Cross-Site Scripting (Stored XSS)",
"location": "Line 12 — comment bodies retrieved from the database are interpolated directly into the HTML response without escaping, executing any stored scripts",
"remediation": "Escape output using `markupsafe.escape(c[0])` before inserting int... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/run_report')
def run_report():
report_type = request.args.get('type')
path = f'/reports/{report_type}.py'
with open(path) as f:
exec(f.read())
return 'Done' | {
"vulnerability_type": "Path Traversal + Remote Code Execution",
"location": "Lines 7-9 — `report_type` is used in a path without sanitization (traversal via `../../`) and the file contents are executed with `exec()`, enabling arbitrary code execution",
"remediation": "Use `os.path.basename(report_type)` to stri... |
Review this Python code for security issues:
from flask import Flask, request
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
db = SQLAlchemy(app)
@app.route('/users')
def list_users():
name_filter = request.args.get('name', '')
users = db.engine.execute(f'SELECT * FROM user WHERE name LIKE "%{n... | {
"vulnerability_type": "SQL Injection via SQLAlchemy raw query",
"location": "Line 9 — an f-string embeds `name_filter` directly into a raw SQL string passed to `db.engine.execute()`",
"remediation": "Use SQLAlchemy ORM queries: `User.query.filter(User.name.like(f'%{name_filter}%')).all()` — SQLAlchemy parameter... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/image')
def serve_image():
name = request.args.get('name')
with open(f'static/images/{name}', 'rb') as f:
return f.read() | {
"vulnerability_type": "Path Traversal",
"location": "Line 7 — `name` is used in a file open call without sanitization; `../../etc/passwd` or similar traversal strings can read arbitrary files",
"remediation": "Sanitize with `os.path.basename(name)` and verify the resolved absolute path is within the intended di... |
Review this Python code for security issues:
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/api/order', methods=['POST'])
def place_order():
data = request.json
price = data.get('price') # client-supplied price
item = data.get('item')
create_order(item, price)
return... | {
"vulnerability_type": "Business Logic Flaw — Client-Side Price Manipulation",
"location": "Line 7 — the price is taken from the client request body rather than looked up server-side, allowing an attacker to set an arbitrary price (e.g., 0 or negative)",
"remediation": "Never trust client-supplied pricing. Look ... |
Review this Python code for security issues:
import flask
from flask import request
app = flask.Flask(__name__)
@app.route('/graphql', methods=['POST'])
def graphql():
query = request.json.get('query')
depth = get_query_depth(query)
result = schema.execute(query)
return flask.jsonify(result.data) | {
"vulnerability_type": "GraphQL — Missing Depth Limiting / Introspection Abuse",
"location": "Lines 7-9 — query depth is computed but never enforced; introspection is also likely enabled in production, exposing the full schema",
"remediation": "Enforce a maximum query depth (e.g., 5) and reject queries exceeding... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/upload', methods=['POST'])
def upload():
f = request.files['file']
if f.filename.endswith('.jpg') or f.filename.endswith('.png'):
f.save('/var/www/uploads/' + f.filename)
return 'OK' | {
"vulnerability_type": "Insufficient File Type Validation (MIME Sniffing Bypass)",
"location": "Lines 7-8 — file type is validated only by extension check on the filename, which can be bypassed by naming a PHP/Python script `shell.php.jpg`",
"remediation": "Validate file type by inspecting magic bytes using the ... |
Review this Python code for security issues:
from flask import Flask, request, make_response
app = Flask(__name__)
@app.after_request
def add_headers(response):
return response
@app.route('/')
def index():
return '<html><body>Welcome</body></html>' | {
"vulnerability_type": "Missing Security Headers",
"location": "Lines 4-6 — the `after_request` hook adds no security headers; responses lack `Content-Security-Policy`, `X-Frame-Options`, `X-Content-Type-Options`, `Strict-Transport-Security`",
"remediation": "Add security headers in the `after_request` hook: `re... |
Review this Python code for security issues:
from flask import Flask, request
import re
app = Flask(__name__)
@app.route('/lookup')
def lookup():
domain = request.args.get('domain')
import socket
ip = socket.gethostbyname(domain)
return ip | {
"vulnerability_type": "DNS Rebinding / SSRF via DNS Resolution",
"location": "Lines 8-9 — `socket.gethostbyname()` resolves an attacker-controlled domain; combined with DNS rebinding, this can bypass IP allowlists and reach internal services",
"remediation": "After resolving the hostname, check that the resolve... |
Review this Python code for security issues:
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/api/v1/admin/users', methods=['DELETE'])
def delete_all_users():
db.execute('DELETE FROM users')
return jsonify({'deleted': True}) | {
"vulnerability_type": "Missing Authentication / Unauthorized Destructive Operation",
"location": "Lines 4-7 — the endpoint performs a bulk delete of all users with no authentication, authorization, or CSRF protection",
"remediation": "Require admin authentication (verify JWT or session), add CSRF token validati... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/reflect')
def reflect():
callback = request.args.get('callback', 'callback')
data = '{"user": "alice"}'
return f'{callback}({data})' | {
"vulnerability_type": "JSONP Injection / XSS via Callback Parameter",
"location": "Line 7 — the `callback` parameter is directly interpolated into the response without validation; an attacker can inject arbitrary JavaScript as the callback name",
"remediation": "Validate `callback` strictly against an alphanume... |
Review this Python code for security issues:
from flask import Flask, session, request
app = Flask(__name__)
@app.route('/change_email', methods=['POST'])
def change_email():
new_email = request.form.get('email')
user_id = session.get('user_id')
db.update_user_email(user_id, new_email)
return 'Email u... | {
"vulnerability_type": "Cross-Site Request Forgery (CSRF)",
"location": "Lines 5-9 — the email-change endpoint has no CSRF token check; a malicious site can silently change a logged-in user's email via a crafted POST request",
"remediation": "Generate and validate a CSRF token per session. Use `flask-wtf`'s `CSR... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/lookup')
def db_lookup():
table = request.args.get('table')
column = request.args.get('column')
value = request.args.get('value')
result = db.execute(f'SELECT * FROM {table} WHERE {column} ... | {
"vulnerability_type": "SQL Injection via Dynamic Table/Column Names",
"location": "Line 8 — `table` and `column` are user-controlled and interpolated directly into the SQL query; parameterized queries cannot protect identifiers (table/column names), only values",
"remediation": "Validate `table` and `column` ag... |
Review this Python code for security issues:
from flask import Flask, request
from cryptography.fernet import Fernet
app = Flask(__name__)
KEY = b'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA='
@app.route('/encrypt')
def encrypt():
data = request.args.get('data').encode()
f = Fernet(KEY)
return f.encrypt(... | {
"vulnerability_type": "Hardcoded Weak Encryption Key",
"location": "Line 5 — the Fernet encryption key is hardcoded as a trivially guessable all-zero value, rendering all encrypted data decryptable by anyone",
"remediation": "Generate a strong random key using `Fernet.generate_key()` at deployment time, store i... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/items')
def get_items():
limit = request.args.get('limit', 100)
offset = request.args.get('offset', 0)
items = db.execute(f'SELECT * FROM items LIMIT {limit} OFFSET {offset}')
return st... | {
"vulnerability_type": "SQL Injection + Resource Exhaustion",
"location": "Line 8 — `limit` and `offset` are interpolated into SQL without sanitization (injection) and without upper-bound enforcement (DoS via `LIMIT 999999999`)",
"remediation": "Use parameterized queries for the values and validate that `limit` ... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/render')
def render_page():
page = request.args.get('page', 'home')
with open(f'templates/{page}.html') as f:
return f.read() | {
"vulnerability_type": "Path Traversal / Local File Inclusion",
"location": "Line 7 — `page` is embedded in a file path without sanitization, allowing `../../etc/passwd` to be read from disk",
"remediation": "Validate `page` against an explicit allowlist of permitted page names: `PAGES = {'home', 'about', 'conta... |
Review this Python code for security issues:
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/api/token', methods=['POST'])
def get_token():
username = request.form['username']
password = request.form['password']
user = db.query_one('SELECT * FROM users WHERE username=? AND pas... | {
"vulnerability_type": "Insecure Token Generation + Plaintext Password Storage",
"location": "Line 9 — the token is simply the user's database ID (guessable); and the password is likely stored/compared in plaintext since no hashing is applied",
"remediation": "Store passwords hashed with `bcrypt`. Issue tokens u... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/preview')
def preview():
html = request.args.get('html', '')
return f'<html><body>{html}</body></html>' | {
"vulnerability_type": "Cross-Site Scripting (XSS) — Direct HTML Injection",
"location": "Line 6 — raw HTML from the query string is embedded directly in the response body; attackers can inject `<script>` tags or event handlers",
"remediation": "Escape user-supplied HTML using `markupsafe.escape(html)` before em... |
Review this Python code for security issues:
from flask import Flask, request
import zipfile, io
app = Flask(__name__)
@app.route('/unzip', methods=['POST'])
def unzip():
f = request.files['archive']
z = zipfile.ZipFile(io.BytesIO(f.read()))
z.extractall('/var/www/uploads/')
return 'Extracted' | {
"vulnerability_type": "Zip Slip (Path Traversal via Archive Extraction)",
"location": "Line 9 — `extractall()` is called without checking member paths; a crafted zip containing entries like `../../etc/cron.d/backdoor` can write files outside the target directory",
"remediation": "Validate each archive member pa... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/user', methods=['PUT'])
def update_user():
data = request.json
user = User(**data) # maps all JSON keys to model fields
db.session.merge(user)
db.session.commit()
return 'Updated' | {
"vulnerability_type": "Mass Assignment",
"location": "Line 7 — `User(**data)` maps all JSON fields directly to model attributes; an attacker can set privileged fields like `is_admin=true` or `role='superuser'`",
"remediation": "Accept only an explicit allowlist of fields: `allowed = ['name', 'email']; safe_data... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/login', methods=['POST'])
def login():
username = request.form.get('username')
password = request.form.get('password')
user = db.get_user(username)
if user and user.password == password:
... | {
"vulnerability_type": "Plaintext Password Comparison",
"location": "Line 9 — passwords are compared in plaintext, meaning they are stored unhashed in the database; a breach exposes all user passwords immediately",
"remediation": "Hash passwords at registration using `bcrypt.hashpw(password.encode(), bcrypt.gens... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.errorhandler(500)
def handle_error(e):
return str(e), 500
@app.route('/divide')
def divide():
a = int(request.args.get('a', 1))
b = int(request.args.get('b', 1))
return str(a / b) | {
"vulnerability_type": "Sensitive Information Disclosure via Error Messages",
"location": "Line 6 — the 500 error handler returns the full exception string `str(e)` to the client, leaking internal details like stack traces, file paths, and library versions",
"remediation": "Return a generic error message to clie... |
Review this Python code for security issues:
from flask import Flask, request
from functools import wraps
app = Flask(__name__)
def require_auth(f):
@wraps(f)
def decorated(*args, **kwargs):
token = request.headers.get('Authorization')
if token:
return f(*args, **kwargs)
re... | {
"vulnerability_type": "Insufficient Authentication — Token Presence Without Validation",
"location": "Line 9 — the decorator only checks that the `Authorization` header is non-empty; any non-empty string (including `'invalid'`) grants access",
"remediation": "Validate the token cryptographically: decode and ver... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/hash')
def hash_data():
data = request.args.get('data', '')
import hashlib
return hashlib.sha1(data.encode()).hexdigest() | {
"vulnerability_type": "Use of Weak Hash Function (SHA-1) for Security Purposes",
"location": "Line 7 — SHA-1 is used for hashing; it is cryptographically broken and should not be used for security-sensitive operations such as password hashing, token signing, or integrity verification",
"remediation": "For non-p... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api')
def api():
key = request.args.get('api_key')
if key == 'hardcoded-api-key-123':
return get_sensitive_data()
return 'Forbidden', 403 | {
"vulnerability_type": "Hardcoded API Key in Source Code",
"location": "Line 7 — the API key is hardcoded as a plaintext string literal, making it trivially discoverable in version control or decompiled binaries",
"remediation": "Load API keys from environment variables: `VALID_KEY = os.environ.get('API_KEY')`. ... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/send_email', methods=['POST'])
def send_email():
to = request.form.get('to')
subject = request.form.get('subject')
body = request.form.get('body')
import smtplib
server = smtplib.SMTP('... | {
"vulnerability_type": "Email Header Injection",
"location": "Line 11 — `subject` and `body` are interpolated directly into the raw SMTP message; newline characters in `subject` can inject additional headers (e.g., `Bcc:`, `From:`)",
"remediation": "Strip newline characters from `subject`: `subject = subject.rep... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/calc')
def calc():
a = request.args.get('a', '0')
b = request.args.get('b', '0')
result = eval(f'{a} + {b}')
return str(result) | {
"vulnerability_type": "Remote Code Execution via eval()",
"location": "Line 8 — `eval()` is called on a string built from user-supplied `a` and `b` values; injecting `__import__('os').system('id')` in either parameter executes shell commands",
"remediation": "Parse `a` and `b` as floats before arithmetic: `resu... |
Review this Python code for security issues:
from flask import Flask, request, jsonify
import jwt
app = Flask(__name__)
@app.route('/verify')
def verify_token():
token = request.headers.get('Authorization')
payload = jwt.decode(token, options={'verify_signature': False})
return jsonify(payload) | {
"vulnerability_type": "JWT Signature Verification Disabled",
"location": "Line 8 — `verify_signature: False` disables JWT signature validation entirely; any attacker-crafted token with arbitrary claims will be accepted",
"remediation": "Always verify the JWT signature: `payload = jwt.decode(token, SECRET_KEY, a... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/webhook', methods=['POST'])
def webhook():
event = request.json.get('event')
user_id = request.json.get('user_id')
if event == 'payment_success':
upgrade_user(user_id)
return 'OK' | {
"vulnerability_type": "Missing Webhook Signature Verification",
"location": "Lines 5-10 — the webhook endpoint processes events without verifying the request comes from the legitimate payment provider; any caller can trigger `upgrade_user()`",
"remediation": "Verify the webhook signature provided in the request... |
Review this Python code for security issues:
from flask import Flask, request, session
app = Flask(__name__)
@app.route('/login', methods=['POST'])
def login():
username = request.form['username']
user = authenticate(username, request.form['password'])
if user:
session['user'] = user.to_dict()
... | {
"vulnerability_type": "Session Fixation",
"location": "Lines 8-9 — after successful login, the session ID is not regenerated; an attacker who pre-set a session cookie can hijack the authenticated session",
"remediation": "Regenerate the session after login: in Flask, call `session.clear()` before setting new se... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/v1/items', methods=['GET'])
def get_items():
items = db.execute('SELECT * FROM items').fetchall()
return str(items)
@app.route('/api/v1/items/<id>', methods=['DELETE'])
def delete_item(id):
... | {
"vulnerability_type": "SQL Injection via URL Path Parameter",
"location": "Line 11 — the `id` URL parameter is interpolated into a DELETE query with an f-string; crafted values can drop tables or exfiltrate data",
"remediation": "Use a parameterized query: `db.execute('DELETE FROM items WHERE id=?', (id,))`. Ad... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/jobs', methods=['POST'])
def run_job():
job_name = request.form.get('job')
schedule = request.form.get('schedule')
os.system(f'crontab -l | echo "{schedule} /jobs/{job_name}" | crontab -')
... | {
"vulnerability_type": "Command Injection via Crontab Manipulation",
"location": "Line 8 — both `schedule` and `job_name` are user-controlled and embedded in a shell command; an attacker can inject arbitrary cron entries or shell commands",
"remediation": "Never construct cron entries from user input via shell c... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/search', methods=['POST'])
def search_es():
query = request.json.get('query')
result = es.search(index='users', body={
'query': {'match': {'name': query}}
})
return str(result) | {
"vulnerability_type": "Elasticsearch Injection / Denial of Service",
"location": "Lines 6-9 — the raw `query` value is inserted into an Elasticsearch query body; an attacker can craft a deeply nested or computationally expensive query causing DoS",
"remediation": "Validate `query` as a plain string with a maxim... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/file')
def read_file():
path = request.args.get('path')
try:
with open(path) as f:
return f.read()
except Exception as e:
return str(e) | {
"vulnerability_type": "Path Traversal + Information Disclosure via Exception",
"location": "Lines 7-10 — arbitrary file paths are accepted and read; exceptions reveal the full server path and file system structure to the caller",
"remediation": "Reject the request if `path` is not within a safe base directory (... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/encode')
def encode():
data = request.args.get('data')
import base64
encoded = base64.b64encode(data.encode()).decode()
return f'<p>Encoded: {encoded}</p>' | {
"vulnerability_type": "Cross-Site Scripting (XSS) — Base64 is Not Sanitization",
"location": "Line 8 — `encoded` is embedded in HTML output; while base64 seems safe, the surrounding HTML context means if the encoding logic is bypassed or `data` is reflected elsewhere unencoded, XSS is possible. Additionally, the ... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/config')
def show_config():
return {
'db_host': app.config['DB_HOST'],
'db_user': app.config['DB_USER'],
'db_pass': app.config['DB_PASS'],
'secret_key': app.secret_key
... | {
"vulnerability_type": "Sensitive Configuration Exposure",
"location": "Lines 6-11 — the endpoint returns database credentials and the application secret key in plaintext to any caller without authentication",
"remediation": "Remove this endpoint entirely or restrict it to authenticated administrators. Never exp... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/xslt', methods=['POST'])
def transform():
xml = request.data
xslt_str = request.headers.get('X-XSLT')
from lxml import etree
xslt_doc = etree.fromstring(xslt_str.encode())
transform = e... | {
"vulnerability_type": "XSLT Injection — Remote Code Execution",
"location": "Lines 7-10 — user-supplied XSLT is compiled and applied; XSLT can include `<xsl:value-of select=\"document('/etc/passwd')\"/>` or use extension functions to execute shell commands",
"remediation": "Never accept user-supplied XSLT. Use ... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/forgot', methods=['POST'])
def forgot_password():
email = request.form.get('email')
user = db.get_by_email(email)
if user:
send_reset_email(email)
return 'Reset email sent'
... | {
"vulnerability_type": "User Enumeration via Differential Response",
"location": "Lines 10-11 — the endpoint returns different responses depending on whether the email exists, allowing attackers to enumerate valid accounts",
"remediation": "Return the same response regardless of whether the email exists: `return... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/v1/invoice/<invoice_id>')
def get_invoice(invoice_id):
invoice = Invoice.query.get(invoice_id)
return jsonify(invoice.serialize()) | {
"vulnerability_type": "Insecure Direct Object Reference (IDOR) / Broken Object Level Authorization",
"location": "Lines 5-7 — the invoice is fetched by ID without verifying the requesting user owns or is authorized to access it",
"remediation": "Add ownership check: `if invoice.user_id != current_user.id: abort... |
Review this Python code for security issues:
from flask import Flask
app = Flask(__name__)
app.config['DEBUG'] = True
app.config['TESTING'] = True
@app.route('/')
def index():
return 'Production app' | {
"vulnerability_type": "Debug Mode Enabled in Production",
"location": "Lines 3-4 — `DEBUG=True` and `TESTING=True` are set; debug mode exposes an interactive Werkzeug console (allows remote code execution) and detailed tracebacks to any visitor",
"remediation": "Set `DEBUG` and `TESTING` to `False` in productio... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/transfer', methods=['POST'])
def bank_transfer():
data = request.json
amount = data['amount']
to = data['to_account']
from_account = data['from_account'] # client-supplied
execute_... | {
"vulnerability_type": "Broken Function Level Authorization — Client-Supplied Source Account",
"location": "Line 9 — the source account is taken from the client request; an attacker can specify any `from_account` to transfer funds from accounts they don't own",
"remediation": "Derive `from_account` from the auth... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/v1/users', methods=['GET'])
def list_users():
page = int(request.args.get('page', 1))
per_page = int(request.args.get('per_page', 10))
users = User.query.paginate(page, per_page, False)
... | {
"vulnerability_type": "Missing Authentication + Data Overexposure",
"location": "Lines 4-9 — the user list endpoint has no authentication check, and `serialize()` may expose sensitive fields (password hashes, emails, roles) for all users",
"remediation": "Require authentication and admin role before listing use... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/callback')
def oauth_callback():
code = request.args.get('code')
state = request.args.get('state')
# No state validation
token = exchange_code_for_token(code)
session['token'] = token
... | {
"vulnerability_type": "OAuth CSRF — Missing State Parameter Validation",
"location": "Lines 7-10 — the `state` parameter is received but never validated against a session-stored value; this allows CSRF attacks that force a victim to link their account to an attacker's OAuth token",
"remediation": "Generate a ra... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/search')
def search():
q = request.args.get('q', '')
conn = get_db()
cur = conn.cursor()
cur.execute("SELECT id, title FROM articles WHERE title LIKE '%" + q + "%'")
return jsonify(... | {
"vulnerability_type": "SQL Injection via LIKE clause",
"location": "Line 9 — `q` is concatenated inside a LIKE expression without parameterization; an attacker can break out of the string and inject arbitrary SQL",
"remediation": "Use a parameterized query: `cur.execute(\"SELECT id, title FROM articles WHERE ti... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/graphql', methods=['POST'])
def graphql_endpoint():
query = request.json.get('query', '')
variables = request.json.get('variables', {})
# No query complexity or depth limit
result = schema.... | {
"vulnerability_type": "GraphQL Denial of Service — Unbounded Query Complexity",
"location": "Lines 8-9 — there is no complexity or depth limit on GraphQL queries; an attacker can submit deeply nested or circular queries that exhaust server resources",
"remediation": "Integrate `graphql-core` with a complexity a... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/admin/delete_user', methods=['POST'])
def delete_user():
user_id = request.form.get('user_id')
if request.form.get('confirm') == 'yes':
db.delete_user(user_id)
return redirect('/admin/u... | {
"vulnerability_type": "Cross-Site Request Forgery (CSRF) on Admin Destructive Action",
"location": "Lines 4-9 — the delete action lacks a CSRF token; a malicious page with a hidden form can delete any user account by tricking an admin into visiting it",
"remediation": "Add CSRF token validation using `flask-wtf... |
Review this Python code for security issues:
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/api/run', methods=['POST'])
def run_command():
cmd = request.json.get('command')
allowed = ['ls', 'pwd', 'whoami']
if cmd.split()[0] in allowed:
result = subprocess.check_outpu... | {
"vulnerability_type": "Command Injection via Argument Injection despite Allowlist",
"location": "Lines 7-9 — only the first token is checked against the allowlist, but `shell=True` allows argument injection; e.g., `whoami && cat /etc/passwd` passes the check but executes two commands",
"remediation": "Check the... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/notes')
def notes():
user_id = request.args.get('user_id')
notes = Note.query.filter_by(user_id=user_id).all()
return jsonify([n.serialize() for n in notes]) | {
"vulnerability_type": "Broken Object Level Authorization (BOLA / IDOR)",
"location": "Lines 5-7 — `user_id` from the query string is trusted without verifying it matches the authenticated user; anyone can read another user's notes by changing the parameter",
"remediation": "Use the authenticated user's ID from ... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/process', methods=['POST'])
def process():
data = request.data
import marshal
obj = marshal.loads(data)
return str(obj) | {
"vulnerability_type": "Insecure Deserialization via marshal",
"location": "Line 8 — `marshal.loads()` deserializes arbitrary bytecode from user input; crafted payloads can execute arbitrary code or crash the interpreter",
"remediation": "Never deserialize untrusted data using `marshal`, `pickle`, or `shelve`. U... |
Review this Python code for security issues:
from flask import Flask, request, jsonify
from flask_jwt_extended import create_access_token
app = Flask(__name__)
@app.route('/login', methods=['POST'])
def login():
username = request.json.get('username')
password = request.json.get('password')
if username ==... | {
"vulnerability_type": "Hardcoded Default Credentials",
"location": "Line 9 — the application accepts `admin`/`admin` as valid credentials hardcoded in source; this is a well-known default that attackers try first",
"remediation": "Store credentials in the database, hashed with `bcrypt`. Remove all hardcoded cre... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/v1/export')
def export_data():
fmt = request.args.get('format', 'json')
data = db.get_all_records()
if fmt == 'json':
return jsonify(data)
elif fmt == 'csv':
return gene... | {
"vulnerability_type": "CSV Injection (Formula Injection)",
"location": "Line 10 — if `generate_csv(data)` does not escape cell values, database content beginning with `=`, `+`, `-`, or `@` will be interpreted as formulas when opened in spreadsheet software",
"remediation": "Sanitize all cell values in `generate... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/rpc', methods=['POST'])
def rpc():
method = request.json.get('method')
params = request.json.get('params', {})
func = globals().get(method)
if func:
return str(func(**params))
r... | {
"vulnerability_type": "Remote Code Execution via Unrestricted Function Dispatch",
"location": "Lines 7-10 — `globals().get(method)` allows callers to invoke any globally-accessible function by name, including dangerous builtins accessible through `globals()`",
"remediation": "Define an explicit allowlist of per... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/login', methods=['POST'])
def login():
username = request.form['username']
password = request.form['password']
user = db.execute('SELECT * FROM users WHERE username=?', (username,)).fetchone()
... | {
"vulnerability_type": "Open Redirect via `next` Parameter After Login",
"location": "Line 11 — the `next` redirect target is taken from the query string without validation; an attacker can set `?next=https://evil.com` to redirect the user after login",
"remediation": "Validate the `next` URL to ensure it is a r... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/api/v1/password', methods=['PUT'])
def change_password():
user_id = request.json.get('user_id')
new_password = request.json.get('new_password')
db.update_password(user_id, new_password)
ret... | {
"vulnerability_type": "Missing Current Password Verification + IDOR on Password Change",
"location": "Lines 5-8 — the endpoint changes the password for any `user_id` from the request without requiring the current password, and without verifying the caller owns that account",
"remediation": "Require the current ... |
Review this Python code for security issues:
from flask import Flask, request
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
db = SQLAlchemy(app)
@app.route('/report')
def generate_report():
start = request.args.get('start')
end = request.args.get('end')
sql = f"SELECT * FROM orders WHERE c... | {
"vulnerability_type": "SQL Injection via Date Parameters",
"location": "Line 10 — `start` and `end` date strings are embedded directly in SQL with f-strings; an attacker can close the string and inject arbitrary SQL",
"remediation": "Use SQLAlchemy text with bind parameters: `db.engine.execute(text(\"SELECT * F... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/notify', methods=['POST'])
def notify():
phone = request.form.get('phone')
message = request.form.get('message')
client = TwilioClient(ACCOUNT_SID, AUTH_TOKEN)
client.messages.create(to=pho... | {
"vulnerability_type": "SMS Flooding / Smishing Enablement (Missing Rate Limiting and Input Validation)",
"location": "Lines 5-9 — any caller can send arbitrary SMS messages to any phone number with arbitrary content and no rate limiting; this enables SMS flooding and smishing attacks",
"remediation": "Add rate ... |
Review this Python code for security issues:
from flask import Flask, request
app = Flask(__name__)
@app.route('/upload_avatar', methods=['POST'])
def upload_avatar():
img = request.files['image']
filename = img.filename
img.save(f'/var/www/html/avatars/{filename}')
return f'<img src="/avatars/{filena... | {
"vulnerability_type": "Stored XSS + Unrestricted File Upload + Path Traversal",
"location": "Lines 6-9 — filename is unsanitized (traversal), saved to the web root (executable if server runs scripts), and reflected into HTML (XSS via crafted filename like `<script>alert(1)</script>.jpg`)",
"remediation": "Use `... |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 2