UG9ydGFmb2dsaW8gZGVsbCdGb25kYXRvcmUgZGkgQXhpZSBJbmZpbml0eSBIYWNrZWQsIGxlIFBlcmRpdGUgc2kgQXZ2aWNpbmFubyBhaSAxMCBNaWxpb25pIGRpIERvbGxhcmk=

2024-03-06, 06:10

<p><img src="https://gimg2.gateimg.com/image/article/1709705993sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR137131"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il 23 febbraio Jeff Zirlin, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> Il co-fondatore ha perso ETH del valore di circa $10 milioni in un furto di criptovaluta.</p>
<p>Nel 2022, il ponte Ronin ha perso criptoattivi per un valore di 622 milioni di dollari attraverso un attacco informatico.</p>
<p>Gli analisti di mercato hanno incoraggiato le parti interessate chiave a cooperare per prevenire i furti di criptovalute.</p>
<p><strong>Parole chiave</strong>: perdite di criptovaluta, furto di criptovaluta, hack di criptovaluta, hacker di criptovaluta, portafogli di criptovaluta, perdite di eth, portafoglio hackerato, portafoglio Ronin, investimenti in criptovaluta, salvare criptovaluta</p>
<h2 id="h2-Introduzione278693"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Con l’aumentare della popolarità delle criptovalute, le attività criminali informatiche che mirano agli asset digitali sono in aumento. Nel 2023, i criminali informatici hanno rubato oltre 1 miliardo di dollari, una cifra che dimostra la minaccia degli attacchi informatici e di altre attività criminali correlate.</p>
<p>Purtroppo, i cattivi hacker mirano ad altre portafogli digitali personali e istituzionali. Lo scopo di questo articolo è esplorare come gli hacker hanno attaccato Jeff Zirlin, co-fondatore dei due portafogli di Axie Infinity.</p>
<h2 id="h2-Jeff20Zirlin20perde209720milioni20di20Ethereum20ETH20a20causa20di20hacker702644"><a name="Jeff Zirlin perde $9.7 milioni di Ethereum (ETH) a causa di hacker" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Jeff Zirlin perde $9.7 milioni di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (ETH) a causa di hacker</h2><p>Il co-fondatore di Axie Infinity, Jeff Zirlin, ha subito il furto di due portafogli digitali il 23 febbraio, con una perdita totale di 3.248 ETH, del valore approssimativo di $9,5 milioni al momento dell’attacco.</p>
<p>Il 23 febbraio, PeckShield, un investigatore blockchain, ha avvisato il pubblico di un portafoglio di balene hackerato. L’hack ha aumentato l’ammontare degli asset digitali rubati quest’anno.<br><img src="https://gimg2.gateimg.com/image/article/170970494411.jpeg" alt=""><br>Origine: <a href="https://twitter.com/PeckShield/status/1760843091916042439" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Zirlin ha confermato l’hack e ha aggiunto che i beni digitali sono stati inviati a Tornado Cash, un mixer di criptovalute. Come mixer di criptovalute, Tornado Cash oscura le transazioni per aumentarne l’anonimato al pubblico.</p>
<p>Zirlin <a href="https://twitter.com/Jihoz_Axie/status/1760845078757511562" rel="nofollow noopener noreferrer" target="_blank">detto su X</a>“Questa è stata una mattinata difficile per me. Due dei miei indirizzi sono stati compromessi. L’attacco è limitato ai miei account personali e non ha nulla a che fare con la convalida o le operazioni della catena Ronin.”</p>
<p>Zirlin ha anche assicurato agli utenti di Ronin che i loro portafogli digitali erano al sicuro. “Inoltre, le chiavi trapelate non hanno nulla a che fare con le operazioni di Sky Mavis. Voglio assicurare a tutti che abbiamo rigorose misure di sicurezza in atto per tutte le attività correlate alla blockchain”, ha aggiunto.</p>
<p>Nonostante il contrattempo dell’hacking, Zirlin rimane positivo e resiliente nei suoi rapporti con gli asset cripto. Ha detto: “Continuerò a spingermi avanti con ognuno di voi in questo viaggio magico. La missione: portare la libertà economica a tutti gli utenti di Internet a cominciare dai giocatori.”</p>
<p>Inoltre, poco dopo la notizia del furto di criptovalute divenne pubblica, un altro co-fondatore di Ronin, Aleksander Larsen, assicurò agli utenti che il ponte ha un’elevata sicurezza e non era stato violato.</p>
<p>Lui <a href="https://twitter.com/Psycheout86/status/1760837760179380279" rel="nofollow noopener noreferrer" target="_blank">chiarito su X</a>: “Il ponte non ha problemi e Ronin non è compromesso… Un portafoglio è chiaramente compromesso come accade su ogni catena, e i fondi vengono incassati con Tornado cash. Il ponte stesso ha la massima sicurezza, è stato sottoposto a molti audit e va in pausa quando vengono prelevate troppe risorse.”</p>
<p>Zirlin ha riconosciuto che la causa dell’exploit era una perdita delle sue chiavi private anziché un compromesso del protocollo Ronin. Come indicato in precedenza, <a href="https://twitter.com/Psycheout86/status/1760837760179380279" rel="nofollow noopener noreferrer" target="_blank">PackShield confermato anche</a> che le perdite di ETH sono state il risultato di una compromissione del portafoglio.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-are-blockchain-bridges-and-how-do-they-work/146" target="_blank">Cosa sono i ponti blockchain e come funzionano?</a></p>
<h2 id="h2-Gli20utenti20Ronin20hanno20ancora20i20ricordi20dellhack20del202022201631"><a name="Gli utenti Ronin hanno ancora i ricordi dell’hack del 2022" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli utenti Ronin hanno ancora i ricordi dell’hack del 2022</h2><p>A seguito dell’ultimo hack del portafoglio Ronin, gli utenti della rete erano preoccupati considerando che il bridge è stato sfruttato anche nel 2022, portando a perdite di criptovaluta superiori a 622 milioni di dollari.</p>
<p>Gli analisti hanno attribuito questo attacco al gruppo Lazarus, affiliato alla Corea del Nord, che ha approfittato della vulnerabilità del protocollo. Inoltre, hanno invitato i protocolli a rafforzare la loro sicurezza per salvaguardare le criptovalute.</p>
<p>La piattaforma di gioco è stata in grado di recuperare solo criptovalute per un valore di $30 milioni. Tuttavia, è riuscita a rimborsare tutti gli asset criptati rubati ai suoi utenti. Il 2024 non è stato immune a rapine di criptovalute.</p>
<p>Già quest’anno si sono verificati diversi hacking nel mondo delle criptovalute. Ad esempio, la quantità di asset criptati rubati da gennaio a febbraio, rispetto al 2023, è aumentata del 713% e del 710% rispettivamente.</p>
<p>Di conseguenza, Philip Hoey, direttore di CoinJournal, ha criticato l’aumento delle perdite criptate nei primi due mesi dell’anno. Secondo Alexablockchain <a href="https://alexablockchain.com/is-2024-the-year-of-crypto-heists/" rel="nofollow noopener noreferrer" target="_blank">pubblicazione</a>, Hoey ha detto, “<br><strong>I dati evidenziano una tendenza preoccupante per l’industria delle criptovalute. Ciò non solo sottolinea la necessità di misure di sicurezza più rigorose, ma richiede anche una collaborazione internazionale per affrontare questo problema</strong>.</p>
<p>Ha continuato: “Poiché assistiamo all’evoluzione delle finanze digitali, è imprescindibile che evolviamo anche le nostre strategie per proteggerle. Ciò include il potenziamento delle misure di sicurezza, la promozione dell’educazione degli utenti e la promozione della cooperazione internazionale per scoraggiare e rispondere in modo più efficace ai crimini crittografici.”</p>
<p>Con l’aumento dei casi di hack di criptovalute, è necessario introdurre misure proattive per salvaguardare gli investimenti in criptovalute se il mercato mira ad aumentare i tassi di adozione delle criptovalute. Tuttavia, ciò richiede uno sforzo concertato da parte di vari attori come regolatori, agenti di forze dell’ordine e l’industria delle criptovalute.</p>
<h2 id="h2-Conclusione660280"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Gli hacker hanno sfruttato i due portafogli criptati di Jeff Zirlin e rubato 3.248 ETH, del valore di circa 9,5 milioni di dollari. Il co-fondatore di <a href="/price/axie-infinity-axs" target="_blank" class="blog_inner_link">Axie Infinity</a> attribuisce l’attacco criptato alle chiavi private trapelate.</p>
<p>Il <a href="https://www.gate.io/blog_detail/796/axie-infinity-and-its-mission-to-be-decentralized" target="_blank">Axie Infinity</a> i fondatori hanno assicurato agli utenti che <a href="https://www.gate.io/learn/articles/what-is-the-ronin-network/492" target="_blank">il Ponte Ronin</a> è sicuro poiché ha misure di sicurezza elevate ed è costantemente sottoposto a verifica. Nel frattempo, gli analisti hanno sollecitato i principali interessati a coordinare i propri sforzi e risorse per prevenire l’aumento dei furto di criptovalute.</p>
<h2 id="h2-Domande20frequenti20sul20Crypto20Hacking200934"><a name="Domande frequenti sul Crypto Hacking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sul Crypto Hacking</h2><h3 id="h3-Aumenteranno20gli20attacchi20informatici20nel20settore20delle20criptovalute20nel202024953045"><a name="Aumenteranno gli attacchi informatici nel settore delle criptovalute nel 2024?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aumenteranno gli attacchi informatici nel settore delle criptovalute nel 2024?</h3><p>Sulla base delle tendenze precedenti, è probabile che il numero di attacchi informatici su criptovalute diminuirà nel 2024. Ciò è dovuto al fatto che il numero di attacchi informatici su criptovalute è diminuito nel 2023 rispetto al 2021 e al 2022. Il numero più alto di furti di criptovalute è avvenuto nel 2022.</p>
<h3 id="h3-La20pi20grande20rapina20crittografica20nel202023228731"><a name="La più grande rapina crittografica nel 2023?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La più grande rapina crittografica nel 2023?</h3><p>L’hack di Mixin Network avvenuto a settembre, in cui gli attaccanti hanno rubato circa 200 milioni di dollari, è probabilmente stato il più grande colpo crittografico del 2023. Gli altri attacchi hanno coinvolto Multichain, che ha perso circa 126 milioni di dollari, Poloniex (126 milioni di dollari), Atomic Wallet (100 milioni di dollari), Heco Chain (87 milioni di dollari), Curve Finance (62 milioni di dollari) e <a href="/price/coinex-cet" rel="nofollow noopener noreferrer" target="_blank">CoinEx</a>($55 milioni).<br>Leggi anche: <a href="https://www.gate.io/blog_detail/2158/the-biggest-crypto-heist-in-history" target="_blank">Il più grande colpo di criptovaluta della storia</a></p>
<h3 id="h3-Dove20tenere20al20sicuro20le20criptovalute733204"><a name="Dove tenere al sicuro le criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dove tenere al sicuro le criptovalute?</h3><p>I migliori luoghi per conservare in sicurezza le criptovalute sono i portafogli hardware e gli exchanges di criptovalute sicuri. Gate.io è uno degli exchanges di criptovalute che offre elevata sicurezza, dove le persone possono conservare le proprie criptovalute.</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 il ripostaggio dell'articolo a condizione che Gate.io venga citato. In tutti i casi, si ricorrerà a azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>