Der WvdS Crypto Service implementiert mehrere Schutzmechanismen, die automatisch aktiv sind. Sie muessen nichts konfigurieren.

Schuetzt vor Denial-of-Service (DoS) Angriffen durch Ueberlastung.

Verhalten bei Ueberschreitung:

Request --> [Rate Limiter] --> Status: 0x07 (RATE_LIMITED)
                           --> Keine Crypto-Operation ausgefuehrt

Client-Empfehlung:

• Bei Status 0x07: Warten und Retry mit Backoff
• Exponentielle Wartezeit: 100ms, 200ms, 400ms, …

int send_with_retry(const uint8_t* request, size_t len) {
    int retry = 0;
    int delay_ms = 100;
 
    while (retry < 5) {
        send_request(request, len);
        int status = get_response_status();
 
        if (status != 0x07) return status;  // Nicht rate-limited
 
        usleep(delay_ms * 1000);
        delay_ms *= 2;  // Exponential backoff
        retry++;
    }
    return -1;  // Timeout
}

Der Crypto Service schuetzt aktiv vor Nonce-Reuse:

• Nonce wird vom Service generiert (CSPRNG)
• Client kann keine eigene Nonce vorgeben
• Jede Nonce wird nur einmal verwendet

• Service speichert verwendete Nonces (Bloom Filter)
• Bei wiederholter Nonce: Status 0x08 (NONCE_REUSE)
• Fenstergroesse: 1 Million Nonces

Hinweis: Das Nonce-Tracking ist pro Key-ID. Bei Key-Rotation wird der Tracker zurueckgesetzt.

Alle Eingaben werden vor der Verarbeitung geprueft:

Keine Exceptions:

Der Service wirft keine Exceptions. Alle Fehler werden ueber Status-Codes zurueckgemeldet.

Gruende:

• Shared Memory Groesse begrenzt
• DoS-Schutz (Memory Exhaustion)
• Vorhersagbare Laufzeit

Grosse Daten verschluesseln:

// Chunked Encryption fuer grosse Dateien
#define CHUNK_SIZE (60 * 1024)  // 60 KB pro Chunk
 
int encrypt_large_file(FILE* in, FILE* out) {
    uint8_t buffer[CHUNK_SIZE];
    size_t bytes_read;
    uint32_t chunk_id = 0;
 
    while ((bytes_read = fread(buffer, 1, CHUNK_SIZE, in)) > 0) {
        // AAD enthaelt Chunk-ID fuer Reihenfolge-Schutz
        char aad[32];
        snprintf(aad, sizeof(aad), "chunk:%u", chunk_id++);
 
        uint8_t ct[CHUNK_SIZE + 28];
        size_t ct_len;
        uint8_t nonce[12], tag[16];
 
        encrypt_message(buffer, bytes_read, aad, strlen(aad),
                       ct, &ct_len, nonce, tag);
 
        fwrite(nonce, 1, 12, out);
        fwrite(tag, 1, 16, out);
        fwrite(ct, 1, ct_len, out);
    }
    return 0;
}

Alle sicherheitskritischen Daten werden nach Verwendung ueberschrieben:

• Schluessel (nach Crypto-Operation)
• Klartexte (nach Verschluesselung)
• Shared Secrets (nach Key-Exchange)

Implementierung:

// Compiler-optimierung verhindern
static void secure_zero(void* ptr, size_t len) {
    volatile uint8_t* p = (volatile uint8_t*)ptr;
    while (len--) *p++ = 0;
}

Der Crypto Service laeuft als isolierter L4Re Task:

+---------------------------------------------------------------+
|                    L4Re Microkernel                           |
+---------------------------------------------------------------+
|     |              |              |              |            |
|  +--+--+       +---+---+      +---+---+      +---+---+        |
|  | Sigma0 |    | Moe   |      | Crypto |     | OEM   |        |
|  | (Root) |    | (Mem) |      | Service|     | Gateway|       |
|  +--------+    +-------+      +--------+     +--------+        |
|                                   |              |             |
|                                   +--------------+             |
|                                   NUR diese IPC                |
+---------------------------------------------------------------+

Sicherheitsgarantien:

• Eigener Adressraum (kein direkter Memory-Zugriff)
• Nur explizite IPC erlaubt (Capability-basiert)
• Kein Netzwerk-Zugang (air-gapped)

< API-Referenz | Weiter: Compliance >