Regel
Vermeiden Rekursion ohne Schutz Schutz.
Rekursion ohne angemessener Tiefen Begrenzung Risiken Stapel
Überlauf und erzeugt DoS Sicherheitslücken aus böswilligen
Eingaben. Rekursion mit erzwungener Tiefen Grenzen und angemessenen
Grenzen Überprüfung ist akzeptabel.

Sprachunterstützung: 45+

Einleitung

Rekursive Funktionen ohne Tiefenbegrenzung können den Aufruf-Stack erschöpfen und Abstürze verursachen. Bösartige Eingaben wie tief verschachtelte JSON-Objekte oder zyklische Datenstrukturen können absichtlich unbegrenzte Rekursionen auslösen. Eine einzige manipulierte Anfrage kann Ihren Dienst durch Überschreiten der Stack-Limits zum Absturz bringen und eine Denial-of-Service-Schwachstelle schaffen, die trivial auszunutzen ist.

Warum es wichtig ist

Sicherheitsimplikationen (DoS-Angriffe): Angreifer können Eingaben manipulieren, die eine tiefe Rekursion auslösen und Ihre Anwendung zum Absturz bringen. Tief verschachtelte JSON-, XML- oder verknüpfte Datenstrukturen sind häufige Angriffsvektoren. Eine einzige bösartige Anfrage erschöpft den Stack und legt den gesamten Dienst für alle Benutzer lahm.

Systemstabilität: Stack-Overflow-Fehler bringen den Prozess sofort zum Absturz, ohne graceful degradation. Im Produktivbetrieb bedeutet dies verworfene Anfragen, unterbrochene Transaktionen und Service-Nichtverfügbarkeit. Die Wiederherstellung erfordert einen Neustart der gesamten Anwendung.

Ressourcenerschöpfung: Unbegrenzte Rekursion verbraucht Stack-Speicher exponentiell. Jeder rekursive Aufruf fügt einen Stack-Frame hinzu, und tiefe Rekursionsketten können Megabytes an Speicher verbrauchen. Dies beeinträchtigt andere Prozesse auf demselben Server und kann Out-of-Memory-Bedingungen auslösen.

Code-Beispiele

❌ Nicht konform:

function processNestedData(obj) {
    if (typeof obj !== 'object' || obj === null) {
        return obj;
    }

    const result = {};
    for (const key in obj) {
        result[key] = processNestedData(obj[key]);
    }
    return result;
}

Warum es falsch ist: Ohne Tiefenbegrenzung können Angreifer tief verschachtelte Objekte senden, die Stack-Limits überschreiten. Eingaben wie {a: {a: {a: {...}}}} Eine Verschachtelung von 10.000 Ebenen führt zum Absturz der Anwendung mit einem Stack-Overflow. Die Funktion rekursiert blind, ohne die Tiefe zu prüfen.

✅ Konform:

function processNestedData(obj, depth = 0, maxDepth = 100) {
    if (depth > maxDepth) {
        throw new Error('Maximum nesting depth exceeded');
    }

    if (typeof obj !== 'object' || obj === null) {
        return obj;
    }

    const result = {};
    for (const key in obj) {
        result[key] = processNestedData(obj[key], depth + 1, maxDepth);
    }
    return result;
}

Warum dies wichtig ist: Der maxDepth Parameter begrenzt die Rekursion auf 100 Ebenen, wodurch ein Stack-Überlauf verhindert wird. Diese Grenze ist hoch genug für legitime verschachtelte Datenstrukturen (die meisten realen Daten überschreiten selten 10-20 Ebenen), während sie niedrig genug ist, um Angriffe zu stoppen, bevor sie erheblichen Stack-Speicher verbrauchen. Bösartige tief verschachtelte Eingaben lösen einen Fehler aus, anstatt die Anwendung zum Absturz zu bringen. Die Tiefenprüfung erfolgt vor der Verarbeitung und schlägt schnell fehl, wenn die Grenzen überschritten werden.

Fazit

Fügen Sie allen rekursiven Funktionen, die externe Daten verarbeiten, Tiefenparameter hinzu. Legen Sie angemessene maximale Tiefen basierend auf der erwarteten Komplexität der Datenstruktur fest. Werfen Sie Fehler oder geben Sie Standardwerte zurück, wenn Tiefenlimits überschritten werden, anstatt abzustürzen.