Zum Hauptinhalt springen

Python · SAST

Python-SAST, das vollständig offline läuft

Auditieren Sie Ihren Python-Code auf OWASP-Top-10-Schwachstellen, Framework-spezifische Fehlkonfigurationen und Abhängigkeitsrisiken — ohne eine einzige Zeile in die Cloud zu senden. Deckt Django, Flask, FastAPI, SQLAlchemy und die Standardbibliothek ab.

Geprüfte Frameworks & Bibliotheken

Wir testen die Abdeckung über Fixtures auf diesen Frameworks. Neue Muster werden in jedem Builtin-Regel-Release ergänzt.

Django Flask FastAPI SQLAlchemy Pyramid Tornado aiohttp Starlette Pandas NumPy Requests urllib3 PyYAML paramiko cryptography pyjwt

Häufigste erkannte CWE-Klassen

Diese CWE-Klassen treten in modernen Codebasen dieser Sprache am häufigsten auf. StaticCodeAudit liefert dedizierte Regeln für jede, gemappt auf OWASP Top 10 / ISO 27001 / ASVS, sofern relevant.

CWE-89

SQL-Injection

String-Formatierung oder f-Strings zum Bau von SQL-Queries — typisch bei cursor.execute(f"SELECT ... {user_input}"), Django .raw() mit Concat, oder SQLAlchemy .text() ohne Bind-Parameter.

Erkannt von SCA-Regel: sql_injection_fstring

CWE-78

OS-Befehlsinjektion

subprocess.run(shell=True, ...), os.system() mit User-Input. Das Flag shell=True ermöglicht Shell-Metazeichen-Missbrauch.

Erkannt von SCA-Regel: os_system_injection

CWE-502

Unsichere Deserialisierung

pickle.loads(), yaml.load() ohne SafeLoader, shelve, oder marshal auf nicht vertrauenswürdigen Bytes. Entspricht Remote Code Execution.

Erkannt von SCA-Regel: unsafe_deserialization

CWE-918

SSRF

requests.get(user_url), urllib.request.urlopen() auf User-kontrollierten URLs ohne Schema-/Host-Allowlist. Lässt Angreifer interne Dienste erreichen (Metadaten-Endpoints, RDS, etc.).

Erkannt von SCA-Regel: taint_ssrf

CWE-798

Hartkodierte Zugangsdaten

API-Keys, JWT-Secrets, DB-Passwörter in Quelldateien. Erkannt durch Entropie + bekannte Muster (AWS, Stripe, GitHub, Slack, etc.).

Erkannt von SCA-Regel: hardcoded_secret

CWE-94

Code-Injektion via dynamische Kompilierung

Aufrufe von Pythons dynamischen Kompilierungs-Built-ins auf teilweise user-kontrollierten Daten.

Erkannt von SCA-Regel: dangerous_eval

Verwundbar vs. sicher — drei kurze Beispiele

CWE-89 Erkannt von SCA-Regel: sql_injection_fstring
❌ Verwundbar
# Verwundbar — Flask + SQLAlchemy raw
@app.route('/user/<name>')
def user(name):
    sql = f"SELECT * FROM users WHERE name = '{name}'"
    return db.engine.execute(sql).fetchone()
✅ Sicher
# Sicher — Bind-Parameter
@app.route('/user/<name>')
def user(name):
    sql = text("SELECT * FROM users WHERE name = :name")
    return db.engine.execute(sql, {"name": name}).fetchone()
CWE-78 Erkannt von SCA-Regel: os_system_injection
❌ Verwundbar
# Verwundbar — shell=True mit User-Input
import subprocess
def ping(host):
    return subprocess.run(f"ping -c 1 {host}", shell=True)
✅ Sicher
# Sicher — Argumentliste, kein Shell
import subprocess
def ping(host):
    return subprocess.run(["ping", "-c", "1", host], check=False)
CWE-502 Erkannt von SCA-Regel: unsafe_deserialization
❌ Verwundbar
# Verwundbar — yaml.load ohne SafeLoader
import yaml
def load_config(blob):
    return yaml.load(blob)  # voller Loader = RCE
✅ Sicher
# Sicher — yaml.safe_load
import yaml
def load_config(blob):
    return yaml.safe_load(blob)

Was StaticCodeAudit erkennt (diese Sprache)

  • SQL-Injection in rohem SQL, f-Strings, .format(), Django .raw(), SQLAlchemy .text() ohne Bind-Parameter
  • OS-Befehlsinjektion (subprocess mit shell=True, os.system, os.popen)
  • Unsichere Deserialisierung (pickle, yaml.load, marshal, shelve)
  • SSRF via requests, urllib, aiohttp mit User-kontrollierten URLs
  • Hartkodierte Secrets (AWS, Stripe, GitHub PAT, Slack-Tokens, JWT-Secrets, DB-Passwörter, PEM-Keys)
  • XXE und Billion-Laughs XML (xml.etree, lxml ohne deaktivierten Resolver)
  • Path Traversal (os.path.join mit User-Input, open() ohne Root-Anchor)
  • Unsichere Cookies (Flask/Django Flags Secure / HttpOnly / SameSite fehlen)
  • CSRF-Ausnahme (@csrf_exempt, Flask ohne flask-wtf)
  • Unsichere Krypto (MD5/SHA1 für Security, ECB-Modus, hartkodierter IV, schwache Zufallszahlen)
  • Debug-Modus aktiviert in Flask-/Django-Produktion
  • Unsicheres JWT (Algorithmus none, hartkodiertes Secret, kein Ablauf)
  • Veraltete APIs (PyCrypto, ssl.TLSv1, urllib2-Stil)
  • PII in Logs und Exception-Nachrichten
  • CI/CD-Fehlkonfigurationen (.gitlab-ci.yml, GitHub Actions: unsicherer Checkout, Secrets in Logs)

Neugierig, wie die Erkennungsqualität tatsächlich gemessen wird? Sehen Sie sich die vollständige sprachübergreifende Benchmark-Methodik an (OWASP Benchmark, NIST Juliet, Precision/Recall/F1 pro Sprache) →

OWASP Benchmark (Python) — unabhängige Validierung

StaticCodeAudit wurde gegen OWASP Benchmark (Python) gemessen — eine öffentliche, reproduzierbare Test-Suite mit 1.230 Python-Testfällen — ergänzt durch einen Realwelt-Check anhand von 3 Frameworks, rekonstruiert aus veröffentlichten CVEs.

86,5%
F1-Score
96,0%
Recall
1.230
Testfälle

CVE Test Suite, nach Framework — 2 von 3 mit F1 = 100%

100%
Flask (aus CVE rekonstruiert)
100%
Django (aus CVE rekonstruiert)
80,0%
Python-stdlib (aus CVE rekonstruiert)

OWASP Benchmark Python erreicht 78,8% Precision bei 96,0% Recall (1.230 Fälle, unabhängige Methodik) — echte Bugs werden erkannt, auf Kosten etwas mehr Rauschens. Die 3 Zeilen oben stammen aus einem separaten, härteren Test: 45 Fälle, rekonstruiert aus echten, historischen CVEs über 8 Frameworks und 5 Sprachen. Pythons 3 Frameworks erzielen dort das beste Ergebnis; vollständige Aufschlüsselung (auch wo andere Sprachen schlechter abschneiden) auf der <a href="/de/language-benchmarks.php" class="text-primary font-semibold hover:underline">Sprachbenchmark-Seite</a>.

Echte Schwachstellen passen selten in eine einzige Datei

Flask- und Django-Anwendungen verteilen die Logik auf mehrere Schichten: eine View empfängt die Anfrage, eine Datenzugriffsfunktion baut die Abfrage. Ein Scanner, der jeweils nur eine Datei sieht, verbindet die beiden nie — er sieht die Nutzereingabe in views.py und den Datenbankaufruf in db.py, aber nie die Verbindung dazwischen. StaticCodeAudit verfolgt die Daten über Dateigrenzen hinweg.

views.py
@app.route("/orders")
def find_order():
    order_id = request.args.get("id")
    return jsonify(get_order(order_id))
db.py
def get_order(order_id):
    sql = f"SELECT * FROM orders WHERE id = {order_id}"
    return db.execute(sql).fetchone()

order_id stammt aus der HTTP-Anfrage in der View und erreicht die SQL-Abfrage eine Datei später unverändert — StaticCodeAudit meldet dies genau in der Zeile, in der die Abfrage ausgeführt wird.

Wie schneidet das im Vergleich zu Bandit oder Semgrep ab?

Bandit und Semgrep sind die zwei Tools, die als Erstes genannt werden, wenn ein Python-Team nach einem kostenlosen Security-Scanner sucht. Beide sind legitim, und viele Teams nutzen bereits eines davon — hier ein ehrlicher Vergleich, keine Abwertung.

Bandit

Kostenlos, Open Source

AST-basierter Scanner, speziell für Python-Sicherheitsprobleme gebaut (hartkodierte Passwörter, shell=True, unsicheres yaml.load). Ausgereift und weit verbreitet, aber auf eine Datei begrenzt: kein dateiübergreifendes Taint-Tracking, und Findings sind standardmäßig nicht auf CWE/ISO 27001/ASVS gemappt.

Semgrep (Community)

Kostenlos, Open-Source-Kern

Pattern-Matching-Engine, die viele Sprachen abdeckt, darunter Python, mit einem großen offenen Regel-Register. Der kostenlose Tier deckt die meisten Alltagsregeln ab; dateiübergreifendes Taint-Tracking, Compliance-Reporting und einige Enterprise-Integrationen sind Semgreps kostenpflichtigen Tiers vorbehalten.

Vollständiger Vergleich StaticCodeAudit vs. Semgrep →

Keines der beiden wird durch die Installation von StaticCodeAudit ersetzt — wenn Bandit bereits das abdeckt, was Ihr Team braucht, nutzen Sie es weiter. Was StaticCodeAudit hinzufügt: Findings, die bereits auf CWE/OWASP/ISO 27001/ASVS/NIST CSF gemappt sind (ein Finding, das direkt in eine Audit-Akte passt, nicht nur eine Regel-ID), dateiübergreifendes Taint-Tracking über Ihre gesamte Flask-/Django-App standardmäßig, und 7 weitere Sprachen, die von derselben Binary abgedeckt werden — kein separater Scanner pro Sprache zu konfigurieren. Viele Teams nutzen beides.

Auditieren Sie Ihren Code

Auditieren Sie Ihren Python-Code auf OWASP-Top-10-Schwachstellen, Framework-spezifische Fehlkonfigurationen und Abhängigkeitsrisiken — ohne eine einzige Zeile in die Cloud zu senden. Deckt Django, Flask, FastAPI, SQLAlchemy und die Standardbibliothek ab.

Demo-Binary herunterladen Geführte Demo buchen