TCdPTlUgc29zdGllbmUgaWwgY29pbnZvbGdpbWVudG8gZGVsbGEgQ29yZWEgZGVsIE5vcmQgbmVsIGZ1cnRvIGRpIGNyaXB0b3ZhbHV0YSBkYSAzIG1pbGlhcmRpIGRpIGRvbGxhcmk=

2024-02-22, 08:23

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR298569"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Diversi hacker affiliati alla Corea del Nord sono responsabili del furto di oltre 3 miliardi di dollari tra il 2017 e il 2023.</p>
<p>La Corea del Nord utilizza i fondi raccolti dai furti di criptovalute per sviluppare armi di distruzione di massa.</p>
<p>I fondi raccolti dai beni crittografici rubati ammontano a circa il 30% dei suoi guadagni esteri.</p>
<h2 id="h2-Introduzione800215"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Probabilmente, la più grande minaccia per gli asset digitali come le criptovalute è la loro perdita attraverso mezzi illeciti come l’hacking e le truffe. L’emergere di cyber-criminali organizzati rende la situazione grave poiché alcuni di loro utilizzano metodi avanzati per rubare asset digitali a individui e organizzazioni.</p>
<p>Molti progetti di criptovaluta hanno perso molte criptovalute a causa di hacking. In questa analisi, esaminiamo le attività illecite di criptovaluta di alcuni hacker affiliati alla Corea del Nord.</p>
<p>Importante sapere: <a href="https://www.gate.io/learn/articles/general-security-principles-in-blockchain/358" target="_blank">Principi generali di sicurezza nella blockchain</a></p>
<h2 id="h2-Lassalto20crittografico20della20Corea20del20Nord205820cyberattacchi20finanziano20lo20sviluppo20delle20armi20di20distruzione20di20massa20afferma20il20rapporto20dellONU580231"><a name="L’assalto crittografico della Corea del Nord: 58 cyberattacchi finanziano lo sviluppo delle armi di distruzione di massa, afferma il rapporto dell’ONU" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’assalto crittografico della Corea del Nord: 58 cyberattacchi finanziano lo sviluppo delle armi di distruzione di massa, afferma il rapporto dell’ONU</h2><p>I monitor delle sanzioni delle Nazioni Unite hanno recentemente riferito che diversi gruppi organizzati nordcoreani, operanti sotto il Reconnaissance General Bureau - l’agenzia di intelligence estera principale del paese - sono stati coinvolti nel furto di criptoattività negli ultimi anni, rubando oltre 3 miliardi di dollari attraverso attacchi informatici.</p>
<p>Secondo <a href="https://www.reuters.com/technology/cybersecurity/un-experts-investigate-58-cyberattacks-worth-3-bln-by-north-korea-2024-02-08/" rel="nofollow noopener noreferrer" target="_blank">Reuters</a> Nel periodo compreso tra il 2017 e il 2023, l’ONU ha individuato 58 attacchi informatici che potrebbero essere stati condotti da hacker affiliati alla Corea del Nord, causando la perdita di cripto-attività del valore di circa 3 miliardi di dollari.</p>
<p>Lo stesso rapporto menziona che la Corea del Nord sta mirando sempre di più alle catene di approvvigionamento e alle aziende della difesa. Il possibile motivo del furto di criptovalute della Repubblica Democratica Popolare di Corea (DPRK) potrebbe essere quello di finanziare il proprio programma di sviluppo di armi di distruzione di massa (WMD).</p>
<p>La pubblicazione citava il rapporto dell’ONU secondo cui “Il gruppo sta indagando su 58 presunti attacchi informatici della DPRK a società legate alle criptovalute tra il 2017 e il 2023, del valore approssimativo di 3 miliardi di dollari, che avrebbero aiutato a finanziare lo sviluppo delle armi di distruzione di massa della DPRK”.</p>
<p>È essenziale notare che nonostante le sanzioni imposte al paese, la Corea del Nord continua a sviluppare e testare sottomarini d’attacco nucleari, satelliti e missili balistici. Il grafico seguente mostra la perdita totale di criptoattività che gli hacker di criptovalute della Corea del Nord hanno rubato nel corso degli anni.<br><img src="https://gimg2.gateimg.com/image/article/1708589886image.jpg" alt=""><br>Fondi crittografici rubati da hacker affiliati nordcoreani dal 2016 - Chainanalysis</p>
<p>Come noterai da <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a>, Gli hacker di criptovalute legati alla Corea del Nord hanno rubato la maggior quantità di attività criptate nel 2022. Durante quell’anno i gruppi criminali di cripto hanno rubato oltre 1 miliardo di dollari. Tuttavia, nel 2023 c’è stato una riduzione del numero di attacchi legati alla Corea del Nord poiché <a href="https://www.gate.io/blog_detail/3094/daily-news-a-new-vulnerability-in-ios-16-may-cause-crypto-devices-to-be-hacked-north-korean-hackers-stolen-over-200m-in-crypto-in-2023-7-trending-tokens-are-about-to-be-unlocked" target="_blank">rubato criptovalute del valore di circa $340 milioni</a>.</p>
<p>A <a href="https://www.chainalysis.com/blog/2022-biggest-year-ever-for-crypto-hacking/" rel="nofollow noopener noreferrer" target="_blank">Rapporto Chainanalysis</a> ha indicato che il Gruppo Lazarus è stato il leader dell’attività di hacking di criptovalute in Corea del Nord poiché ha rubato circa $1,7 miliardi di criptovalute nel 2022.</p>
<p>A riguardo di questo, <a href="https://www.chainalysis.com/blog/2022-biggest-year-ever-for-crypto-hacking/" rel="nofollow noopener noreferrer" target="_blank">Chainalysis ha detto</a>, “1,1 miliardi di dollari di quel totale sono stati rubati negli hack dei protocolli DeFi, rendendo la Corea del Nord una delle forze trainanti dietro la tendenza agli hack di DeFi che si è intensificata nel 2022.” Questo indica che se non vi è una soluzione alla minaccia supportata dalla Corea del Nord, molte piattaforme DeFi potrebbero continuare a perdere grandi quantità di asset digitali, inclusi criptovalute.</p>
<p>La minaccia sostenuta dalla Corea del Nord va oltre le perdite finanziarie che il settore delle criptovalute affronta. Questo perché i gruppi criminali cripto scambiano infrastrutture e strumenti che potenziano ulteriormente le loro capacità di colpire le criptovalute. Ci si aspetta che, col passare del tempo, l’ecosistema dei criminali informatici crescerà e adotterà tecnologie moderne come intelligenza artificiale (AI) e apprendimento automatico (ML).</p>
<p>Inoltre, il ricavato generato dall’attività di hacking di criptovalute della Corea del Nord rappresenta circa il 30% delle entrate estere del paese, il che può migliorare le capacità militari del regime. La Corea del Nord utilizza anche i fondi rubati per produrre armi convenzionali e munizioni che fornisce ad altri paesi, violando così le sanzioni esistenti.</p>
<p>Il Consiglio di Sicurezza delle Nazioni Unite è improbabile che prenda provvedimenti contro la Corea del Nord a causa della divisione nell’organo. Ciò perché la Cina e la Russia si battono per il mitigare delle sanzioni per attrarre la Corea del Nord a negoziati di denuclearizzazione. Già la Russia e la Cina hanno rafforzato le loro relazioni con la Corea del Nord.</p>
<h2 id="h2-Cyberattacchi20del20Gruppo20Lazarus136638"><a name="Cyberattacchi del Gruppo Lazarus" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cyberattacchi del Gruppo Lazarus</h2><p>Come precedentemente menzionato, il gruppo Lazarus è responsabile della maggior parte delle attività di hacking crittografico della Corea del Nord. Ad esempio, gli Stati Uniti hanno accusato la Corea del Nord di aver rubato oltre 7,8 milioni di dollari di criptovalute da Nomad, una piattaforma di criptovalute. Il gruppo Lazarus è noto per l’uso di servizi di miscelazione. <a href="https://www.gate.io/learn/articles/what-is-tornado-cash/211" target="_blank">come Tornado Cash</a> per riciclare i fondi.</p>
<p>Il <a href="https://www.gate.io/blog_detail/963/north-korean-lazarus-hackers-the-mastermind-behind-the-infamous-ronin-hack" target="_blank">Il gruppo Lazarus è anche accusato di rubare asset crittografici</a> valore 55 milioni di dollari da <a href="/price/coinex-cet" rel="nofollow noopener noreferrer" target="_blank">CoinEx</a> scambio, $117 milioni da Poloniex e $100 milioni da Atomic Wallet, un portafoglio digitale decentralizzato non custodito.</p>
<p>Si tratta della stessa organizzazione criminale cripto che potrebbe aver rubato circa $37,3 milioni in asset cripto dai portafogli caldi di CoinsPaid e $60 milioni di criptovalute da Alphapo, un provider di pagamento cripto centralizzato.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1545/tether%E6%B2%A1%E6%9C%89%E6%94%AF%E6%8C%81%E7%BE%8E%E5%9B%BD%E5%AF%B9%E9%93%BE%E4%B8%8A%E6%B7%B7%E5%B8%81%E5%99%A8tornado-cash%E7%9A%84%E5%88%B6%E8%A3%81" target="_blank">Tether non riesce a mantenere le sanzioni statunitensi contro Tornado Cash</a></p>
<p>Gli altri attacchi informatici legati alla Corea del Nord che implicano il gruppo Lazarus sono Stake.com, un casinò cripto online, che ha perso 41 milioni di dollari in valuta virtuale, così come il <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> Il ponte di Ronin e <a href="/price/harmony-one" rel="nofollow noopener noreferrer" target="_blank">Armonia</a> Gli incidenti del ponte dell’orizzonte. L’elenco degli hack è più lungo di questo e potrebbe includere alcuni colpi di cripto che le persone potrebbero non aver imputato al gruppo legato alla Corea del Nord.</p>
<p>Leggi anche: <a href="https://www.gate.io/id/blog_detail/2158/the-biggest-crypto-heist-in-history" target="_blank">Il più grande furto di criptovalute nella storia</a></p>
<h2 id="h2-Conclusione317551"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Le Nazioni Unite hanno compilato un rapporto in cui accusano la Corea del Nord di aver ideato molti colpi di criptovaluta che hanno comportato la perdita di valute virtuali per un valore superiore a 3 miliardi di dollari tra il 2017 e il 2023. Secondo una fonte, gran parte dei fondi raccolti viene destinata allo sviluppo di armi di distruzione di massa. Al momento, il Consiglio di Sicurezza delle Nazioni Unite non ha un piano operativo per scongiurare la minaccia che la Corea del Nord rappresenta per il mondo.</p>
<h2 id="h2-FAQ20per20Crypto20in20Corea20del20Nord964745"><a name="FAQ per Crypto in Corea del Nord" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FAQ per Crypto in Corea del Nord</h2><h3 id="h3-La20Corea20del20Nord20usa20criptovalute430116"><a name="La Corea del Nord usa criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Corea del Nord usa criptovalute?</h3><p>La Corea del Nord utilizza criptovalute. Alcune di esse vengono utilizzate per finanziare la produzione di armi e munizioni. È stata anche accusata di rubare asset criptografici dai protocolli DeFi attraverso hacking.</p>
<h3 id="h3-Quanta20criptovaluta20ha20rubato20la20Corea20del20Nord42406"><a name="Quanta criptovaluta ha rubato la Corea del Nord?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanta criptovaluta ha rubato la Corea del Nord?</h3><p>Tra il 2017 e il 2023 la Corea del Nord ha rubato più di 3 miliardi di dollari di asset criptati. Il paese ha diversi gruppi di hacker legati al Bureau Generale di Ricognizione, la sua agenzia di intelligence estera primaria.</p>
<h3 id="h3-Quanto20ha20rubato20il20gruppo20Lazarus547037"><a name="Quanto ha rubato il gruppo Lazarus?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto ha rubato il gruppo Lazarus?</h3><p>Corea del Nord <a href="https://www.gate.io/learn/articles/report-interpretation-analysis-of-north-korean-hackers-phishing-groups-and-money-laundering-tools/1535" target="_blank">Il gruppo affilato Lazarus ha rubato più di $1.7 miliardi di criptovalute tra il 2017 e il 2023</a> Il suo principale metodo di rubare gli asset crittografici era l’hacking.</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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>