Distinguere GPU identiche

Post del blog: Telling identical GPUs apart from their numerical output

Due GPU dello stesso modello calcolano la stessa somma in un ordine leggermente diverso, e quella differenza basta a distinguerle. Un piccolo kernel CUDA identifica su quale di 19 NVIDIA A40 identiche è stato eseguito con un'accuratezza del 99,1%, usando soltanto i numeri che calcola. Non legge alcun numero di serie e non usa timer.

• Sopravvive ai riavvii. Dopo il riavvio di un container, tutte le 12 misurazioni hanno corrisposto al chip corretto.
• Non poteva essere falsificato. Un attaccante su un chip, regolando ogni impostazione di lancio che controlla, ha raggiunto al massimo una correlazione di 0,616 con l'impronta di un altro chip. I chip autentici corrispondono alla propria con una media di 0,946, e mai al di sotto di 0,916.
• Anche una chiamata predefinita a torch.index_add_ lo rivela. Leggendo soltanto l'output ordinario di quell'operazione si identifica il chip con un'accuratezza del 100% tra GPU sullo stesso driver, e del 78% tra driver diversi.
• Funziona su più modelli: A40, RTX 3090, RTX 4090 e L40S.

Perché funziona: quando migliaia di thread block competono per aggiornare un unico contatore, l'hardware decide chi arriva per primo. Minuscole differenze di fabbricazione tra i core di un chip influenzano quell'ordine sempre nello stesso modo.

La modalità deterministica di PyTorch elimina la fuga di index_add_. Il repository contiene le sonde, ogni misurazione alla base dei numeri seguenti e gli script che riproducono ciascun risultato su una CPU di un laptop.

Risultati

Risultato	Numero	Riproduzione
Sonda attiva, 19 A40 identiche, canale P3 (solo output numerico, senza %smid)	99,1% LOO (111/112), caso 5,3%, separazione 4,28x	analysis/pooled_analyze.py
Sonda attiva, 8 A40	P3 100% LOO, separazione 4,09x, p di permutazione = 0,0005	analysis/analyze_puf.py
Confondente del driver: 4 A40 sullo stesso identico driver (580.159.04)	P3 100% (6,10x), P2 100% (5,43x)	analysis/analyze_puf.py
Riavvio: riavvio del container, stesso die verificato tramite UUID (4 A40)	100% di re-identificazione (12/12), entrambi i canali	analysis/temporal_analyze.py
RTX 3090, 7 chip su 4 versioni di driver	P3 100% LOO (4,55x), P2 100% (8,12x), p = 0,0005	analysis/cross_model_analyze.py
RTX 4090, 2 chip sullo stesso host e driver	P3 6/6 (12,5x), P2 6/6 (17,8x)	analysis/cross_model_analyze.py
L40S, 2 chip	P3 4/4 (17,2x), P2 4/4 (13,8x)	analysis/cross_model_analyze.py
torch.index_add_ passivo, K=65536, 6 A40	100% stesso driver (9/9), 78% tra driver diversi	analysis/passive_analyze.py
Capacità della firma passiva, K=65536	~217 bit indipendenti (A40), ~239 (RTX 4090)	analysis/roc_capacity.py
Falsificazione: l'attaccante esplora ogni parametro di lancio che controlla	migliore falsificazione 0,616 di correlazione vs 0,92 di soglia minima autentica	analysis/forge_analyze.py
Confine: transformer vanilla fwd/bwd, GEMM denso, matmul TF32	bit-identico tra chip, nessuna fuga	analysis/leak_analyze.py, analysis/channel_analyze.py
Difesa: torch.use_deterministic_algorithms(True)	canale passivo eliminato; costo backward 2,5-3,6x; sonda attiva non influenzata	analysis/defense_analyze.py

LOO = classificazione nearest-centroid leave-one-out di singole misurazioni rispetto ai centroidi per chip. Separazione = distanza tra chip / distanza entro il chip.

Come funziona

La sonda (probes/probe_puf.py) è un piccolo kernel cupy. Lancia 4096 blocchi da 128 thread. Ogni thread esegue la stessa catena fissa di FMA, poi il thread 0 di ciascun blocco prende un ticket da un contatore globale con atomicAdd(counter, 1). Il ticket è lo slot di arrivo di quel blocco. Nulla dell'input differisce tra i chip; l'unica cosa che varia è quali blocchi arrivano per primi.

Quell'ordine non è casuale. Il distributore del lavoro mappa gli indici dei blocchi sugli SM secondo uno schema quasi fisso, e ciascun SM su un dato die funziona leggermente più veloce o più lento dei suoi simili a causa delle variazioni di fabbricazione. Mediando su 3000 lanci, ciascun indice di blocco si stabilizza su un rango medio di arrivo che riflette la velocità dell'SM su cui finisce.

fixed kernel, fixed input
        |
        v
blocks race to atomicAdd  -->  arrival slot per block (hardware-decided)
        |
        v  average over 3000 launches
mean arrival rank per block index (P3)  /  per physical SM via %smid (P2)
        |
        v  subtract the cross-chip mean (removes the architecture)
per-chip residual  -->  nearest-centroid match against enrolled chips

Da una singola esecuzione emergono tre canali:

• P3, rango per blocco. Slot di arrivo medio per indice di blocco. Si ricava esclusivamente dall'output numerico del kernel: nessun %smid, nessun timer, nessun contatore privilegiato. Questo è il canale principale.
• P2, rango per SM. Gli stessi slot raggruppati per SM fisica tramite il registro %smid. Il raggruppamento per SM fisica media il rumore termico, quindi P2 regge sotto carico: 100% di re-identificazione (18/18) dopo 60 s di stress a pieno carico.
• P1, somma marginale. Un istogramma del risultato float32 di una riduzione fissa. È debole (separazione di 1,20x su 8 A40), perché la somma distrugge gran parte dell'informazione d'ordine.

Sottrarre la media tra i chip rimuove tutto ciò che i chip condividono (architettura, driver, compilatore) e lascia il residuo per die. Due misurazioni dello stesso chip risultano vicine tra loro; le misurazioni di chip diversi no.

Avvio rapido

git clone https://github.com/divagr18/gpu-instance-fingerprint.git
cd gpu-instance-fingerprint
pip install -r requirements.txt        # numpy + scipy, enough for every analysis

Esegui l'analisi sui dati inclusi (CPU, nessuna GPU necessaria):

python analysis/pooled_analyze.py      # 19 A40s: 111/112 = 99.1%
python analysis/analyze_puf.py "a40_8chip/*.json"   # 8 A40s: P3 100%

Esegui il probe su una GPU:

pip install numpy cupy-cuda12x
python probes/probe_puf.py 3 0 > gpu_a_r0.json   # 3 epochs, replicate 0 (about 2 s per epoch)
python probes/probe_puf.py 3 1 > gpu_a_r1.json

Raccogli alcuni replicati da ciascuna di due o più GPU dello stesso modello, poi:

python analysis/analyze_puf.py "path/to/*.json"

Ogni record JSON riporta l'UUID della GPU, il driver, la versione di cupy e, accanto alle misurazioni, clock e temperatura per epoca. L'analisi raggruppa per nome del modello ed etichetta i chip tramite UUID.

Per eseguire su macchine remote via SSH, scripts/run_remote.sh invia una sonda, la esegue in parallelo su più host e raccoglie il JSON:

OUT_DIR=data/my_run REPS=4 scripts/run_remote.sh probe gpu1=root@HOST1:PORT gpu2=root@HOST2:PORT

docker/Dockerfile crea un'immagine con CUDA 12.8, cupy e la probe preinstallata (docker build -f docker/Dockerfile -t gpu-instance-fingerprint .).

Riprodurre ciascun risultato

Tutti i comandi vengono eseguiti dalla radice del repository su una CPU. Gli script trovano i propri dati in data/ autonomamente.