SGVkZ2V5IEZpbmFuY2UgY29scGl0byBkYSB1biBhdHRhY2NvIGluZm9ybWF0aWNvIGRhIDQ1IG1pbGlvbmkgZGkgZG9sbGFyaTogdW4gY2FtcGFuZWxsbyBkJ2FsbGFybWUgcGVyIGxhIHNpY3VyZXp6YSBkZWwgYmxvY2tjaGFpbg==

2024-05-08, 06:48

<p><img src="https://gimg2.gateimg.com/image/article/1715150452rdzz.jpeg" alt=""></p>
<h2 id="h2-TL20DR135745"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Hedgey Finance ha perso circa $45 milioni di asset crittografici dopo che gli hacker hanno sfruttato le vulnerabilità DeFi nel suo protocollo.<br>Cyvers s richiede il monitoraggio in tempo reale delle transazioni sui protocolli DeFi.</p>
<p>Cyvers  ha avvertito di possibili operazioni di riciclaggio di denaro dopo che gli asset cripto rubati da Hedgey Finance e FixedFloat sono stati inviati allo stesso indirizzo del portafoglio su Bybit exchange.</p>
<h2 id="h2-Introduzione777103"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La minaccia di attacchi informatici ai protocolli DeFi e ad altre piattaforme basate su blockchain continua. Nonostante le chiamate di allarme che sono state fatte da molto tempo, alcuni protocolli blockchain non riescono a implementare strong misure di sicurezza per evitare possibili minacce. La cosa triste è che nella maggior parte dei casi gli attaccanti utilizzano gli stessi metodi per truffare gli asset digitali.</p>
<p>Questo articolo riguarda come alcuni attaccanti malevoli hanno rubato circa $45 milioni di beni crittografici da Hedgey Finance. In particolare, analizzeremo come gli attaccanti hanno sfruttato le debolezze del protocollo.</p>
<h2 id="h2-Attacco20informatico20a20Hedgey20Finance20causa20una20perdita20di204520milioni823796"><a name="Attacco informatico a Hedgey Finance causa una perdita di $45 milioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Attacco informatico a Hedgey Finance causa una perdita di $45 milioni</h2><p>Il 19 aprile, Hedgey Finance è stato oggetto di un attacco informatico, che ha portato alla perdita di criptoasset del valore di circa 45 milioni di dollari. Gli attaccanti hanno sifonato le criptovalute utilizzando una serie di transazioni. Sono stati prelevati criptoasset per un valore di 2,1 milioni di dollari dal <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> mainnet, mentre sono stati rubati 42,6 milioni di dollari di asset digitali <a href="https://www.gate.io/learn/articles/a-deep-dive-into-arbitrum/487" target="_blank">dalla blockchain Arbitrum</a>. In tutto, criptovalute del valore di circa $44,7 sono state rubate durante l’attacco informatico a Hedge Finance.</p>
<p>Fondamentalmente, Hedgey Finance è un protocollo blockchain che crea e gestisce vincoli di token on-chain, portali di reclamo e blocchi, tra gli altri servizi cripto. L’attacco a Hedgey Finance ha portato a un rinnovato <a href="https://www.gate.io/blog_detail/1672/10-best-defi-protocols-to-invest-during-bear-markets" target="_blank">richieste di protocolli DeFi</a> rafforzare la sicurezza della loro blockchain per prevenire la perdita dei fondi investiti.</p>
<p>Poco dopo aver notato l’attacco informatico, Hedgey Finance ha avvisato i suoi utenti dello sviluppo. Pubblicazione <a href="https://twitter.com/hedgeyfinance/status/1781400318644810138" rel="nofollow noopener noreferrer" target="_blank">su X, ha detto</a>, “Faremo un’analisi approfondita nei prossimi giorni. Al momento siamo concentrati nel lavorare con gli utenti coinvolti nel prodotto di richiesta di token e nel recuperare i fondi persi.”</p>
<p>Inoltre, oltre alle nostre attuali verifiche di sicurezza, stiamo lavorando con ConsenSys Diligence per preparare ulteriori verifiche e procedure di sicurezza per tutti i prodotti. Condivideremo aggiornamenti e informazioni più dettagliate nel corso della settimana.</p>
<h2 id="h2-Cyvers20la20societ20di20sicurezza20informatica20che20ha20rilevato20lincidente632119"><a name="Cyvers, la società di sicurezza informatica che ha rilevato l’incidente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cyvers, la società di sicurezza informatica che ha rilevato l’incidente</h2><p>Cyvers s, uno dei principali cani da guardia della sicurezza informatica, è stato il primo a segnalare alla comunità cripto l’attacco informatico alla criptovaluta Hedgey Finance. Dopo aver notato l’attacco, ha cercato di comunicare con Hedgey Finance attraverso vari canali, ma non ha ricevuto risposta. Inoltre, attraverso il suo sito, Etherscan ha avvertito gli utenti dell’attacco come indica l’immagine seguente.<br><img src="https://gimg2.gateimg.com/image/article/17151506901.jpeg" alt=""><br>Sorgente <a href="https://etherscan.io/address/0xd84f48b7d1aafa7bd5905c95c5d1ffb2625ada46" rel="nofollow noopener noreferrer" target="_blank">Etherscan</a></p>
<p>In particolare, gli hacker hanno scambiato gli asset crittografici rubati in DAI prima di trasferirli nel loro portafoglio digitale. La mancata ricezione da parte di Hedgey Finance degli avvisi dalla comunicazione della società di sicurezza informatica indica la necessità che le aziende basate su blockchain siano sempre attente.</p>
<h2 id="h2-Esplorazione20del20metodo20di20sfruttamento20funzione20CreateLockedCampaign20e20prestiti20flash647195"><a name="Esplorazione del metodo di sfruttamento: funzione ‘CreateLockedCampaign’ e prestiti flash" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Esplorazione del metodo di sfruttamento: funzione ‘CreateLockedCampaign’ e prestiti flash</h2><p>Gli aggressori hanno sottratto gli asset crittografici su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Arbitrum e <a href="https://www.gate.io/price/view/binance-smart-chain" target="_blank">Binance Smart Chain</a> dopo aver superato le difese digitali di Hedgey Finance. Attualmente, molti hacker stanno mirando ai flash loan, una forma di prestito senza garanzie utilizzata in DeFi, poiché possono svuotare diversi asset crittografici attraverso blocchi di transazioni singole.</p>
<p>In questo caso, Cyvers s ha fornito un aggiornamento sul metodo di attacco utilizzato dagli sfruttatori. Gli attaccanti malintenzionati hanno sfruttato le vulnerabilità DeFi all’interno del protocollo di Hedgey Finance. La loro linea di attacco era una vulnerabilità del prestito flash. Per accedere ai prestiti flash hanno sfruttato la funzione ‘createLockedCampaign’ del protocollo.</p>
<p>Il vero problema era la mancanza di convalida dell’input da parte degli utenti di Hedgey Finance. A causa di quella debolezza nella crittografia della sicurezza informatica, l’exploiter ha manipolato il sistema e ottenuto approvazioni di token non autorizzate. Dopo aver acceduto ai token, gli hacker hanno invocato una chiamata alla funzione ‘cancelCampaign’, che ha permesso loro di recuperare i beni approvati e non reclamati.</p>
<p>L’attività finale è stata trasferire gli asset dal contratto delle vittime al proprio. Per riuscire con questo passaggio, hanno evitato l’anticipo da parte dei bot. Gli aggressori hanno rubato token USDC, NOBL e MASA che hanno convertito in DAI. <a href="https://www.gate.io/learn/articles/what-is-pegging-in-crypto/802" target="_blank">una stablecoin ancorata</a> al dollaro degli Stati Uniti. Inoltre, hanno anche acquisito 77,74 milioni di token BONUS.</p>
<p>In seguito a quell’attacco, Cyvers ha consigliato all’industria cripto di adottare un approccio coordinato per prevenire minacce simili. Ha sottolineato la necessità che le applicazioni decentralizzate (dApp) e le società di sicurezza collaborino per mitigare i rischi presenti nel settore al fine di ripristinare la fiducia e la fiducia all’interno dell’ecosistema cripto.</p>
<h2 id="h2-Reazione20e20risposta20di20Hedgey634857"><a name="Reazione e risposta di Hedgey" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reazione e risposta di Hedgey</h2><p>Il team di Hedgey ha riconosciuto il furto di criptovalute attraverso lo sfruttamento del flash loan. Pubblicando sulla sua pagina X, <a href="https://twitter.com/hedgeyfinance/status/1781257581488418862" rel="nofollow noopener noreferrer" target="_blank">ha detto</a>, “Stiamo indagando su un attacco al Contratto di Richiesta del Token Hedgey. Se hai creato richieste attive, ti preghiamo di cancellarle utilizzando la funzione ‘Fine Richiesta Token’.</p>
<p>Nel frattempo, il team ha annunciato di aver avviato un’indagine su quanto accaduto. Ha dichiarato di essere al lavoro con gli auditor per identificare la vera causa dell’attacco informatico e ha promesso di implementare misure più forti per la protezione degli asset digitali al fine di evitare che si verifichino exploit simili in futuro.</p>
<p>Un’ulteriore triste sviluppo che si è verificato dopo che la notizia dell’attacco ha raggiunto il mercato delle criptovalute è stata l’usurpazione di Hedge Finance da parte di diversi account truffa. Hanno pubblicato messaggi, con potenziali <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> dannosi, chiedendo agli utenti di Hedgey Finance di revocare le autorizzazioni del contratto intelligente o richiedere rimborsi.</p>
<h2 id="h2-Preoccupazioni20per20il20riciclaggio20di20denaro851591"><a name="Preoccupazioni per il riciclaggio di denaro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Preoccupazioni per il riciclaggio di denaro</h2><p>Cyvers ha suggerito che gli asset crittografici rubati potrebbero essere utilizzati per il riciclaggio di denaro a scopi crittografici. Ciò segue un trasferimento di una grande quantità di fondi alla borsa crittografica Bybit. In precedenza, lo stesso indirizzo ha ricevuto molti fondi crittografici da FixedFloat, un’altra borsa di criptovalute, che ha subito anche un furto di criptovalute di 2,8 milioni di dollari.</p>
<p>Il furto di criptovalute di Hedgey Finance indica un aumento delle minacce alla sicurezza all’interno del settore DeFi. Pertanto, sottolinea la necessità che le aziende DeFi implementino servizi di monitoraggio delle criptovalute in tempo reale e l’adozione di meccanismi di risposta rapida.</p>
<h2 id="h2-Storia20delle20sfruttature20di20Crypto20nel202024776663"><a name="Storia delle sfruttature di Crypto nel 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Storia delle sfruttature di Crypto nel 2024</h2><p>L’attacco di Hedgey Finance fa parte di una tendenza più ampia all’interno del settore delle criptovalute. Alcuni di questi attacchi sono collegati al riciclaggio di denaro in cripto perpetrato da gruppi criminali organizzati come il Gruppo Lazarus, un affiliato del governo nordcoreano. Secondo Cyvers s, finora nel 2024 sono stati rubati complessivamente quasi 739,7 milioni di dollari di criptovalute, come indica il grafico successivo.<br><img src="https://gimg2.gateimg.com/image/article/17151508472.jpeg" alt=""><br>Source: <a href="https://twitter.com/Cyvers_/status/1777640598230684103/photo/1" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Sulla base di tali statistiche è chiaro che i cyber-attaccanti che mirano ai protocolli DeFi sono al corrente delle misure di sicurezza blockchain in evoluzione. Allo stesso tempo, è necessario un impegno concertato tra i protagonisti del settore blockchain per evitare ulteriori danni in futuro.</p>
<h2 id="h2-Conclusione157017"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Hedgey Finance ha perso quasi 45 milioni di dollari di attivi crittografici attraverso una recente violazione della sicurezza del protocollo. Gli attori malintenzionati informatici stanno sempre più mirando alle piattaforme che offrono prestiti flash perché possono far perdere molte criptovalute attraverso poche transazioni. Nel frattempo, Cyvers  ha chiesto l’unità di intenti tra le aziende di sicurezza blockchain e i protocolli DeFi per prevenire future sfruttamenti crittografici.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>