4oCcU21ldHRpIGRpIHVzYXJlIERhcHBzIeKAnSBJbCBraXQgZGkgY29ubmVzc2lvbmUgZGVsIHBvcnRhZm9nbGlvIGNyaXR0b2dyYWZpY28gZGkgTGVkZ2VyIGxhc2NpYSBnbGkgdXRlbnRpIGVzcG9zdGk=

<p><img src="https://gimg2.gateimg.com/image/article/1703840429RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-In20breve20non20letto562328"><a name="In breve; non letto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In breve; non letto</h2><p>Un exploit del kit di connessione di Ledger Crypto Wallet ha comportato il furto di asset digitali del valore di oltre $500.000.</p>
<p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> ha congelato il portafoglio dell’hacker nel tentativo di ridurre al minimo la perdita di criptoasset dall’hack.</p>
<p>Ledger, Sushiswap e Blockaid hanno dato ai loro utenti indicazioni su cosa fare dopo l’exploit crittografico.</p>
<h2 id="h2-Introduzione518034"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Ledger è diventata l’ultima vittima dell’hacking di criptovalute, perdendo oltre $500,000 di asset digitali. Per gestire l’evento di hacking, l’azienda ha collaborato con vari progetti di criptovalute per ridurre il livello di danni in termini di perdita di asset cripto.</p>
<p>Oggi analizziamo la causa dell’hack di Ledger e il suo effetto sugli utenti di criptovalute e altre organizzazioni. Valuteremo anche come Ledger e i suoi partner hanno attenuato la potenziale perdita.</p>
<h2 id="h2-Attacco20alla20catena20di20approvvigionamento20di20Ledger439167"><a name="Attacco alla catena di approvvigionamento di Ledger" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Attacco alla catena di approvvigionamento di Ledger</h2><p>Il Ledger Connect Kit è stato compromesso da hacker crittografici ancora sconosciuti, con conseguente perdita di oltre $500.000 di criptovalute. A seguito di quell’incidente, Ledger ha avvisato i suoi utenti di non collegare le dApp web3, poiché ciò potrebbe portare a ulteriori perdite di asset digitali.</p>
<p>In sostanza, l’attaccante ha inserito un drenatore di portafogli Java nella sua libreria ‘Ledger dApp Connect Kit’, portando al furto sia di NFT che di criptovalute. <a href="https://github.com/LedgerHQ/connect-kit/tree/main/packages/connect-kit-loader" rel="nofollow noopener noreferrer" target="_blank">Kit di connessione per dApps Ledger</a> consente alle app <a href="/web3" target="_blank" class="blog_inner_link">web3</a> di <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> con i portafogli hardware Ledger.</p>
<p>Il portafoglio Ledger consente agli utenti di acquistare, trasferire e conservare i propri asset digitali, inclusi NFT e criptovalute. Con esso, gli utenti possono conservare i propri asset digitali offline, riducendo così le possibilità di exploit. Il portafoglio supporta molti asset digitali esistenti su diverse blockchain come <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>.</p>
<p>Il motivo per cui Ledger ha avvisato i suoi utenti di evitare di connettersi a vari web3 dapps con cui si è associato è che l’attaccante ha compromesso il suo kit per includere un codice maligno, un wallet drainer. Tuttavia, è importante notare che il wallet drainer può solo rubare gli asset se l’utente connette il suo portafoglio ai dapps correlati.</p>
<p>Secondo un <a href="https://github.com/LedgerHQ/connect-kit/issues/29" rel="nofollow noopener noreferrer" target="_blank">avviso su Github</a> il codice maligno ha colpito le versioni 1.1.5 attraverso 1.1.7 del Connect Kit. Il codice è stato aggiunto attraverso un account NPM compromesso. Pertanto, gli utenti hanno dovuto smettere di connettersi alle web3 dapps associate finché Ledger non ha ripristinato la versione sicura del Connect Kit.</p>
<p>Ledger ha anche avvertito gli utenti riguardo agli attacchi di phishing criptato che erano in corso durante quel periodo, poiché altri attaccanti miravano a approfittare della situazione esistente. Allo stesso tempo, agli utenti è stato consigliato di non condividere le loro frasi di seed o altre informazioni essenziali relative ai loro portafogli.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/674/top-crypto-scams-to-avoid" target="_blank">Principali truffe criptovalute da evitare</a></p>
<p>Poco dopo aver notato l’attacco al suo kit di connessione, Ledger ha comunicato con i suoi utenti, avvertendoli del pericolo potenziale. Ad esempio, l’azienda ha detto: ‘Abbiamo identificato e rimosso una versione maligna del Kit di Connessione Ledger. Una versione autentica sta per essere distribuita per sostituire il file maligno.’</p>
<p>Non interagire con nessuna dApp al momento. Ti terremo informato man mano che la situazione evolve. Il tuo dispositivo Ledger e Ledger Live non sono stati compromessi.</p>
<p>In seguito, ha fornito un aggiornamento della situazione. Ha pubblicato: “La versione maligna del file è stata sostituita con la versione autentica intorno alle 14:35 CET. La nuova versione autentica dovrebbe essere diffusa presto. Forniremo un rapporto completo non appena sarà pronto.”</p>
<p>Notizie correlate: <a href="https://www.gate.io/uk/blog_detail/2237" target="_blank">Perché i furti di criptovalute sono in aumento</a></p>
<p>Ha aggiunto: “Nel frattempo, vorremmo ricordare alla comunità di firmare sempre in modo chiaro le proprie transazioni - ricordate che gli indirizzi e le informazioni presentate sullo schermo del vostro Ledger sono le uniche informazioni autentiche.”</p>
<p>Se c’è una differenza tra lo schermo mostrato sul tuo dispositivo Ledger e lo schermo del tuo computer/telefono, interrompi immediatamente quella transazione.</p>
<h2 id="h2-La20reazione20delle20altre20parti308322"><a name="La reazione delle altre parti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La reazione delle altre parti</h2><p>Dopo la notizia dell’attacco crittografico del Ledger Wallet’s Connect Kit, i partner di Ledger hanno avvisato attivamente i propri utenti per prevenire ulteriori furti.</p>
<p>Blockaid, una società di sicurezza Web3, è stata tra i primi attori a consigliare alla comunità crittografica riguardo all’attacco alla catena di distribuzione. Ha twittato: “Abbiamo rilevato un potenziale attacco alla catena di distribuzione sul kit di collegamento ledger. L’attaccante ha iniettato un payload che svuota il portafoglio nel popolare pacchetto NPM”.</p>
<p>Ha aggiunto: “Dapps che utilizzano le versioni 1.1.4 e successive del kit di connessione di Ledger, incluso <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">Sushi</a>.com e Hey.xyz, sono stati colpiti.</p>
<p>Hudson Jameson, collegamento sviluppatore principale di Ethereum, ha anche avvertito gli utenti di criptovalute hackerate di procedere con cautela. <a href="https://twitter.com/hudsonjameson/status/1735283602340843757" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>«È rischioso utilizzare le dapps attualmente se non si comprendono le librerie di backend che utilizzano. Anche dopo che Ledger corregge il codice errato nella loro libreria, i progetti che utilizzano e distribuiscono quella libreria dovranno aggiornare le cose prima che sia sicuro utilizzare le dapps che utilizzano le librerie web3 di Ledger.»</p>
<p>Metamask <a href="https://twitter.com/MetaMask/status/1735291650614653364?s=20" rel="nofollow noopener noreferrer" target="_blank">ha anche consigliato ai suoi utenti</a> su come procedere dopo lo sfruttamento della criptovaluta. Ha pubblicato: “Utenti Ledger: @blockaid ha identificato un attacco a Ledger Connect Kit. Smetti di usare le dApp.”</p>
<p>Inoltre, ha affermato: “Per favore, smetti di usare dApps. Se sei un utente di MetaMask: assicurati di avere la funzione Blockaid attivata nell’estensione MetaMask prima di effettuare qualsiasi transazione sulla tua portfolio MetaMask. Il team di MetaMask Portfolio sta lavorando alla soluzione e ha già un rimedio pronto che verrà implementato oggi stesso.”</p>
<p>Sushiswap ha anche avvertito i suoi utenti di fare attenzione dopo l’exploit crittografico. Li ha consigliati di non connettersi con nessuna app decentralizzata. Ha pubblicato su X: “Se hai la pagina <a href="/price/sushi-sushi" target="_blank" class="blog_inner_link">Sushi</a> aperta e vedi un inaspettato pop-up ‘Connetti portafoglio’, NON interagire o connettere il tuo portafoglio.”</p>
<p>Matthew Lilley, CTO di Sushi, è stato più esplicito. Ha twittato: “<br><strong>Non interagire con NESSUN dApp fino a ulteriori comunicazioni.</strong> Ci sono diversi protocolli di finanza decentralizzata come Sushi, Metamask, Phantom, <a href="/price/balancer-bal" rel="nofollow noopener noreferrer" target="_blank">Balancer</a>, Lido, Coinbase e Zapper che utilizzano Ledger <a href="https://developers.ledger.com/docs/connectivity/connect-kit" rel="nofollow noopener noreferrer" target="_blank">Kit di connessione</a> software per collegare applicazioni decentralizzate ai loro prodotti.</p>
<p>Pertanto, una volta che un hacker di criptovaluta accede all’interfaccia di un sito web o di un’applicazione, può modificare le funzioni che gli utenti vedono per deviare i loro fondi verso destinazioni errate. Ledger è riuscito a correggere il sistema dopo circa 40 minuti dal momento in cui si è reso conto dello sfruttamento.</p>
<p>Ledger ha fornito un aggiornamento su come si è verificato l’attacco crittografico. Ha dichiarato che il suo ex dipendente è stato vittima di un attacco di phishing crittografico che ha permesso agli hacker di inserire il codice maligno nel suo Connect Kit. Nel tentativo di recuperare il bottino, Tether, l’emittente di stablecoin, ha disabilitato il portafoglio digitale dell’hacker.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1280/the-top-7-best-crypto-wallets" target="_blank">I migliori 7 migliori portafogli criptovaluta</a></p>
<h2 id="h2-Conclusione542291"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Un recente hack di criptovaluta ha portato a criminali informatici che hanno rubato asset digitali per un valore superiore a $600.000. Ciò è seguito all’hacking del Ledger dApps Connect Kit dopo un attacco di phishing. Dopo l’incidente di hacking, diverse aziende di criptovaluta, tra cui Ledger, Sushiswap e Blockaid, hanno avvertito gli utenti di criptovaluta di evitare di utilizzare applicazioni decentralizzate collegate al Ledger dApps Connect Kit.</p>
<h2 id="h2-Domande20frequenti20su20Ledger20Wallet12511"><a name="Domande frequenti su Ledger Wallet?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Ledger Wallet?</h2><h3 id="h3-Cos20Ledger623960"><a name="Cos’è Ledger?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Ledger?</h3><p>Ledger è un’azienda che possiede portafogli criptovalute Ledger, che sono dispositivi utilizzati per conservare asset digitali. L’ecosistema Ledger offre alle persone l’opportunità di acquistare, conservare e vendere asset digitali.</p>
<h3 id="h3-Quale20portafoglio20criptato2020il20pi20sicuro97297"><a name="Quale portafoglio criptato è il più sicuro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quale portafoglio criptato è il più sicuro?</h3><p>La maggior parte delle persone crede che Trezor sia il portafoglio cripto più sicuro sul mercato al momento. Tuttavia, altri portafogli cripto hardware come Ledger sono anche molto sicuri.</p>
<h3 id="h3-Come20mantenere20al20sicuro20i20tuoi20criptovaluta371634"><a name="Come mantenere al sicuro i tuoi criptovaluta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come mantenere al sicuro i tuoi criptovaluta?</h3><p>Puoi mantenere al sicuro la tua criptovaluta conservandola in exchange di criptovalute sicuri come Gate.io. Allo stesso modo, puoi conservare gli asset digitali in portafogli offline come Trezor e Ledger.</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il riposting dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>