Sicherheit & Qualitätssicherung

Als QA geerbten Code billig testen oder sauber absichern?

Du übernimmst eine Codebasis ohne verlässliche Tests, und der nächste Release steht bereits an. Das kleine Budget ist nicht das eigentliche Problem: Gefährlich wird es, wenn ein billiger Sicherheits-Scan als Qualitätssicherung gilt. Meine Position ist unbequem: Sichere zuerst einen einzigen kritischen Ablauf nachweisbar ab, statt die Testabdeckung gleichmäßig zu erhöhen. „Richtig machen“ beginnt mit einer belastbaren Entscheidung darüber, welches Risiko zuerst zählt.

Ein knapper Etat rechtfertigt eine enge Risikowette, keine gleichmäßige Testquote

Bevor du Tests schreibst, frage nach den Folgen eines Fehlers. Welche Aktion kann Geld bewegen, Berechtigungen ändern oder Daten unwiederbringlich löschen? Wer kann sie auslösen, und woran würde der Betrieb merken, dass sie schiefgegangen ist? Für eine geerbte Anwendung ohne Tests sind diese Fragen ergiebiger als ein Coverage-Ziel, weil viele leicht testbare Funktionen wenig Schaden anrichten, während ein ungeschützter Löschpfad kaum Code umfassen muss.

Für den ersten Arbeitstag würde ich eine kleine Risikotabelle anlegen: Ablauf, möglicher Schaden, erreichbare Angriffsfläche, vorhandene Kontrollen und eine Person, die das erwartete Verhalten bestätigen kann. Setze probehalber 3 Abläufe auf die Liste; diese Zahl ist ein anpassbarer Arbeitswert, keine Aussage über die Größe deiner Anwendung. Wähle daraus einen Ablauf, dessen Fehler zugleich fachlich teuer und technisch plausibel ist. Wenn niemand die Sollregel für ihn benennen kann, ist genau das dein erstes Testergebnis: Es fehlt eine überprüfbare Anforderung.

Die Überschrift Sicherheit und Qualitaetssicherung in der Softwareentwicklung benennt ein sinnvolles gemeinsames Ziel; als Reihenfolge für ein knappes Budget wäre mir beides gleichzeitig zu breit, weil ein Team ohne Ausgangstests sonst bei jedem Befund neu über Prioritäten verhandelt. Schreibe stattdessen für den gewählten Ablauf eine kurze Bedrohungsannahme auf: Welche Identität darf ihn ausführen, welche Eingaben sind fremd, und welche Daten dürfen im Fehlerfall nicht erscheinen? OWASP ASVS 5.0.0 kann dabei als Fragenkatalog dienen, aber nicht als pauschales Versprechen, alle Anforderungen bereits erfüllt zu haben.

Ich würde nicht zuerst eine globale Testabdeckung von 80 Prozent verlangen, weil diese frei wählbare Zielzahl weder Autorisierung noch Datenintegrität an den riskanten Stellen belegt. Bestehende Coverage-Werte sind trotzdem nützlich: Miss sie mit coverage.py oder JaCoCo und notiere, welche Zeilen des ausgewählten Ablaufs tatsächlich ausgeführt werden. Die Zahl ist dann eine Beobachtung über Tests, kein Sicherheitsurteil. Wenn du gegenüber dem Management nur Zeit für einen ersten Schritt bekommst, verlange Zeit für diese Auswahl und einen reproduzierbaren Testlauf – nicht für ein Dashboard.

Charakterisierungstests gewinnen am Anfang, solange du ihre Blindstellen offenlegst

Bei unbekanntem Altcode stehen zwei Methoden gegeneinander. Charakterisierungstests halten das heutige Verhalten an einer stabilen Schnittstelle fest; sie gewinnen, wenn Dokumentation fehlt und ein kleiner Eingriff unmittelbar bevorsteht. Ihr Preis ist, dass sie auch einen alten Fehler konservieren können. Ende-zu-Ende-Tests mit Playwright gewinnen, wenn der Schaden erst im Zusammenspiel von Anmeldung, Oberfläche und Server sichtbar wird. Sie kosten mehr für Testdaten, Laufzeit und Fehlersuche; ein fehlgeschlagener Browserlauf sagt oft noch nicht, welche Schicht die Ursache ist.

Für den ausgewählten Ablauf beginne ich deshalb mit einem Charakterisierungstest und ergänze genau dort einen Ende-zu-Ende-Test, wo eine Berechtigungsgrenze sonst unsichtbar bliebe. Zeichne vor dem ersten Test gültige und ungültige Eingaben sowie den erwarteten Nebeneffekt auf. Bei einer Änderung von Zugriffsrechten gehören beispielsweise ein berechtigter Aufruf, ein fremdes Konto und die Kontrolle des gespeicherten Zustands zusammen. Ein HTTP-Status nach RFC 9110 allein reicht nicht, weil eine Anwendung trotz abgewiesener Antwort bereits Daten verändert haben kann.

Unterstelle den folgenden Fall ausdrücklich als Planungsbeispiel: Für den ersten gesicherten Ablauf stehen 2 Arbeitstage zur Verfügung; dieses Zeitfenster musst du an Release-Druck und Testumgebung anpassen. Reserviere davon zuerst Zeit, um Testdaten wiederherstellen zu können. Danach automatisiere den fachlichen Erfolg und den wichtigsten verweigerten Zugriff. Der Test muss bei einem Fehler ein unterscheidbares Signal liefern: „falsches Ergebnis“, „unerlaubter Zugriff gelang“ und „Umgebung nicht verfügbar“ dürfen nicht als derselbe rote CI-Job erscheinen.

„Ordentlich“ bedeutet hier nicht, sofort mehr Testarten einzukaufen. Es bedeutet, die Tests so zu bauen, dass sie wiederholbar sind: feste Testkonten statt geteilter Administratorkonten, kontrollierte Uhrzeit bei zeitabhängigen Regeln und Aufräumen der erzeugten Daten. Für Python kann pytest solche Fälle gut ausführen; bei Java ist JUnit 5 eine naheliegende Wahl. Das Framework entscheidet jedoch nicht über die Aussagekraft, weil ein perfekt laufender Test mit falscher Sollregel nur einen Irrtum zuverlässig wiederholt. Lass deshalb die fachliche Regel und die verbotene Aktion von einer verantwortlichen Person gegenzeichnen.

Ein Sicherheits-Scan ist erst dann hilfreich, wenn seine Funde einen Besitzer haben

Parallel zu den ersten Tests brauchst du ein Inventar der Abhängigkeiten und offensichtlichen Gefahrenstellen. Prüfe Lockfiles und Build-Dateien mit pip-audit für Python, npm audit für Node.js oder OSV-Scanner für mehrere Ökosysteme. Gitleaks hilft bei versehentlich eingecheckten Geheimnissen; Semgrep kann mit gezielten Regeln gefährliche Muster suchen. Keines dieser Werkzeuge beweist Sicherheit, weil es weder deine fachlichen Berechtigungsregeln kennt noch jede tatsächlich erreichbare Ausnutzung zuverlässig erkennt.

Ein sehr billiger erster Blick kann sogar ohne neuen Dienst laufen. Dieses Beispiel setzt Python und ein Git-Repository voraus und meldet lediglich verdächtige Textstellen in versionierten Dateien. Es verändert nichts und darf deshalb weder als Freigabeprüfung noch als vollständiger Scan ausgegeben werden:

python - <<'PY'
import pathlib, subprocess
names = subprocess.check_output(["git", "ls-files", "-z"]).decode().split("\0")
patterns = (b"verify=False", b"shell=True", b"pickle.loads(")
for name in filter(None, names):
    path = pathlib.Path(name)
    if path.suffix not in {".py", ".js", ".ts"} or not path.is_file():
        continue
    for line_no, line in enumerate(path.read_bytes().splitlines(), 1):
        if any(pattern in line for pattern in patterns):
            print(f"{name}:{line_no}: {line[:120].decode(errors='replace')}")
PY

Die Ausgabe liefert Gesprächsanlässe, keine bestätigten Schwachstellen: shell=True kann mit konstanten Argumenten anders zu bewerten sein als mit Nutzereingaben, während ein gefährlicher Aufruf ohne diesen exakten Text unentdeckt bleibt. Prüfe bei jedem Treffer Datenfluss, Erreichbarkeit und vorhandene Schutzmaßnahmen. Bei einer gemeldeten Bibliothek frage zusätzlich, ob die betroffene Funktion überhaupt genutzt wird und ob ein Update das Verhalten des kritischen Ablaufs verändert.

Setze als veränderbaren Startwert 30 Minuten für die Triage eines neuen, möglicherweise ausnutzbaren Fundes an; gemeint ist die erste Zuordnung, nicht die Behebung. Halte fest, wer entscheidet, wer behebt und wann erneut geprüft wird. CVSS 4.0 kann die technische Schwere beschreiben, ersetzt aber diese Prüfung nicht, weil eine hohe Punktzahl ohne erreichbaren Angriffspfad anders behandelt werden muss als ein belegter Zugriff auf fremde Daten. Ich würde nicht jedes Dependency-Update automatisch mergen, weil der dadurch ausgelöste Verhaltenswechsel in einer ungetesteten Anwendung selbst ein Release-Risiko ist.

„Richtig machen“ heißt, für jeden Release denselben Nachweis verlangen zu können

Der Unterschied zwischen Sparlösung und sauberem Vorgehen liegt weniger in der Zahl der Tools als in der Verbindlichkeit. Die Sparlösung liefert einen geprüften Hochrisiko-Ablauf, dokumentierte Lücken und eine Person für jeden offenen Fund. Sauber wird das Verfahren, wenn neue Änderungen diese Nachweise nicht stillschweigend umgehen können: Tests laufen in der CI, fehlgeschlagene Prüfungen sind sichtbar, und eine Ausnahme hat Grund, Zuständigkeit sowie ein Wiedervorlagedatum.

Die Überschrift Sicherheit und QS in der Softwareentwicklung: Best Practices klingt nach einem fertigen Katalog; ich würde sie für deinen Fall eher als Zielzustand lesen, weil eine ungetestete Codebasis zunächst verlässliche Belege für ihre riskantesten Änderungen braucht. Lege deshalb eine kleine Release-Regel fest: Der Charakterisierungstest für den gewählten Ablauf läuft erfolgreich, der verweigerte Zugriff bleibt verweigert, und neue Scanner-Funde sind bewertet. Ein roter Scan darf nicht einfach mit „technische Schuld“ etikettiert werden, weil diese Formulierung weder die aktuelle Gefährdung noch eine Entscheidung dokumentiert.

Als Richtwert zum Nachjustieren kannst du zunächst verlangen, dass ein fehlgeschlagener kritischer Test innerhalb von 1 Arbeitstag einer Ursache oder einer ausdrücklich benannten Untersuchung zugeordnet wird. Messe daneben die tatsächliche Laufzeit des Testjobs und die Zahl der Fehlalarme über mehrere Releases; erst diese eigenen Werte zeigen, ob die Regel im Team durchhaltbar ist. Wenn Tests regelmäßig wegen fremder Dienste scheitern, stabilisiere Daten und Schnittstellen, bevor du weitere Prüfungen als Pflicht einschaltest, weil ein häufig ignoriertes Rot keinen Release schützt.

Für die längerfristige Arbeit hilft NIST SSDF SP 800-218 als Rahmen für Verantwortlichkeiten und sichere Entwicklungsschritte. Übersetze ihn aber in Änderungen an diesem Repository: Wer prüft neue Abhängigkeiten? Wer kann eine Testausnahme genehmigen? Wo liegt der Nachweis für eine behobene Berechtigungslücke? Eine aufwendige Zertifizierungs- oder Toolstrategie vor diesen Antworten wäre für mich falsch, weil sie Prozesskosten erzeugt, ohne den nächsten riskanten Commit besser zu beurteilen.

Der erste Termin gehört dem gefährlichsten Ablauf

Öffne heute die Codebasis und benenne mit dem zuständigen Team genau einen Ablauf, dessen Fehler nicht still bleiben darf. Notiere eine erlaubte und eine verbotene Aktion, die erwarteten Datenänderungen und den Namen der Person, die diese Erwartung bestätigt. Starte erst danach mit dem Test. Wenn schon diese Angaben strittig sind, hast du die erste Sicherheitslücke im Arbeitsprozess gefunden – bevor ein Scanner überhaupt läuft.