QWxsYXJtZSBkaSBzaWN1cmV6emE6IDIyMCBwcm90b2NvbGxpIERlRmkgZXNwb3N0aSBhIHVuIHBvdGVuemlhbGUgZGlyb3R0YW1lbnRvIGRlbCBETlMgZGkgU3F1YXJlc3BhY2U=

2024-07-24, 07:50

<p><img src="https://gimg2.gateimg.com/image/article/1721807281sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR987778"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Gli attacchi DNS possono reindirizzare i record DNS verso siti web malevoli che possono svuotare i portafogli degli utenti.</p>
<p>Durante le prime due settimane di luglio alcuni attori malintenzionati hanno cercato di compromettere MetaMask. <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a> e Celer Networks, tra gli altri.</p>
<p>Gli utenti dovrebbero utilizzare password robuste per le email, così come l’autenticazione a due fattori per i loro account digitali.</p>
<h2 id="h2-Introduzione363304"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli attaccanti crittografici stanno aumentando i loro metodi per rubare asset digitali agli investitori ignari. Pertanto, è essenziale che le persone che effettuano transazioni crittografiche siano osservanti alle attività insolite sulle reti blockchain con cui interagiscono. Oggi ci concentriamo su come gli attaccanti crittografici stiano utilizzando il dirottamento DNS per rubare alle persone. Esploreremo anche i modi in cui gli investitori possono proteggere i loro asset da tali attacchi.</p>
<h2 id="h2-I20criminali20crittografici20intensificano20i20loro20metodi20come20gli20attacchi20DNS20minacciano20il20settore154501"><a name="I criminali crittografici intensificano i loro metodi: come gli attacchi DNS minacciano il settore" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I criminali crittografici intensificano i loro metodi: come gli attacchi DNS minacciano il settore</h2><p>Un nuovo metodo di attacco crittografico chiamato dirottamento DNS sta minacciando la sicurezza di vari network blockchain. Questo metodo sofisticato che i cattivi attori stanno utilizzando potrebbe influenzare molti protocolli finanziari decentralizzati, con il timore che oltre 220 protocolli DeFi siano attualmente sotto una grande minaccia.</p>
<p>Attraverso il dirottamento di DNS Squarespace, attori malintenzionati possono reindirizzare i record DNS verso indirizzi IP maliziosi utilizzati per svuotare gli asset digitali dai portafogli degli utenti ignari. Già utilizzando questo metodo, questi attaccanti hanno compromesso diversi protocolli DeFi, tra cui Compound, un… <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>-based protocollo DeFi e Celer Network, un protocollo di interoperabilità multi-chain. I portafogli digitali degli utenti che interagiscono con gli endpoint dei protocolli mirati verranno reindirizzati a pagine web che svuoteranno i loro portafogli. È importante notare che nella maggior parte dei casi le vittime vengono ingannate a firmare transazioni malevoli che danno agli attaccanti il pieno controllo dei loro asset. I kit di drenaggio vengono di solito distribuiti attraverso domini compromessi e siti di phishing, quindi molti investitori di criptovalute affrontano rischi di sicurezza DeFi.</p>
<p>Alcuni osservatori hanno fatto notare che questi attaccanti hanno legami con il famigerato Inferno Drainer che utilizza kit avanzati di svuotamento del portafoglio per prendere il controllo degli asset criptati delle vittime attraverso transazioni ingannevoli. Secondo una recente pubblicazione di Decrypt, Ido Ben-Natan, il co-fondatore e CEO di Blockaid, è convinto che Inferno Drainer sia coinvolto in questi furti di criptovalute. In un <a href="https://decrypt.co/239524/220-defi-protocols-risk-squarespace-dns-hijack" rel="nofollow noopener noreferrer" target="_blank">Nell’intervista con Decrypt, Ben-Natan ha detto</a> L’associazione a Inferno Drainer è chiara a causa dell’infrastruttura condivisa onchain e offchain. Questo include gli indirizzi del portafoglio onchain e del contratto intelligente, nonché gli indirizzi IP e i domini offchain collegati a Inferno.</p>
<p>Tuttavia, poiché questi criminali informatici condividono un’infrastruttura on-chain e off-chain, è possibile rintracciarli. Ad esempio, le aziende digitali come Blockaid che lavorano con le comunità e le parti interessate possono aiutare a identificare le vulnerabilità del DNS e mitigare gli effetti di tali attacchi. Tuttavia, una comunicazione chiara e la cooperazione da parte delle varie parti coinvolte sono essenziali per limitare l’estensione dei danni che l’attacco potrebbe causare. Ben-natan ha spiegato: ‘Blockaid è in grado di rintracciare gli indirizzi. Il nostro team ha anche lavorato a stretto contatto con la comunità per garantire l’esistenza di un canale aperto per segnalare i siti compromessi.’<br>Nel lontano novembre 2023, Inferno Drainer ha annunciato l’intenzione di sciogliere la propria operazione. Tuttavia, a giudicare dalle apparenze, il gruppo continua a rappresentare una grave minaccia per la sicurezza informatica nelle criptovalute attraverso dirottamenti del DNS e altri metodi correlati. In base alle recenti tendenze della sicurezza delle criptovalute, Inferno Drainer ha rubato oltre $180 milioni di asset digitali.</p>
<h2 id="h2-Problema20di20dirottamento20DNS20come20funziona138883"><a name="Problema di dirottamento DNS: come funziona" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Problema di dirottamento DNS: come funziona</h2><p>L’attacco DNS si verifica quando i cattivi attori deviano le query di ricerca verso server di nomi di dominio non autorizzati. Fondamentalmente, l’attaccante utilizza modifiche non autorizzate o malware per alterare il record DNS del sito web preso di mira, indirizzando così gli utenti verso una destinazione maligna. Nel caso dell’attacco a Squarespace, alcuni esperti ritengono che gli attaccanti possano aver utilizzato l’avvelenamento della cache DNS, che comporta l’iniezione di dati falsi nelle cache DNS. Di conseguenza, le query DNS restituirebbero risposte errate prima di reindirizzare gli utenti verso siti web maligni.</p>
<p>Il <a href="https://www.gate.io/learn/articles/how-defi-protocols-generate-revenue-and-why-its-important/2890" target="_blank">protocolli DeFi</a> che sono stati attaccati hanno utilizzato vari metodi per prevenire furti su larga scala dei beni digitali degli utenti. Una delle risposte di sicurezza SquareSpace ampiamente utilizzate è stata avvertire gli utenti del pericolo esistente. Ad esempio, MetaMask ha avvisato i propri utenti del pericolo attraverso piattaforme di social media come <a href="https://x.com/MetaMask/status/1811436757759701391" rel="nofollow noopener noreferrer" target="_blank">X.com</a>.<br><img src="https://gimg2.gateimg.com/image/article/17218082771.jpeg" alt=""><br>Fonte: <a href="https://x.com/MetaMask/status/1811436757759701391" rel="nofollow noopener noreferrer" target="_blank">X.com</a></p>
<p>Una volta che i protocolli DeFi mirati hanno condiviso gli avvisi su varie piattaforme di social media, molti membri delle diverse comunità criptovalutarie hanno aiutato diffondendo il messaggio, avvertendo molti utenti di asset digitali delle minacce esistenti.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/six-major-indicators-every-beginner-must-know-about-defi/563" target="_blank">Sei Indicatori Principali Che Ogni Principiante Deve Conoscere Riguardo a DeFi</a></p>
<h2 id="h2-Ambito20di20impatto2022020protocolli20DeFi20a20rischio265939"><a name="Ambito di impatto: 220 protocolli DeFi a rischio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ambito di impatto: 220 protocolli DeFi a rischio</h2><p>Attualmente, non ci sono informazioni tangibili sull’intera portata del recente dirottamento DNS di Squarespace. I primi attacchi DNS sono stati rilevati il 6 e l’11 luglio di quest’anno, quando attori malintenzionati hanno cercato di prendere il controllo di <a href="/price/compound-comp" target="_blank" class="blog_inner_link">Compound</a> e Celer Network. Tuttavia, nel caso di Celer Network, il suo sistema di monitoraggio ha sventato l’attacco. La valutazione iniziale di Blockaid degli attacchi indica che gli attaccanti stanno puntando sui nomi di dominio forniti da Squarespace. Ciò mette più di 220 protocolli DeFi a rischio di sicurezza DeFi. Questo perché tutti <a href="https://www.gate.io/blog_detail/1038/everything-you-need-to-know-about-defi" target="_blank">app DeFi</a> I siti web che utilizzano il dominio Squarespace affrontano i rischi di attacchi DNS.</p>
<p>In merito a questo, attraverso un <a href="https://x.com/blockaid_/status/1811423284409602184" rel="nofollow noopener noreferrer" target="_blank">Blockaid ha detto X post</a>“Dalla valutazione iniziale, sembra che gli aggressori stiano operando dirottando i record DNS dei progetti ospitati su SquareSpace”. Gli attacchi a vari protocolli DeFi, portafogli digitali ed exchange di criptovalute sono stati sventati dai loro robusti sistemi di sicurezza. Nella maggior parte di questi casi, i frontend hanno notificato agli utenti il pericolo imminente, come mostra lo screenshot seguente.<br><img src="https://gimg2.gateimg.com/image/article/17218083422.jpeg" alt=""><br>Fonte: x.com</p>
<p>Come osservato, i portafogli digitali che includono Coinbase Wallet e MetaMask hanno segnalato i siti web associati come pericolosi e non sicuri. Esempi di alcuni protocolli DeFi a rischio sono Thorchain, Flare, Pendle Finance. <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> Labs, Polymarket, Protocollo Satoshi, Near, <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a>, Nirvana, MantaDAO e Ferrum.</p>
<h2 id="h2-Il20ruolo20del20DNS20nella20sicurezza20crittografica673256"><a name="Il ruolo del DNS nella sicurezza crittografica" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il ruolo del DNS nella sicurezza crittografica</h2><p>In termini semplici, un sistema di nomi di dominio (DNS) converte i nomi dei siti web in indirizzi amici del computer. Ad esempio, traducono i nomi di dominio come www.tcore.com in indirizzi IP numerici come 82.223.84.85 consentendo ai dispositivi di connettersi con diverse destinazioni online. Tuttavia, un DNS svolge un ruolo importante nel garantire le piattaforme crypto online. Poiché si tratta di un sistema decentralizzato, non ha un punto centrale di fallimento che impedisce molti cyber attacchi. Inoltre, il DNS blockchain rende impossibile per gli attori malintenzionati interferire con le transazioni, garantendo così gli asset digitali che esistono su varie reti decentralizzate.</p>
<h2 id="h2-Come20le20piattaforme20DeFi20possono20proteggersi20da20vulnerabilit20simili165788"><a name="Come le piattaforme DeFi possono proteggersi da vulnerabilità simili" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come le piattaforme DeFi possono proteggersi da vulnerabilità simili</h2><p>Dopo gli attacchi DNS, gli esperti di sicurezza informatica hanno suggerito diversi metodi per gestire vulnerabilità DNS simili. Le aziende DeFi possono aggiungere ulteriori livelli di sicurezza ai loro protocolli. Ad esempio, possono riconfigurare i loro contratti intelligenti per impedire gli aggiornamenti a meno che non siano verificati dalle firme onchain. In questo caso, prima di un aggiornamento, un DNS dovrebbe richiedere una firma dal portafoglio dell’utente. Ciò renderà più difficile per gli hacker riuscire nelle loro missioni poiché dovrebbero hackerare sia il portafoglio che il registrar.</p>
<p>Inoltre, i protocolli DeFi potrebbero aver bisogno di segnalare URL affidabili e verificare tutti gli indirizzi web associati. Possono anche aggiungere estensioni del browser rilevanti come HTTPS e autenticazioni a due fattori (2FA) per account digitali e portafogli. Inoltre, il protocollo DeFi dovrebbe avere canali di comunicazione per segnalare attività criptate sospette. In questo modo, qualsiasi piattaforma interessata può ottenere supporto da altri partner di sicurezza.</p>
<p>Un altro modo di <a href="https://www.gate.io/learn/articles/what-is-defi/2815" target="_blank">proteggere le piattaforme DeFi</a> utilizza filtri di contenuti per bloccare i siti web dannosi dall’interagire con i loro smart contract. Ad esempio, possono utilizzare malware robusti <a href="https://www.gate.io/learn/articles/common-phishing-methods-and-security-prevention-suggestions-in-web3/3061" target="_blank">bloccare i siti di phishing</a>.</p>
<h2 id="h2-Guida20per20lutente20Come20proteggere20gli20asset20personali724610"><a name="Guida per l’utente: Come proteggere gli asset personali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Guida per l’utente: Come proteggere gli asset personali</h2><p>Oltre alle misure di sicurezza implementate dal protocollo DeFi, gli utenti dovrebbero adottare le proprie strategie di protezione degli asset crittografici. Ad esempio, dovrebbero installare software anti-malware sui loro dispositivi elettronici. Devono anche utilizzare l’autenticazione a due fattori, VPN e firewall robusti. Inoltre, le persone dovrebbero utilizzare password robuste per le loro email e registrazioni di dominio.</p>
<h2 id="h2-Conclusione420574"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Oltre 220 protocolli DeFi sono minacciati da attacchi DNS. Durante le prime due settimane di luglio alcuni attaccanti malintenzionati hanno cercato di compromettere diversi protocolli DeFi e portafogli digitali che includono Compound, Celer Network, Coinbase wallet e MetaMask. Tuttavia, la maggior parte di queste piattaforme ha respinto gli attacchi. Per prevenire futuri attacchi, le aziende crittografiche potrebbero <a href="https://www.gate.io/blog_detail/4278/stay-safe-with-gate.io-essential-security-measures-every-user-should-know" target="_blank">introdurre ulteriori misure di sicurezza</a> come autenticazioni a due fattori e estensioni del browser correlate come HTTPS.</p>
<h2 id="h2-Domande20frequenti20sugli20attacchi20DNS692487"><a name="Domande frequenti sugli attacchi DNS" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sugli attacchi DNS</h2><h3 id="h3-Cosa20succede20se20il20DNS20viene20dirottato177794"><a name="Cosa succede se il DNS viene dirottato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa succede se il DNS viene dirottato?</h3><p>Se DNS viene dirottato, reindirizzerà i record DNS a siti web maligni che potrebbero comportare il drenaggio del portafoglio degli utenti. Per prevenire gli attacchi DNS, le aziende DeFi potrebbero dover riconfigurare i loro smart contract per impedire gli aggiornamenti che normalmente avvengono senza firme verificate onchain.</p>
<h3 id="h3-Come20si20mitiga20lhijacking20DNS107821"><a name="Come si mitiga l’hijacking DNS?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come si mitiga l’hijacking DNS?</h3><p>Gli utenti possono utilizzare diverse strategie come password di posta elettronica sicure e autenticazioni a due fattori per mitigare gli attacchi di dirottamento DNS. D’altra parte, i protocolli DeFi potrebbero dover aggiungere ai preferiti URL affidabili e verificare tutti gli indirizzi web associati.</p>
<h3 id="h3-VPN20impedisce20lhijacking20DNS226137"><a name="VPN impedisce l’hijacking DNS?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>VPN impedisce l’hijacking DNS?</h3><p>Una VPN può prevenire l’hijacking del DNS. Questo perché la VPN è in grado di prevenire l’intercettazione delle query DNS. Tuttavia, gli utenti dovrebbero utilizzare VPN affidabili.</p>
<h2 id="h2-Qual2020la20differenza20tra20la20verifica20del20DNS20e20lhijacking20del20DNS163728"><a name="Qual è la differenza tra la verifica del DNS e l’hijacking del DNS?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è la differenza tra la verifica del DNS e l’hijacking del DNS?</h2><p>Il dirottamento DNS comporta la modifica delle impostazioni DNS, mentre la prova DNS modifica i record DNS. Di solito, gli attaccanti utilizzano malware per facilitare il dirottamento DNS.</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 ripostaggio dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>