WvdS Crypto Service implementira več zaščitnih mehanizmov, ki so samodejno aktivni. Ničesar vam ni treba konfigurirati.

Ščiti pred napadi zavrnitve storitve (DoS) z obremenitvijo.

Obnašanje ob prekoračitvi:

Zahteva --> [Rate Limiter] --> Status: 0x07 (RATE_LIMITED)
                           --> Kriptografska operacija ni izvedena

Priporočilo za odjemalce:

• Pri statusu 0x07: Počakajte in ponovite z backoff
• Eksponentna čakalna doba: 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;  // Ni rate-limited
 
        usleep(delay_ms * 1000);
        delay_ms *= 2;  // Eksponentni backoff
        retry++;
    }
    return -1;  // Timeout
}

Crypto Service aktivno ščiti pred ponovno uporabo nonce:

• Nonce generira storitev (CSPRNG)
• Odjemalec ne more predložiti lastne nonce
• Vsaka nonce se uporabi samo enkrat

• Storitev shranjuje uporabljene nonce (Bloom Filter)
• Pri ponovljeni nonce: Status 0x08 (NONCE_REUSE)
• Velikost okna: 1 milijon nonce

Opomba: Sledenje nonce je na ključ-ID. Pri rotaciji ključa se sledilnik ponastavi.

Vsi vnosi se preverijo pred obdelavo:

Brez izjem:

Storitev ne vrže izjem. Vse napake se sporočijo preko statusnih kod.

Razlogi:

• Velikost skupnega pomnilnika omejena
• Zaščita pred DoS (izčrpanje pomnilnika)
• Predvidljiv čas izvajanja

Šifriranje velikih podatkov:

// Chunked Encryption za velike datoteke
#define CHUNK_SIZE (60 * 1024)  // 60 KB na kos
 
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 vsebuje Chunk-ID za zaščito vrstnega reda
        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;
}

Vsi varnostno kritični podatki se po uporabi prepišejo:

• Ključi (po kriptografski operaciji)
• Čistopisi (po šifriranju)
• Skupne skrivnosti (po izmenjavi ključev)

Implementacija:

// Prepreči optimizacijo prevajalnika
static void secure_zero(void* ptr, size_t len) {
    volatile uint8_t* p = (volatile uint8_t*)ptr;
    while (len--) *p++ = 0;
}

Crypto Service teče kot izoliran L4Re task:

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

Varnostne garancije:

• Lasten naslovni prostor (brez neposrednega dostopa do pomnilnika)
• Dovoljen samo ekspliciten IPC (na osnovi zmožnosti)
• Brez dostopa do omrežja (air-gapped)

< API Referenca | Naprej: Skladnost >