TCdhY2NvdW50IGRpIEVpZ2VubGF5ZXIgWCDDqCBzdGF0byBjb21wcm9tZXNzbzogYXR0ZW56aW9uZSBhbGxlIHRydWZmZSBkaSBwaGlzaGluZw==

2024-10-31, 02:56

<p><img src="https://gimg2.gateimg.com/image/article/17303433661690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR921376"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il 18 ottobre alcuni attori malintenzionati hanno violato l’account di Eigenlayer X e hanno pubblicato <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> di phishing.</p>
<p>Durante il Q3 del 2024 sono stati rubati più di 314 milioni di dollari attraverso truffe di phishing criptato</p>
<p>A settembre una singola truffa di phishing cripto ha portato a una perdita di criptovalute del valore di circa 32,43 milioni di dollari.</p>
<h2 id="h2-Introduzione716409"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>I cattivi attori nel settore delle criptovalute stanno diventando sempre più audaci e innovativi al fine di rubare a persone ignare. Frodi, attacchi informatici e truffe di phishing sono alcuni dei mezzi che gli attori maligni utilizzano per rubare criptovalute. Tuttavia, i protagonisti del settore digitale decentralizzato stanno promuovendo l’unità per prevenire o ridurre gli episodi di furto di criptovalute. Oggi discutiamo di come gli scammer hanno utilizzato il phishing per ingannare gli utenti di criptovalute.</p>
<h2 id="h2-Eigenlayer20subisce20un20altro20spavento20di20phishing990807"><a name="Eigenlayer subisce un altro spavento di phishing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Eigenlayer subisce un altro spavento di phishing</h2><p>Il 18 ottobre i cattivi attori hanno violato l’account X di Eigenlayer nel tentativo di rubare criptovalute dai suoi utenti attraverso il phishing. Volevano capitalizzare sulla storia di successo di Eigenlayer con gli airdrop. Dopo aver preso il controllo del <a href="https://www.gate.io/learn/articles/a-comprehensive-interpretation-of-eigenlayer-a-new-favorite-project-both-loved-and-hated-by-ethereum/1784" target="_blank">Eigenlayer</a> L’account X gli scammer hanno pubblicato un messaggio secondo il quale la blockchain ha un altro airdrop. Hanno affermato che tutti gli utenti che erano idonei durante la precedente fase di airdrop dovrebbero partecipare a quella attuale. Hanno incluso un <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">collegamento</a> attraverso il quale gli utenti di Eigenlayer richiederebbero l’airdrop. Tuttavia, il <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">collegamento</a> indirizzati gli utenti al sito di phishing degli truffatori.</p>
<p>PeckShield, l’azienda di sicurezza blockchain, è stata la prima a avvisare gli utenti di criptovalute riguardo al falso programma di distribuzione aerea. Nel suo avviso di truffa su X, PeckShield ha avvertito gli utenti di criptovalute di non fare clic sui link URL forniti.<img src="https://gimg2.gateimg.com/image/article/17303435381.jpeg" alt=""><br>Avviso di truffa PeckShield - x.com/PeckShield</p>
<p>Dopo l’avviso postato da PeckShield X che ha allertato la comunità crittografica sul tentativo di phishing, Eigenlayer ha informato i suoi membri riguardo allo sviluppo. Ha dichiarato: L’account @EigenLayer è stato compromesso. Si prega di non interagire con nessun link sospetto e controllare attentamente e verificare di essere in contatto con ‘eigenlayer.xyz’. Verrà fornito un aggiornamento una volta garantita la sicurezza.</p>
<p>Se le due aziende criptovalutarie non avessero agito rapidamente, molti membri della comunità Eigenlayer X avrebbero potuto essere truffati. Ciò perché gli truffatori hanno utilizzato un metodo sofisticato per oscurare il link. Ad esempio, il messaggio degli truffatori conteneva un’immagine apparentemente legittima del sito web di restaking di Eigenlayer, compreso il suo URL del blog. Ciò perché l’attaccante ha aggiunto un’immagine antiscam al thread del tweet per aumentare la sua credibilità. Inoltre, gli truffatori hanno utilizzato diverse versioni del link truffa. Hanno ruotato gli URL per evitare una facile rilevazione. È importante notare che l’airdrop presunto è arrivato diverse settimane dopo la fine ufficiale del stakedrop della stagione 2.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/exploring-the-re-staking-potential-of-eigenlayer/4069" target="_blank">Esplorare il potenziale di Re-Staking di EigenLayer</a></p>
<p>La cosa positiva è che è stata individuata rapidamente una rapida rilevazione dei link truffa. Di conseguenza, il post degli truffatori è stato rimosso in breve tempo. La popolarità dell’Eigenlayer, il secondo protocollo più grande su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> rete, ha portato a <a href="https://www.gate.io/blog/1425/What-is-phishing-and-how-to-protect-ourselves-from-phishing-attacks" target="_blank">molti truffe di phishing</a> Finora, il protocollo ha avuto due truffe di phishing solo nell’ottobre. In primo luogo, il 4 ottobre, il team ha annunciato di essere al corrente di un’attività di vendita non autorizzata che coinvolgeva un indirizzo che terminava con ‘f10D’. Eigenlayer ha affermato che il portafoglio aveva venduto circa 1,6 milioni di… <a href="https://www.gate.io/how-to-buy/eigenlayer-eigen" target="_blank">Token EIGEN</a> valutato intorno ai 5,7 milioni di dollari. Tuttavia, il 5 ottobre il team ha informato la sua comunità X che la transazione è stata il risultato di un attacco informatico criptato.</p>
<p>Leggi su <a href="https://www.gate.io/learn/articles/eigenlayers-risk-management/1955" target="_blank">Gestione del rischio presso Eigenlayer</a></p>
<h2 id="h2-La20crescente20minaccia20delle20violazioni20degli20account20dei20social20media20e20i20suoi20effetti20sul20settore20delle20criptovalute677949"><a name="La crescente minaccia delle violazioni degli account dei social media e i suoi effetti sul settore delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La crescente minaccia delle violazioni degli account dei social media e i suoi effetti sul settore delle criptovalute</h2><p>L’hack dell’account Eigenlayer X mette in luce la crescente minaccia di takeover di account sui social media e phishing. Un recente rapporto di Security.Org ha mostrato che i casi di takeover di account tra i residenti degli Stati Uniti sono aumentati del 29% dal 2021. Nel rapporto sono state identificate modalità per prevenire i takeover di account sui social media. Queste includono l’uso di password uniche e robuste, l’abilitazione delle domande di sicurezza e l’uso dell’autenticazione a più fattori.</p>
<p>Nel settore delle criptovalute alcuni truffatori ingannano gli utenti facendoli connettere i loro portafogli digitali a servizi fraudolenti. Se qualcuno connette il proprio portafoglio criptato ai siti di phishing, i truffatori svuotano i loro beni digitali. In quella situazione non ci sarà bisogno di alcuna autenticazione.</p>
<p>D’altra parte, se i truffatori prendono il controllo degli account dei progetti di criptovalute, potrebbero usarli per pubblicizzare programmi di investimento e airdrop falsi. Tali attacchi hanno generalmente successo perché vengono eseguiti su piattaforme di social media affidabili come il profilo X di Eigenlayer.</p>
<h2 id="h2-Diffusione20delle20truffe20di20phishing20in20Crypto832325"><a name="Diffusione delle truffe di phishing in Crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Diffusione delle truffe di phishing in Crypto</h2><p>Secondo Chainanalysis, il phishing di approvazione - in cui le vittime sono state ingannate a effettuare transazioni dannose - ha portato al furto di miliardi di asset digitali che includono criptovalute e NFT. Le piattaforme di social media di proprietà di progetti crypto legittimi sono i principali obiettivi degli hacker. Ad esempio, alcuni impostori utilizzano link ingannevoli nei commenti su piattaforme di social media di progetti crypto ben noti.</p>
<p>A settembre le truffe di phishing cripto hanno comportato la perdita di criptovalute del valore di 46 milioni di dollari. Durante questo periodo sono stati colpiti oltre 10.800 vittime. D’altra parte, nel terzo trimestre del 2024 sono state rubate criptovalute del valore di oltre 127 milioni di dollari a causa del phishing. La più grande truffa di phishing cripto a settembre ha portato alla perdita di asset cripto del valore di circa 32,43 milioni di dollari.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/common-phishing-methods-and-security-prevention-suggestions-in-web3/3061" target="_blank">Metodi comuni di phishing e suggerimenti per la prevenzione della sicurezza in Web3</a><img src="https://gimg2.gateimg.com/image/article/17303437712.jpeg" alt=""></p>
<p>Il più grande incidente di phishing criptato nel settembre 2024 - x.com/scamsniffer</p>
<p>Nel caso sopra, la vittima ha perso 2.083 spWETH. Durante settembre i cattivi attori hanno principalmente preso di mira <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a>, MATIC e <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>. Un altro rapporto di Scam Sniffers mostra che più di $314 milioni di criptovalute sono state rubate attraverso truffe di phishing durante il Q3, 2024.<br><img src="https://gimg2.gateimg.com/image/article/17303438003.jpeg" alt=""><br>Incidenti di truffe di phishing criptato nel Q3,2024 - Scam Sniffer</p>
<p>Come mostrano le cifre sopra, sono stati rubati più di $314 milioni di criptovalute. D’altra parte, 266.713 persone sono state colpite. È importante notare che la maggior parte di queste sono perdite approvate sui social media. Questo richiede la necessità che le persone migliorino la sicurezza del loro account criptato. Un modo per farlo è evitare di cliccare su link provenienti da parti sconosciute. D’altra parte, i team dei progetti cripto dovrebbero assicurarsi che ci siano pochissime possibilità di phishing sui social media. Ad esempio, possono assegnare delle persone per tenere d’occhio tutte le attività sui loro social media.</p>
<p>Il grafico seguente rappresenta la tendenza riguardante le truffe di phishing.<br><img src="https://gimg2.gateimg.com/image/article/17303438344.jpeg" alt=""><br>Tendenza delle truffe di phishing nel 2024 - Scam Sniffer</p>
<p>Come si vede dal grafico sopra, il livello delle truffe di phishing crittografiche è rimasto molto alto. Ciò dimostra la necessità di migliorare la sicurezza della blockchain. In effetti, sia i progetti crittografici che gli utenti dovrebbero adottare misure di sicurezza crittografica approvate e testate.</p>
<h2 id="h2-Conclusione102458"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il 18 ottobre alcuni attori malintenzionati hanno hackerato l’account di Eigenlayer X. Di conseguenza, hanno pubblicizzato un falso airdrop di EIGEN nel tentativo di rubare agli utenti. Nel loro post hanno incluso un link al loro sito di phishing. Tuttavia, sia PeckShield, l’azienda di sicurezza blockchain, che Eigenlayer sono riusciti a notare l’hack. Pertanto, hanno avvisato la comunità cripto dello sviluppo. Inoltre, Eigenlayer ha rimosso il post e i link correlati nel giro di poco tempo.</p>
<h2 id="h2-Domande20frequenti20sul20phishing764719"><a name="Domande frequenti sul phishing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sul phishing</h2><h3 id="h3-Cosa2020successo20allaccount20Eigenlayer20X773125"><a name="Cosa è successo all’account Eigenlayer X?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa è successo all’account Eigenlayer X?</h3><p>L’account Eigenlayer X è stato compromesso tramite sofisticate tattiche di phishing, che hanno portato alla diffusione di collegamenti fraudolenti nascosti dietro immagini di anteprima dall’aspetto legittimo.</p>
<h3 id="h3-Come20hanno20nascosto20i20link20truffaldini20nellhack20dellaccount20Eigenlayer20X822114"><a name="Come hanno nascosto i link truffaldini nell’hack dell’account Eigenlayer X?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come hanno nascosto i link truffaldini nell’hack dell’account Eigenlayer X?</h3><p>Gli hacker hanno oscurato i link truffa utilizzando il design della piattaforma di X per visualizzare un’immagine di anteprima del legittimo sito web Eigenlayer, ingannando gli utenti con l’apparenza di autenticità.</p>
<h3 id="h3-Quali20sono20i20rischi20delle20violazioni20degli20account20sui20social20media20nello20spazio20cripto763107"><a name="Quali sono i rischi delle violazioni degli account sui social media nello spazio cripto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali sono i rischi delle violazioni degli account sui social media nello spazio cripto?</h3><p>Gli account di social media presi di mira, come l’hack dell’account Eigenlayer X, comportano rischi significativi, tra cui la diffusione di truffe di phishing, la perdita di fiducia degli utenti e potenziali perdite finanziarie a causa di pratiche ingannevoli.</p>
<h3 id="h3-Quanto20diffusi20sono20gli20scam20di20phishing20nella20comunit20delle20criptovalute132956"><a name="Quanto diffusi sono gli scam di phishing nella comunità delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quanto diffusi sono gli scam di phishing nella comunità delle criptovalute?</h3><p>Le truffe di phishing sono diventate sempre più diffuse nella comunità delle criptovalute, sfruttando la fiducia che gli utenti ripongono nei canali ufficiali per diffondere contenuti maligni e condurre attività di phishing per l’approvazione, causando miliardi di perdite dal 2021.</p>
<h3 id="h3-Come20possono20gli20utenti20proteggersi20dagli20attacchi20di20phishing20su20piattaforme20come20X101075"><a name="Come possono gli utenti proteggersi dagli attacchi di phishing su piattaforme come X?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come possono gli utenti proteggersi dagli attacchi di phishing su piattaforme come X?</h3><p>Si consiglia agli utenti di verificare le informazioni tramite più canali, di prestare attenzione quando interagiscono con i link e di rimanere vigili per individuare segni di phishing, come anteprime ingannevoli o richieste inaspettate di informazioni o approvazioni.</p>
<h3 id="h3-Come20possono20gli20utenti20identificare20ed20evitare20i20link20di20phishing20sui20social20media271809"><a name="Come possono gli utenti identificare ed evitare i link di phishing sui social media?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come possono gli utenti identificare ed evitare i link di phishing sui social media?</h3><p>Gli utenti possono identificare ed evitare i link di phishing esaminando attentamente gli URL, evitando di fare clic su link non richiesti e verificando l’autenticità della fonte del messaggio prima di interagire con qualsiasi contenuto.</p>
<h3 id="h3-Cosa20sono20le20truffe20di20phishing20di20approvazione20e20quale20impatto20hanno20sullindustria20delle20criptovalute170695"><a name="Cosa sono le truffe di phishing di approvazione e quale impatto hanno sull’industria delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa sono le truffe di phishing di approvazione e quale impatto hanno sull’industria delle criptovalute?</h3><p>Le truffe di phishing di approvazione ingannano le vittime a firmare transazioni dannose, portando a accessi non autorizzati e perdite finanziarie. Tali truffe hanno avuto un impatto significativo sull’industria delle criptovalute, con miliardi persi dal 2021.</p>
<h3 id="h3-Quali20statistiche20recenti20evidenziano20la20gravit20degli20attacchi20informatici20nello20spazio20delle20criptovalute884150"><a name="Quali statistiche recenti evidenziano la gravità degli attacchi informatici nello spazio delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali statistiche recenti evidenziano la gravità degli attacchi informatici nello spazio delle criptovalute?</h3><p>Le statistiche recenti di PeckShield segnalano oltre 200 grandi attacchi nello spazio crittografico solo nella prima metà del 2024, che hanno causato approssimativamente $1,56 miliardi di perdite, di cui solo una frazione è stata recuperata.</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 il ripostaggio dell'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>