TFwnZXhjaGFuZ2UgZGkgY3JpcHRvdmFsdXRlIHRhaXdhbmVzZSBCaXRvUHJvIG5lbCBtaXJpbm8gZGVnbGkgaGFja2VyIG5vcmRjb3JlYW5p

<p><img src="https://gimg2.gateimg.com/image/gatemarketnews2202506271624044471051323.webp" alt="">
</p><p>Il 2 giugno 2025, un breve post del ricercatore blockchain ZachXBT su Telegram ha suscitato scalpore nel settore degli Asset Crypto: diversi hot wallet sull’exchange di Asset Crypto taiwanese BitoPro hanno registrato flussi di fondi sospetti, per un totale di ben 11,5 milioni di USD.</p>
<p>A questo punto, sono passate quasi 3 settimane dall’effettivo attacco, e l’exchange ha solo sospeso i servizi citando “manutenzione del sistema”, senza menzionare nulla riguardo all’attacco degli hacker.</p>
<h2 id="h2-Cronologia20degli20eventi20dallattacco20segreto20alla20divulgazione20pubblica116029"><a name="Cronologia degli eventi, dall’attacco segreto alla divulgazione pubblica" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cronologia degli eventi, dall’attacco segreto alla divulgazione pubblica</h2><p>L’attacco è avvenuto tra l’8 e il 9 maggio 2025. In quel momento, l’hacker ha sfruttato il periodo di finestra per gli aggiornamenti del sistema del wallet e le migrazioni di asset presso l’exchange per lanciare un attacco al suo vecchio hot wallet.</p>
<p>Diverse blockchain pubblici sono stati colpiti: Tron, Ethereum, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Poligono</a> Gli asset del wallet caldo sull’exchange sono stati gradualmente trasferiti. Dopo che l’hacker ha avuto successo, hanno agito rapidamente, liquidando i fondi al prezzo di mercato tramite exchange decentralizzati (DEX) e trasferendoli al mixer Tornado Cash, o tramite <a href="/price/thorchain-rune" rel="nofollow noopener noreferrer" target="_blank">Thorchain</a> Deposito nel <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> rete tramite cross-chain nel portafoglio Wasabi, tentando di interrompere il percorso di tracciamento dei fondi.</p>
<p>Nonostante gli utenti abbiano segnalato problemi di prelievo, la dichiarazione ufficiale di BitoPro che confermava l’attacco è arrivata il 2 giugno, dopo che ZachXBT lo ha esposto pubblicamente, affermando che “gli asset degli utenti sono intatti e la piattaforma ha riserve sufficienti.”</p>
<p>Il metodo di gestione, rimasto nascosto per tre settimane, ha suscitato forti dubbi all’interno della comunità riguardo alla sua trasparenza e capacità di gestione della crisi.</p>
<h2 id="h2-Analisi20delle20Tecniche20di20Attacco20Un20Classico20Intrusione20di20Ingegneria20Sociale424013"><a name="Analisi delle Tecniche di Attacco: Un Classico Intrusione di Ingegneria Sociale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi delle Tecniche di Attacco: Un Classico Intrusione di Ingegneria Sociale</h2><p>Il 19 giugno, BitoPro ha pubblicato un rapporto di una società di sicurezza di terze parti che confermava che l’attaccante era la nota organizzazione di hacker nordcoreani Lazarus Group.</p>
<p>Il percorso di attacco dimostra chiaramente il suo modus operandi altamente specializzato:</p>
<ul>
<li>Attacco di phishing tramite ingegneria sociale: gli hacker mascherano la comunicazione per prendere di mira i dipendenti di BitoPro, attirandoli a fare clic su <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> o file dannosi.</li><li>Infiltrazione di malware: Il malware impiantato con successo ha eluso i sistemi antivirus della borsa, la protezione degli endpoint e la rilevazione della sicurezza cloud.</li><li>Osservazione di infiltrazione: Gli hacker si nascondono nei computer dei dipendenti della vittima per lungo tempo, osservando i processi operativi, soprattutto prendendo di mira il personale delle attività cloud che controlla la gestione delle risorse Amazon AWS.</li><li>Furto di token e bypass del MFA: furto di token di sessione AWS e bypass diretto dei meccanismi di autenticazione a più fattori (MFA).</li><li>Controlla l’host del portafoglio caldo: Connettiti al server C2 dell’attaccante, inietta istruzioni dannose nell’host responsabile delle transazioni del portafoglio caldo e, infine, simula transazioni legittime per implementare il trasferimento alle 1 del mattino del 9 maggio.</li></ul>
<p>Questo metodo è altamente coerente con i precedenti attacchi di Lazarus al sistema bancario globale SWIFT e a diversi exchange, evidenziando la maturità del suo modello di attacco.</p>
<h2 id="h2-La20Mano20Nascosta20LOmbra20del20Gruppo20Lazarus929212"><a name="La Mano Nascosta: L’Ombra del Gruppo Lazarus" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Mano Nascosta: L’Ombra del Gruppo Lazarus</h2><p>Il Gruppo Lazarus non è un trasgressore per la prima volta. L’organizzazione è ampiamente considerata un gruppo di crimine organizzato sostenuto dal regime nordcoreano, che da tempo mira a rubare beni crypto per finanziare i suoi programmi di armamento.</p>
<p>Il suo record penale è scioccante:</p>
<ul>
<li>Nel 2016, ha tentato di rubare 1 miliardo di dollari dalla banca centrale del Bangladesh sfruttando una vulnerabilità nel sistema SWIFT (alla fine ha trasferito con successo 81 milioni di dollari).</li><li>Nel febbraio 2025, l’exchange ByBit è stato attaccato, portando a un furto record di 1,5 miliardi di dollari in asset crittografici.</li><li>Continuamente mirato ad attacchi alla catena di fornitura degli scambi di Crypto Assets globali, sfruttamenti di vulnerabilità e frodi complesse di ingegneria sociale.</li></ul>
<p>Gli esperti di sicurezza sottolineano che l’organizzazione eccelle nel combinare vulnerabilità tecniche con debolezze umane, e l’incidente di BitoPro lo conferma ancora una volta.</p>
<h2 id="h2-La20risposta20dellexchange20misure20per20rimediare20dopo20che20le20pecore20sono20andate20perse143700"><a name="La risposta dell’exchange, misure per rimediare dopo che le pecore sono andate perse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La risposta dell’exchange, misure per rimediare dopo che le pecore sono andate perse</h2><p>Dopo che l’incidente è stato esposto, BitoPro ha adottato una serie di misure di risposta alla crisi:</p>
<ul>
<li>Spegni immediatamente il sistema del portafoglio caldo per interrompere il percorso dell’attacco.</li><li>Sostituire tutte le chiavi di crittografia rilevanti</li><li>Isolare i sistemi infetti e condurre una ricostruzione ambientale</li><li>Affidare a una società di sicurezza blockchain di terze parti il compito di rintracciare i fondi rubati</li></ul>
<p>Per riconquistare la fiducia, BitoPro ha proattivamente inviato un nuovo indirizzo di wallet caldo alla piattaforma di analisi dei dati on-chain Arkham il 19 maggio, aggiornando i dati di liquidità per la supervisione pubblica.</p>
<p>Il fondatore dell’azienda, Zheng Guangtai, ha sottolineato che “gli asset dei clienti non andranno persi; eventuali perdite saranno a carico della piattaforma,” e ha promesso di migliorare i processi di gestione dei portafogli e i livelli di monitoraggio. La Commissione di Vigilanza Finanziaria di Taiwan è intervenuta, richiedendo all’azienda di rafforzare la sicurezza informatica e di presentare una spiegazione dell’incidente.</p>
<h2 id="h2-Sicurezza20Il20collegamento20pi20vulnerabile20rimane20umano899527"><a name="Sicurezza: Il collegamento più vulnerabile rimane “umano”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sicurezza: Il collegamento più vulnerabile rimane “umano”</h2><p>L’incidente di BitoPro, sebbene l’importo perso sia di gran lunga inferiore al massiccio furto di 1,5 miliardi di dollari di ByBit, rivela vulnerabilità nel settore che sono universali:</p>
<ul>
<li>I periodi di manutenzione diventano finestre ad alto rischio: durante gli aggiornamenti di sistema o le migrazioni di asset, i meccanismi di controllo del rischio possono avere punti ciechi temporanei.</li><li>Le difese tecniche sono difficili da sopportare durante le violazioni di ingegneria sociale: anche i firewall e i meccanismi MFA più sofisticati possono essere completamente compromessi da un dipendente che clicca su un <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> dannoso.</li><li>La crisi della trasparenza aggrava il crollo della fiducia: la divulgazione ritardata e la comunicazione vaga danneggiano spesso la fiducia degli utenti più degli eventi stessi.</li></ul>
<p>“Il più debole “ <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">collegamento</a>“in qualsiasi sistema di sicurezza c’è sempre il fattore umano,” una conclusione che è stata ripetutamente convalidata nei rapporti di sicurezza.</p>
<h2 id="h2-Conclusione20Levoluzione20della20difesa20e20la20battaglia20offensiva20e20difensiva20senza20fine89653"><a name="Conclusione: L’evoluzione della difesa e la battaglia offensiva e difensiva senza fine" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione: L’evoluzione della difesa e la battaglia offensiva e difensiva senza fine</h2><p>L’attacco del Lazarus Group è una minaccia sistemica che l’ecosistema globale delle Crypto Assets continua a fronteggiare. Dalla Banca Centrale del Bangladesh, ByBit a BitoPro, i loro metodi di attacco sono in continua evoluzione, ma il nucleo rimane invariato: sfruttare le debolezze umane per superare le barriere tecniche.</p>
<p>BitoPro ha subito una perdita di 11,5 milioni di USD e ha aggiornato il suo sistema, ma la sfida più grande è: come l’exchange può stabilire una cultura di controllo interno che sia “anti-ingegneria sociale” e ottenere una risposta rapida e trasparente quando si trova di fronte a un’intrusione.</p>
<p>Nel mondo della blockchain, la fiducia è la valuta sottostante, e ogni incidente di hacking mette alla prova se le sue vere riserve sono sufficienti.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team Blog</strong><br><div class="info-tips"><em>Il contenuto qui presente non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate può limitare o vietare l’uso totale o parziale dei Servizi da Luoghi Riservati. Per ulteriori informazioni, si prega di leggere l’Accordo Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="6">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>