JDQxMiBNaWxpb25pIFBlcnNpIG5lbCBRMyAyMDI0IGluIE1lenpvIGFsIE1pZ2xpb3JhbWVudG8gZGVsbGUgTWlzdXJlIGRpIFNpY3VyZXp6YQ==

2024-10-09, 07:36

<p><img src="https://gimg2.gateimg.com/image/article/17284589211690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR121980"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Durante il Q3 del 2024, i cattivi attori conservano circa $412 milioni di criptovalute dagli scambi.</p>
<p>A luglio, WazirX ha perso $235 di criptovalute a causa di hacker, mentre valute digitali del valore di circa $52 milioni sono state sottratte da BingX.</p>
<p>La custodia autonoma degli asset digitali può aiutare a prevenire le perdite di criptovalute.</p>
<h2 id="h2-Introduzione686658"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>I crimini crittografici rimangono una delle sfide più grandi per l’adozione delle valute digitali. Questo perché gli investitori che evitano il rischio temono di mettere i loro soldi in attività digitali. Invece, scelgono di concentrarsi su attività di investimento tradizionali come valute estere e materie prime come l’oro. Tuttavia, il lancio di diversi ETF crittografici spot potrebbe attirare tali investitori nel settore. Questa analisi esamina le perdite crittografiche che sono avvenute nel terzo trimestre (Q3) del 2024 a causa di azioni maliziose come l’hacking.</p>
<h2 id="h2-Il20terzo20trimestre20del20202420registra20perdite20per2041220milioni20di20dollari20in20criptovalute528136"><a name="Il terzo trimestre del 2024 registra perdite per 412 milioni di dollari in criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il terzo trimestre del 2024 registra perdite per 412 milioni di dollari in criptovalute</h2><p>A <a href="https://downloads.ctfassets.net/t3wqy70tc3bv/4wrLxaFvKa4NQXA43uPWri/80111984054b3b959e4e2a918537f233/Immunefi_Crypto_Losses_in_Q3_2024.pdf" rel="nofollow noopener noreferrer" target="_blank">rapporto di Immunefi</a> Una società di sicurezza blockchain mostra che durante il terzo trimestre il settore criptato ha perso circa $412,994,499 attraverso azioni maliziose come hacking e frodi criptate. Secondo il rapporto, l’hacking rappresentava circa il 99,25% delle perdite totali criptate. In altre parole, circa $409,906,947 sono stati persi attraverso l’hacking. Al contrario, solo lo 0,75% delle perdite criptate è avvenuto a seguito di frodi.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog/1275/why-many-crypto-assets-are-falling" target="_blank">Perché molti asset crittografici stanno cadendo</a></p>
<h2 id="h2-Rapporto20sulla20sicurezza20delle20criptovalute20le20perdite20diminuiscono20del204020anno20su20anno120686"><a name="Rapporto sulla sicurezza delle criptovalute: le perdite diminuiscono del 40% anno su anno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rapporto sulla sicurezza delle criptovalute: le perdite diminuiscono del 40% anno su anno</h2><p>Sebbene le perdite di cripto del Q3 sembrino molto elevate, c’è stato una diminuzione del 40% dell’importo di asset digitali rubati dal Q3 del 2023. Secondo il rapporto di Immunefi, la sicurezza delle cripto è migliorata notevolmente durante il Q3 del 2024. Questo perché c’è stato un calo nell’importo delle valute digitali rubate. Ad esempio, durante il Q3 del 2023, le perdite totali di cripto ammontavano a 685 milioni di dollari. D’altra parte, durante il Q2 di quest’anno c’è stata una perdita totale di 572 milioni di dollari. Pertanto, in termini generali, i casi di frodi cripto sono diminuiti dell’86%.</p>
<p>La buona notizia è che c’è stato un significativo <a href="https://www.gate.io/learn/course/crypto-security-fraud-safety-and-hack" target="_blank">aumento dei casi di frode criptata</a> La diminuzione delle perdite nelle criptovalute indica che molti progetti di criptovaluta hanno migliorato le loro misure di sicurezza del blockchain. È importante notare, però, che <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> hacks and <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> le perdite della catena sono rimaste relativamente alte. In termini specifici, più della metà degli hack crypto <a href="https://www.gate.io/blog/1008/15-biggest-crypto-hacks-and-heists" target="_blank">avvenuto su catene Ethereum e BNB</a>. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha subito 15 attacchi riusciti e la catena <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> ne ha avuti 8. Altre blockchain che sono state violare includono Base, Blast, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, e Arbitrum. Il fatto che la maggior parte delle blockchain precedentemente fortemente colpite non sia più nella lista indica che potrebbero aver migliorato le loro misure di protezione degli asset crittografici.</p>
<h2 id="h2-Finanza20decentralizzata20vs20Finanza20centralizzata20Dove20si20trovano20i20rischi24139"><a name="Finanza decentralizzata vs Finanza centralizzata: Dove si trovano i rischi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Finanza decentralizzata vs Finanza centralizzata: Dove si trovano i rischi</h2><p>I trend attuali dei furto di criptovalute mostrano che gli exchange centralizzati hanno perso più asset digitali degli exchange decentralizzati. Ad esempio, circa il 74,8% delle perdite di criptovalute che si sono verificate durante il terzo trimestre sono avvenute su <a href="https://www.gate.io/learn/articles/whats-cefi/288 &quot;Centralized Finance (CeFi" rel="nofollow noopener noreferrer" target="_blank">Piattaforme di Finanza Centralizzata (CeFi)</a> Questo significa che gli attacchi DeFi rappresentano solo il 25,20% delle perdite totali del terzo trimestre. Indica anche un miglioramento della sicurezza delle finanze decentralizzate.</p>
<p>In generale, tuttavia, la maggior parte delle perdite di CeFi provenivano dagli hack crittografici di WazirX, una borsa crittografica indiana, che ha perso 235 milioni di dollari a luglio, e BingX, una borsa con sede a Singapore, che ha perso 52 milioni di dollari all’inizio di settembre. Questi due incidenti di furto crittografico rappresentano circa il 69,5% di tutte le perdite del terzo trimestre. Ciò dimostra i rischi degli investimenti crittografici che derivano dalle vulnerabilità della finanza centralizzata. Mostra anche la necessità di migliorare la sicurezza crittografica del settore.</p>
<p>Riguardo all’ultimo rapporto, Mitchell Amador, CEO di Immunefi, ha dichiarato: “Stiamo riscontrando un numero maggiore di incidenti” <a href="https://www.gate.io/learn/articles/what-is-defi/2815" target="_blank">mirato a DeFi</a>, mentre CeFi ha meno incidenti ma spesso con conseguenze più gravi, con centinaia di milioni di fondi rubati in un singolo attacco. In CeFi, il più grande problema infrastrutturale è la gestione delle chiavi private, che è essenziale per mantenere l’autocustodia degli asset crittografici ma di solito non è soggetta a audit di sicurezza.”</p>
<h2 id="h2-Panoramica20del20pi20grande20hack20di20sicurezza20di20BingX20nel20terzo20trimestre42506"><a name="Panoramica del più grande hack di sicurezza di BingX nel terzo trimestre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica del più grande hack di sicurezza di BingX nel terzo trimestre</h2><p>Come detto, le maggiori perdite CeFi sono state il risultato di attacchi crittografici di BingX e WazirX. In sostanza, WazirX è stato hackerato <a href="https://www.gate.io/learn/articles/gate-research-bitcoin-retraces-to-the-63000-support-level-wazirx-suffers-over-230-million-loss-due-to-attack/3567" target="_blank">il 18 luglio e ha perso circa $235 milioni</a>. Il famigerato gruppo di hacker nordcoreani, Lazarus Group, <a href="https://www.gate.io/blog/3836/un-alleges-north-korea-s-involvement-in-3-billion-crypto-heist" target="_blank">è accusato di quell’attacco</a>. D’altra parte, il 20 settembre BingX è stato violato e ha perso $52 milioni di asset digitali. Durante l’attacco, lo scambio ha perso $13,25 milioni di Ether (ETH), $4,4 milioni di… <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>(USDT) e 2,3 milioni di dollari in Binance Coin (BNB), tra le altre valute digitali. Queste violazioni sono state parte di una serie di attacchi mirati alle borse centralizzate in Asia. Durante settembre Indodax, un exchange indonesiano, ha perso anche 20,58 milioni di dollari a causa di hacker, mentre a maggio l’attacco al giapponese DMM <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha portato alla perdita di asset digitali del valore di circa 305 milioni di dollari. Tutti questi incidenti dimostrano la necessità per gli exchange di criptovalute, sia centralizzati che decentralizzati, di migliorare la loro <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">web3</a> sicurezza dell’ecosistema.</p>
<h2 id="h2-Il20ruolo20dellautogestione20nella20prevenzione20delle20perdite20di20criptovalute718470"><a name="Il ruolo dell’autogestione nella prevenzione delle perdite di criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il ruolo dell’autogestione nella prevenzione delle perdite di criptovalute</h2><p>A seguito di grandi perdite di criptovalute da scambi decentralizzati e centralizzati auto-custodia in criptovalute <a href="https://www.gate.io/learn/articles/blockchain-inion-fraud-schemes-and-how-to-prevent-them/3092" target="_blank">potrebbe aiutare nella riduzione delle frodi criptate</a> e nel garantire la sicurezza degli asset crittografici. L’autocustodia degli asset digitali è importante poiché il possesso dei propri asset digitali aumenta la loro sicurezza. Basato su <a href="https://www.gate.io/learn/articles/hidden-dangers-that-cannot-be-ignored-the-security-challenges-and-threats-of-btc-layer-2-technology/3874" target="_blank">tendenze attuali della sicurezza crittografica mantenendo gli asset digitali in portafogli hardware</a> riduce la possibilità di perderli attraverso l’hacking. In generale, hacker e truffatori mirano a progetti criptati di grandi dimensioni che detengono ingenti quantità di asset digitali. Dedicate meno tempo a mirare a portafogli individuali, in particolare portafogli fisici e altre strutture personali di archiviazione a freddo.</p>
<p>Con l’autocustodia, mantieni le tue chiavi private e frasi seed, il che lascia pochissimo spazio per individui non autorizzati ad accedervi. Infine, l’autocustodia migliora la tua privacy personale in quanto nessuno può facilmente rilevare i saldi dei tuoi asset digitali e le transazioni. Con l’autocustodia puoi adottare diverse misure di miglioramento della sicurezza crittografica come l’uso di biometrici e autenticazioni a due fattori che sono attributi chiave per proteggere gli asset crittografici.</p>
<h2 id="h2-Conclusione260229"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Durante il terzo trimestre dell’anno il settore delle criptovalute ha perso attivi criptati per un valore di $412 milioni a causa di hacker e truffatori. Anche se i cattivi attori hanno preso di mira principalmente gli scambi decentralizzati, gli scambi centralizzati hanno subito maggiori perdite di criptovalute. Le blockchain che sono state violate includono Ethereum, BNB chain, Base, Blast, <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> e Arbitrum. È altamente consigliabile che gli utenti di criptovalute gestiscano i propri asset digitali utilizzando l’autocustodia.</p>
<div class="blog-details-info"><br><div>Autore: Mashell C., 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 ripostare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>