OWASP API Security Top 10 - AI Security Hub

Was ist die OWASP API Security Top 10?

Eine Rangliste der API-spezifischen Sicherheitsrisiken, die von OWASP (Open Worldwide Application Security Project) veröffentlicht wird. Die Ausgabe 2023 bietet die neueste Liste, die die Bedrohungen widerspiegelt, die mit der weit verbreiteten Einführung von APIs zugenommen haben.

1️⃣ API1:2023 - Gebrochene Objektlevel-Autorisierung (BOLA)

Critical

Übersicht

Eine Sicherheitslücke, die durch die Manipulation von Objekt-IDs den unbefugten Zugriff auf die Daten anderer Benutzer ermöglicht. Sie ist als die am häufigsten auftretende und am einfachsten auszunutzende Sicherheitslücke bekannt.

Risiko

Angreifer können auf die persönlichen Daten anderer Benutzer, Zahlungsdetails, den Bestellverlauf und mehr zugreifen, indem sie einfach die ID in der URL oder die Anfrageparameter ändern.

Beispiel für anfälligen Code

        JavaScript (Express)
        ❌ Bad
      

// Empfängt ID und gibt Daten direkt zurück - keine Berechtigungsprüfung
app.get('/api/users/:id/orders', async (req, res) => {
  const orders = await Order.find({ userId: req.params.id });
  res.json(orders);
});

Beispiel für sicheren Code

        JavaScript (Express)
        ✅ Good
      

// Abgleich mit der ID des authentifizierten Benutzers zur Überprüfung der Berechtigung
app.get('/api/users/:id/orders', authenticate, async (req, res) => {
  if (req.user.id !== req.params.id && !req.user.isAdmin) {
    return res.status(403).json({ error: 'Forbidden' });
  }
  const orders = await Order.find({ userId: req.params.id });
  res.json(orders);
});

Checkliste zur Schadensbegrenzung

Implementierung von Berechtigungsprüfungen auf Objektebene an allen Endpunkten
Verwendung von UUIDs anstelle von vorhersehbaren sequentiellen IDs
Zentralisierung der Autorisierungslogik in der Middleware
Erkennen von Autorisierungsumgehungen mit automatisierten Tests

2️⃣ API2:2023 - Fehlerhafte Authentifizierung

Critical

Übersicht

Eine Schwachstelle, die es Angreifern ermöglicht, aufgrund von fehlerhaft implementierten Authentifizierungsmechanismen legitime Benutzerkonten zu übernehmen.

Gemeinsame Probleme

Schwache Passwortrichtlinien, unsachgemäße Token-Verwaltung, fehlender Brute-Force-Schutz, unzureichende Sitzungsverwaltung und vieles mehr.

        JavaScript
        ✅ Beispiel für Abhilfe: JWT-Überprüfung
      

const jwt = require('jsonwebtoken');

function authenticate(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) return res.status(401).json({ error: 'Token required' });

  try {
    // Explizite Angabe des Algorithmus (verhindert alg: none-Angriff)
    const decoded = jwt.verify(token, process.env.JWT_SECRET, {
      algorithms: ['HS256'],
      issuer: 'your-app',
    });
    req.user = decoded;
    next();
  } catch (err) {
    res.status(401).json({ error: 'Invalid token' });
  }
}

Explizite Angabe des Algorithmus bei der Überprüfung von JWT-Signaturen
Kurze Verfallszeiten für Token festlegen (Zugangstoken: innerhalb von 15 Minuten)
Implementierung der Rotation von Aktualisierungs-Token
Begrenzung der Anmeldeversuche erzwingen

3️⃣ API3:2023 - Fehlerhafte Autorisierung auf Objekteigenschaftsebene

High

Übersicht

Eine Schwachstelle, bei der die Zugriffskontrolle auf die Eigenschaften (Felder) von Objekten, die in API-Antworten enthalten sind, unzureichend ist. Dieser Punkt kombiniert Excessive Data Exposure und Mass Assignment.

        JavaScript
        ✅ Antwortfilterung
      

// Nur öffentliche Felder des Benutzerobjekts zurückgeben
function sanitizeUser(user, requesterId) {
  const publicFields = { id: user.id, name: user.name, avatar: user.avatar };

  // Nur der Eigentümer kann zusätzliche Felder sehen
  if (requesterId === user.id) {
    publicFields.email = user.email;
    publicFields.phone = user.phone;
  }

  return publicFields;
  // ❌ return user; würde password_hash etc. durchsickern lassen.
}

Explizite Angabe von Feldern, die in API-Antworten aufgenommen werden sollen (allowlist-Ansatz)
Akzeptierte Felder des Anfragekörpers mithilfe eines Schemas einschränken
Dynamische Filterung von Antwortfeldern auf der Grundlage von Rollen

4️⃣ API4:2023 - Uneingeschränkter Ressourcenverbrauch

High

Übersicht

Eine Schwachstelle, bei der es keine Grenzen für die Größe, Häufigkeit oder den Ressourcenverbrauch von API-Anfragen gibt, was zu DoS-Angriffen oder Kostensteigerungen führt.

        JavaScript (Express)
        ✅ Umsetzung von Ressourcenbeschränkungen
      

const rateLimit = require('express-rate-limit');

// Globale Ratenbegrenzung
app.use(rateLimit({
  windowMs: 15 * 60 * 1000, // 15 Minuten
  max: 100,                   // Maximal 100 Anfragen
  standardHeaders: true,
}));

// Begrenzung der Nutzlastgröße
app.use(express.json({ limit: '10kb' }));

// Obergrenze für die Paginierung
app.get('/api/items', (req, res) => {
  const limit = Math.min(parseInt(req.query.limit) || 20, 100);
  // ...
});

5️⃣ API5:2023 - Gebrochene Autorisierung auf Funktionsebene

High

Übersicht

Eine Schwachstelle, bei der keine angemessene Zugriffskontrolle für Verwaltungsfunktionen und Endpunkte implementiert ist, so dass normale Benutzer Verwaltungsvorgänge durchführen können.

        JavaScript
        ✅ Rollenbasierte Zugangskontrolle
      

function authorize(...roles) {
  return (req, res, next) => {
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({ error: 'Insufficient permissions' });
    }
    next();
  };
}

// Zugang nur für Administratoren
app.delete('/api/admin/users/:id', authenticate, authorize('admin'), deleteUser);

// Verwalter und Moderator
app.put('/api/posts/:id/moderate', authenticate, authorize('admin', 'moderator'), moderatePost);

6️⃣ API6:2023 - Uneingeschränkter Zugang zu sensiblen Geschäftsflüssen

Medium

Übersicht

Eine Schwachstelle, bei der kritische Geschäftslogikabläufe nicht gegen automatisierte Angriffe geschützt sind. Beispiele: Ticket-Scalping, massenhaftes Sammeln von Gutscheinen, Spam-Versand usw.

Abhilfemaßnahmen

CAPTCHA / reCAPTCHA einführen
Geräte-Fingerprinting
Tarifbegrenzung auf Unternehmensebene für Operationen
Erkennung menschlicher Interaktion

7️⃣ API7:2023 - Server Side Request Forgery (SSRF)

High

Übersicht

Eine Schwachstelle, bei der der Server eine vom Benutzer eingegebene URL ohne Validierung abruft, was einen nicht autorisierten Zugriff auf interne Netzwerke ermöglicht.

        JavaScript
        ✅ SSRF-Abschwächung
      

const { URL } = require('url');

function isAllowedUrl(input) {
  try {
    const url = new URL(input);
    // Protokolle einschränken
    if (!['https:', 'http:'].includes(url.protocol)) return false;
    // Private IP-Bereiche sperren
    const blocked = ['127.0.0.1', 'localhost', '0.0.0.0', '169.254.169.254'];
    if (blocked.includes(url.hostname)) return false;
    // Interne Netzbereiche überprüfen (10.x, 172.16-31.x, 192.168.x)
    if (/^(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.)/.test(url.hostname)) return false;
    return true;
  } catch {
    return false;
  }
}

8️⃣ API8:2023 - Fehlkonfiguration der Sicherheit

Medium

Übersicht

Unzulässige Sicherheitseinstellungen auf API-Servern oder Frameworks. Dazu gehören das Zulassen unnötiger HTTP-Methoden, übermäßig freizügige CORS-Richtlinien, die Offenlegung von Debug-Informationen und mehr.

        JavaScript (Express)
        ✅ Konfiguration des Sicherheitskopfes
      

const helmet = require('helmet');
const cors = require('cors');

app.use(helmet());
app.use(cors({
  origin: ['https://app.example.com'], // Keine Wildcards verwenden
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  credentials: true,
}));

// Fehlerbehandlung: keine Rückgabe von Stack Traces in der Produktion
app.use((err, req, res, next) => {
  res.status(500).json({
    error: process.env.NODE_ENV === 'production'
      ? 'Internal Server Error'
      : err.message,
  });
});

9️⃣ API9:2023 - Unsachgemäße Bestandsverwaltung

Medium

Übersicht

Ein Zustand, in dem alte API-Endpunktversionen ohne Sicherheitspatches offengelegt werden. Auch bekannt als Schatten-APIs oder Zombie-APIs.

Abhilfemaßnahmen

Dokumentation und Verwaltung aller API-Endpunkte (OpenAPI/Swagger)
Klare Zeitpläne für veraltete APIs festlegen
Nicht registrierte Endpunkte am API-Gateway blockieren
Regelmäßige Prüfungen des API-Bestands durchführen

🔟 API10:2023 - Unsicherer Verzehr von APIs

Medium

Übersicht

Eine Schwachstelle, bei der Antworten von APIs von Drittanbietern ohne Validierung als vertrauenswürdig eingestuft werden. Wenn eine externe API kompromittiert wird, werden die Auswirkungen auf Ihr eigenes System übertragen.

        JavaScript
        ✅ Validierung externer API-Antworten
      

const Ajv = require('ajv');
const ajv = new Ajv();

// Externe API-Antworten mit einem Schema validieren
const externalSchema = {
  type: 'object',
  required: ['id', 'status'],
  properties: {
    id: { type: 'string', maxLength: 50 },
    status: { type: 'string', enum: ['active', 'inactive'] },
  },
  additionalProperties: false,
};

const validate = ajv.compile(externalSchema);

async function fetchExternalData() {
  const res = await fetch('https://api.external.com/data');
  const data = await res.json();

  if (!validate(data)) {
    throw new Error('External API response validation failed');
  }
  return data;
}

📊 Übersichtstabelle

ID	Schwachstelle	Schweregrad	Schlüssel Abschwächung
API1	Broken Object Level Authorization	Critical	Berechtigungsprüfungen auf Objektebene
API2	Broken Authentication	Critical	Ordnungsgemäße Token-Verwaltung und Brute-Force-Schutz
API3	Broken Object Property Level Authorization	High	Explizite Filterung von Antwortfeldern
API4	Unrestricted Resource Consumption	High	Ratenbegrenzung und Beschränkungen der Nutzlastgröße
API5	Broken Function Level Authorization	High	Rollenbasierte Zugriffskontrolle
API6	Unrestricted Access to Sensitive Business Flows	Medium	CAPTCHA und Tarifbegrenzung auf Unternehmensebene
API7	Server Side Request Forgery	High	URL-Validierung und Blockierung privater IP-Adressen
API8	Security Misconfiguration	Medium	Sicherheits-Header und CORS-Konfiguration
API9	Improper Inventory Management	Medium	API-Bestandsverwaltung und Veralterungsrichtlinien
API10	Unsafe Consumption of APIs	Medium	Schema-Validierung von externen API-Antworten

OWASP API-Sicherheit Top 10 (2023)

1️⃣ API1:2023 - Gebrochene Objektlevel-Autorisierung (BOLA)

Übersicht

Beispiel für anfälligen Code

Beispiel für sicheren Code

Checkliste zur Schadensbegrenzung

2️⃣ API2:2023 - Fehlerhafte Authentifizierung

Übersicht

3️⃣ API3:2023 - Fehlerhafte Autorisierung auf Objekteigenschaftsebene

Übersicht

4️⃣ API4:2023 - Uneingeschränkter Ressourcenverbrauch

Übersicht

5️⃣ API5:2023 - Gebrochene Autorisierung auf Funktionsebene

Übersicht

6️⃣ API6:2023 - Uneingeschränkter Zugang zu sensiblen Geschäftsflüssen

Übersicht

Abhilfemaßnahmen

7️⃣ API7:2023 - Server Side Request Forgery (SSRF)

Übersicht

8️⃣ API8:2023 - Fehlkonfiguration der Sicherheit

Übersicht

9️⃣ API9:2023 - Unsachgemäße Bestandsverwaltung

Übersicht

Abhilfemaßnahmen

🔟 API10:2023 - Unsicherer Verzehr von APIs

Übersicht

📊 Übersichtstabelle