~~NOTOC~~
{{wvds:title>Sicurezza}}

===== Meccanismi di Sicurezza =====

Il WvdS Crypto Service implementa diversi meccanismi di protezione che sono **automaticamente attivi**. Non dovete configurare nulla.

----

==== Rate Limiting ====

Protegge da attacchi Denial-of-Service (DoS) tramite sovraccarico.

| Parametro | Valore |
| Max richieste/secondo | 1000 |
| Tolleranza burst | 100 |
| Cooldown | 100 ms |

**Comportamento al superamento:**

<code>
Richiesta --> [Rate Limiter] --> Stato: 0x07 (RATE_LIMITED)
                             --> Nessuna operazione crypto eseguita
</code>

**Raccomandazione per i client:**
  * Su stato 0x07: Attendere e riprovare con backoff
  * Tempo di attesa esponenziale: 100ms, 200ms, 400ms, ...

<code c>
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;  // Non rate-limited

        usleep(delay_ms * 1000);
        delay_ms *= 2;  // Backoff esponenziale
        retry++;
    }
    return -1;  // Timeout
}
</code>

----

==== Nonce Tracking ====

<WRAP center round alert 80%>
**Riutilizzo Nonce = Catastrofe**

Con AES-GCM, il riutilizzo di una nonce porta alla compromissione completa di entrambi i testi in chiaro!
</WRAP>

Il Crypto Service protegge attivamente dal riutilizzo nonce:

=== Per Encrypt ===

  * La nonce è generata dal servizio (CSPRNG)
  * Il client non può fornire una propria nonce
  * Ogni nonce è usata una sola volta

=== Per Decrypt ===

  * Il servizio memorizza le nonce usate (Bloom Filter)
  * Su nonce ripetuta: Stato 0x08 (NONCE_REUSE)
  * Dimensione finestra: 1 milione di nonce

**Nota:** Il tracking nonce è per Key-ID. Il tracker viene resettato alla rotazione chiavi.

----

==== Validazione Input ====

Tutti gli input vengono validati prima dell'elaborazione:

| Controllo | Codice errore |
| Magic Byte != 0xC7 | 0x01 (INVALID_HEADER) |
| Request-Type sconosciuto | 0x02 (INVALID_TYPE) |
| Lunghezza payload errata | 0x03 (INVALID_PAYLOAD) |
| Key-ID non esiste | 0x04 (KEY_NOT_FOUND) |
| Payload > 64 KB | 0x09 (PAYLOAD_TOO_LARGE) |

**Nessuna eccezione:**

Il servizio non lancia eccezioni. Tutti gli errori vengono restituiti tramite codici di stato.

----

==== Dimensione Massima Payload ====

| Limite | 64 KB (65536 byte) |

Motivi:
  * Dimensione memoria condivisa limitata
  * Protezione DoS (esaurimento memoria)
  * Tempo di esecuzione prevedibile

**Cifrare dati grandi:**

<code c>
// Chunked Encryption per file grandi
#define CHUNK_SIZE (60 * 1024)  // 60 KB per 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 contiene Chunk-ID per protezione ordine
        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;
}
</code>

----

==== Azzeramento al Rilascio ====

Tutti i dati critici per la sicurezza vengono sovrascritti dopo l'uso:

  * Chiavi (dopo operazione crittografica)
  * Testi in chiaro (dopo cifratura)
  * Segreti condivisi (dopo scambio chiavi)

**Implementazione:**

<code c>
// Impedisce ottimizzazione del compilatore
static void secure_zero(void* ptr, size_t len) {
    volatile uint8_t* p = (volatile uint8_t*)ptr;
    while (len--) *p++ = 0;
}
</code>

----

==== Isolamento L4Re ====

Il Crypto Service gira come task L4Re isolato:

<code>
+---------------------------------------------------------------+
|                    L4Re Microkernel                           |
+---------------------------------------------------------------+
|     |              |              |              |            |
|  +--+--+       +---+---+      +---+---+      +---+---+        |
|  | Sigma0 |    | Moe   |      | Crypto |     | OEM   |        |
|  | (Root) |    | (Mem) |      | Service|     | Gateway|       |
|  +--------+    +-------+      +--------+     +--------+        |
|                                   |              |             |
|                                   +--------------+             |
|                                   SOLO questo IPC              |
+---------------------------------------------------------------+
</code>

**Garanzie di sicurezza:**

  * Spazio di indirizzamento proprio (nessun accesso diretto alla memoria)
  * Solo IPC esplicito permesso (basato su capability)
  * Nessun accesso alla rete (air-gapped)

----

==== Risoluzione Problemi ====

| Sintomo | Possibile causa | Soluzione |
| Stato 0x04 persistente | Key-Storage corrotto | Rigenerare le chiavi |
| Stato 0x07 frequente | Rate richieste troppo alto | Batching, caching |
| Stato 0x08 | Rotazione chiavi dimenticata | Generare nuova chiave |
| Performance lente | Modo FIPS + Debug | Usare build release |
| Memory leak | Risposte non elaborate | Pulire memoria condivisa |

----

[[.:api|< Riferimento API]] | [[.:compliance|Continua: Conformità >]]