Confidential Computing - Testiamo la protezione dei dati in memoria
Dopo aver esplorato i principi teorici del Confidential Computing, passiamo alla pratica.
In questa seconda parte vedremo come:
- Creare una Virtual Machine su cloud Azure con supporto a Intel SGX (Software Guard Extensions)
- Avviare sulla macchina due container Docker che eseguono rispettivamente un’applicazione protetta con enclave ed un’applicazione classica che non sfrutta la crittografia in memoria
- Provare tramite memory dump a leggere i dati sensibili in memoria e confronteremo i risultati ottenuti nei due casi
Allacciate le cinture, si parte!
Famiglie di VM che supportano il Confidential Computing
Azure offre due famiglie di macchine virtuali progettate per il Confidential Computing:
- DC Family: Virtual Machines “general purpose”.
- EC Family: Virtual Machines ottimizzate per “memory-intensive workloads”.
Per il nostro laboratorio utilizzeremo una VM della famiglia DC, in particolare la serie DCsv2, queste VM supportano la tecnologia Intel SGX (Software Guard Extensions) per creare enclave di memoria protette.
📌 Curiosità:
Ogni macchina virtuale ha un quantitativo limitato di EPC Memory (Enclave Page Cache), ovvero la porzione di memoria riservata alle enclave dove i dati e il codice restano cifrati anche durante l’esecuzione.
La tabella seguente mostra le configurazioni disponibili per la serie DCs_v2:
| Size Name | Cores | Memory (GB) | EPC Memory (MiB) |
|---|---|---|---|
| Standard_DC1s_v2 | 1 | 4 | 28 |
| Standard_DC2s_v2 | 2 | 8 | 56 |
| Standard_DC4s_v2 | 4 | 16 | 112 |
| Standard_DC8_v2 | 8 | 32 | 168 |
Nella nostra demo utilizzeremo una VM di tipo Standard_DC1s_v2, che offre 1 core, 4 GB di RAM e 28 MiB di EPC Memory. Questa configurazione è perfetta per ambienti di test, demo o piccoli workloads.
Per applicazioni più complesse o per l’addestramento di modelli di machine learning, Azure offre anche la serie DCs_v3, che dispone di un quantitativo di memoria EPC significativamente maggiore, adatta a gestire enclave più grandi e carichi di lavoro reali in produzione.
Creazione della VM in Azure
Creare la VM è molto semplice, può essere creata sia tramite Azure CLI, sia direttamente dal portale, quest’ultimo è il metodo che seguiremo.
Dal menù di creazione di una VM, per trovare facilmente il sizing richiesto, aggiungere un filtro “Type: Confidential Computing”, scegliere poi il sizing “Standard DC1s v2”, selezionare come immagine una delle ultime versioni di Ubuntu Server e completare la creazione della VM con le impostazioni desiderate.
Selezione VM size da portale
Configurazione della VM
Una volta creata la VM, colleghiamoci tramite SSH e installiamo i tool necessari per la nostra demo: Git, Docker e Gcore.
Non andremo a riportare qui i dettagli dell’installazione di questi software, dal momento che esistono diverse guide ufficiali sul web.
Terminiamo la fase di setup clonando il repository GitHub ufficiale di Intel SGX SDK per Linux, che contiene esempi di applicazioni protette con enclave:
git clone https://github.com/intel/confidential-computing-demos.git
cd confidential-computing-demos/intel-sgx/memory_dump_docker
All’interno della cartella memory_dump_docker sono presenti due Docker file: protected.Dockerfile e unprotected.Dockerfile, andiamo ad eseguire la build di entrambe le immagini:
docker build -f protected.Dockerfile -t python_minimal_protected .
docker build -f unprotected.Dockerfile -t python_minimal_unprotected .
Ed eseguiamo i due container in 2 shell differenti in modo da vedere i due output generati in parallelo:
docker run --rm --name python_minimal_unprotected python_minimal_unprotected
docker run --rm --device /dev/sgx_enclave --name python_minimal_protected python_minimal_protected
Le due applicazioni all’interno dei container eseguono un semplice script Python che scrive ogni 2 secondi in memoria una stringa dal valore “topsecret_<id_incrementale>_<stringa_esadecimale>” che rappresenta il nostro dato sensibile e ne stampa a video il valore.
Run applicazione non protetta
Run applicazione protetta
Come vediamo dagli output, le due applicazioni si comportano in modo analogo.
Ora andiamo a verificare cosa succede quando proviamo a leggere la memoria dei due processi.
Memory Dump e analisi dei risultati
Per effettuare il memory dump dei due processi, utilizzeremo gcore, che consente di creare un dump della memoria di un processo in esecuzione.
Il repository clonato in precedenza contiene già uno script bash sniffer.sh che esegue il dump della memoria per entrambi i container.
Apriamo una terza shell ed eseguiamo lo script sui due containers:
./sniffer.sh unprotected
./sniffer.sh protected
Memory dump dell’applicazione non protetta
Memory dump dell’applicazione protetta
Analizziamo i risultati ottenuti:
Applicazione non protetta: nel dump di memoria del processo non protetto, riusciamo a trovare chiaramente le stringhe “topsecret” che rappresentano i nostri dati sensibili. Questo dimostra che i dati in memoria sono accessibili e leggibili quantomeno da un amministratore di sistema. In questo caso io, in qualità di admin, rappresento l’insider threat.
Applicazione protetta: nel dump di memoria del processo protetto, non riusciamo a trovare alcuna traccia delle stringhe “topsecret”. Questo conferma che i dati all’interno dell’enclave SGX sono effettivamente protetti e non accessibili dall’esterno, nemmeno tramite un dump di memoria.
Conclusioni
Attraverso questo laboratorio pratico, abbiamo visto come l’applicazione del Confidential Computing tramite tecnologia Intel SGX possa offrire un livello di protezione avanzato per i dati sensibili durante l’elaborazione.
La capacità di isolare i dati in enclave protette garantisce che anche in scenari di compromissione del sistema operativo o dell’hypervisor, i dati rimangano al sicuro e inaccessibili.
