SGFja2VyIGV0aWNvIHNjb3ByZSB1biBleHBsb2l0IERlRmkgZGEgMSwzIG1pbGlvbmkgZGkgZG9sbGFyaQ==

2024-03-06, 02:23

<p><img src="https://gimg2.gateimg.com/image/article/1709691770sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR119412"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Un hacker etico ha recuperato criptovalute per un valore di 1,3 milioni di dollari rubate dal protocollo Blueberry.</p>
<p>Lo stesso hacker con il cappello bianco, di nome @coffeebabe_eth, ha recuperato $5.4 milioni per Curve Finance nel 2023.</p>
<p>Il white hat hacking consente ai protocolli DeFi di individuare le vulnerabilità nei loro sistemi</p>
<p><strong>Parole chiave</strong>: Protocolli DeFi, hacker etico, sfruttamento crittografico, sfruttamento DeFi, hacker crittografico, hacker cappello bianco, attacco bot crittografico, perdite crittografiche, ecosistema crittografico, minaccia crittografica</p>
<h2 id="h2-Introduzione283807"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La più grande minaccia alle criptovalute come forma di denaro digitale e deposito di valore è l’hacking e altre forme di furti informatici come <a href="https://www.gate.io/blog_detail/1425/what-is-phishing-and-how-to-protect-ourselves-from-phishing-attacks" target="_blank">phishing</a>. Sin dai primi giorni degli asset digitali, attori nefasti hanno rubato cripto asset agli investitori e alle imprese basate su blockchain operanti nel settore delle criptovalute. Nel corso degli anni, tali minacce hanno influenzato il tasso di adozione degli asset digitali.</p>
<p>Il modo migliore per prevenire furti di asset digitali è attraverso un’alta sicurezza delle infrastrutture e l’audit. Tuttavia, i progetti crypto possono anche fare uso di hacker etici per testare i loro livelli di sicurezza, riducendo così la possibilità di sfruttamento di Defi. Oggi, vediamo come gli hacker etici hanno impedito furti di asset crypto in passato.<br>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-a-sandwich-attack/936" target="_blank">Cosa è l’attacco del panino?</a></p>
<h2 id="h2-Protocollo20Blueberry20sotto20minaccia20White20Hat20Hacker20neutralizza20lexploit20DeFi20il202320febbraio452617"><a name="Protocollo Blueberry sotto minaccia: White Hat Hacker neutralizza l’exploit DeFi il 23 febbraio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Protocollo Blueberry sotto minaccia: White Hat Hacker neutralizza l’exploit DeFi il 23 febbraio</h2><p>Il protocollo Blueberry, una piattaforma decentralizzata che consente il prestito, è stato attaccato il 23 febbraio ed era sull’orlo di subire perdite crypto di 457.6 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>(ETH), del valore di circa 1,3 milioni di dollari in quel momento, solo per essere salvato da un hacker white hat conosciuto solo come “c0ffeebabe.eth.”</p>
<p>Ciò che ha portato all’intervento di c0ffeebabe.eth è stata la rapida risposta della Blueberry Protocol Foundation dopo aver notato lo sfruttamento di DeFi. Hanno prontamente informato i propri clienti dell’hacking utilizzando la piattaforma di social media X.</p>
<p>Il team ha esortato gli utenti a prelevare le proprie partecipazioni il prima possibile. Purtroppo, in breve tempo, il frontend della piattaforma non era accessibile. Tuttavia, la fondazione è riuscita a mettere in pausa il protocollo dopo circa 30 minuti, impedendo così all’attore malintenzionato di svuotare ulteriormente le criptovalute.</p>
<p>In sostanza, gli sfruttatori erano riusciti a svuotare <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> (BTC), USDC e <a href="/price/olympus-ohm" rel="nofollow noopener noreferrer" target="_blank">Olimpo</a> dai mercati del prestito. In quel momento, tutti gli asset crittografici che erano nel Protocollo Blueberry erano sotto minaccia. Oltre al team, altre persone e organizzazioni all’erta hanno contribuito a diffondere informazioni sulla minaccia crittografica esistente.<br><img src="https://gimg2.gateimg.com/image/article/17096913441.jpeg" alt=""><br>Origine: <a href="https://twitter.com/BlockSecTeam/status/1760876339903558114" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Come osservato nello screenshot, il BlockSecTeam è stato uno dei membri dell’organizzazione che ha contribuito a trasmettere le informazioni ad altri stakeholder.</p>
<p>Una volta che la situazione è stata sotto controllo e ulteriori perdite di criptovaluta sono state evitate, la Fondazione del Protocollo Blueberry ha assicurato ai propri utenti che i loro averi erano al sicuro. Pubblicazione <a href="https://twitter.com/blueberryFDN/status/1760872935982879030" rel="nofollow noopener noreferrer" target="_blank">il team ha detto su X</a>, “Tutti i fondi prosciugati sono stati gestiti da @ coffeebabe_eth e ora sono al sicuro nel multisig Blueberry, meno il pagamento del validatore.”</p>
<p>Come ha riconosciuto il team, un hacker white hat (@coffeebabe_eth) ha salvato il protocollo dalle imminenti perdite di criptovalute. L’hacker etico ha recuperato 366 ETH su un totale di 457 Ether che gli hacker di criptovalute avevano sottratto al protocollo.</p>
<p>In quel momento, il team ha dichiarato di essere in trattativa con i validatori per restituire 91 ETH. <a href="https://twitter.com/blueberryFDN/status/1760876257078899016" rel="nofollow noopener noreferrer" target="_blank">chiarito</a>“I fondi depositati sono attualmente al sicuro. Solo tre mercati sono stati coinvolti e la grande maggioranza è già stata restituita. Il pagamento totale dei validatori (perdita) è di 91 ETH. Ci stiamo mettendo in contatto e miriamo a un rimborso completo agli utenti come obiettivo.”</p>
<p>È importante realizzare che al momento dello sfruttamento della criptovaluta il Protocollo Blueberry <a href="https://www.gate.io/de/blog_detail/1471/the-total-value-locked-tvl-of-the-defi-protocols-exceeds-70-billion &quot;had a total value locked (TVL" rel="nofollow noopener noreferrer" target="_blank">aveva un valore totale bloccato (TVL)</a> Il valore del token GT era inizialmente di $4,5 milioni ma è diminuito a $3,15 milioni a seguito dell’exploit DeFi non riuscito.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-does-tvl-mean-in-defi/217" target="_blank">Cosa significa TVL in DeFi?</a><img src="https://gimg2.gateimg.com/image/article/17096914992.jpeg" alt=""><br>Valore totale bloccato (TVL) del protocollo Blueberry - <a href="https://defillama.com/protocol/blueberry-lend" rel="nofollow noopener noreferrer" target="_blank">Defillama</a></p>
<p>Come si può notare nell’immagine, subito dopo il fallito exploit DeFi il valore totale bloccato nel protocollo (TVL) è sceso da $4,5 milioni a $3,15 milioni.</p>
<h2 id="h2-Il20White20Hat20Hacker20c0ffeebabeeth20ha20anche20salvato20Curve20Finance20nel202023247144"><a name="Il White Hat Hacker, c0ffeebabe.eth, ha anche salvato Curve Finance nel 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il White Hat Hacker, c0ffeebabe.eth, ha anche salvato Curve Finance nel 2023</h2><p>L’hacker etico, c0ffeebabe.eth, anche <a href="https://www.gate.io/blog_detail/3081/curve-founder-168m-stash-faces-stress" target="_blank">Curve Finance salvato nel 2023</a> quando ha recuperato criptovalute del valore di 5,4 milioni di dollari che hacker malintenzionati avevano rubato.</p>
<p>In realtà, c0ffeebabe.eth ha utilizzato un bot di trading di arbitrato <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> per superare gli attaccanti e recuperare gli asset crittografici rubati. L’hacker etico ha restituito i fondi al team.</p>
<h2 id="h2-Perdite20DeFi20del202023620771"><a name="Perdite DeFi del 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perdite DeFi del 2023</h2><p>L’incidente di hacking di Blueberry indica quanto i protocolli DeFi siano vulnerabili alle frodi criptate maligne. Ad esempio, nel solo 2023, DeFi ha subito perdite per oltre 1 miliardo di dollari a causa di furti informatici, come indica il seguente grafico.<br><img src="https://gimg2.gateimg.com/image/article/17096915623.jpeg" alt=""><br>Perdite DeFi per il 2023: <a href="https://twitter.com/intotheblock/status/1736054070492696827/photo/1" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Come osservato dal diagramma, nel 2023 DeFi ha subito perdite criptiche pari a circa 1,02 miliardi di dollari. Tuttavia, ciò ha segnato una grande diminuzione rispetto alle perdite che il settore ha subito nel 2021 e nel 2022, quando le perdite di DeFi erano rispettivamente di circa 3,96 miliardi di dollari e 53 miliardi di dollari.</p>
<h2 id="h2-Perch20i20White20Hat20Hackers20sono20fondamentali20per20il20settore20delle20criptovalute729823"><a name="Perché i White Hat Hackers sono fondamentali per il settore delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché i White Hat Hackers sono fondamentali per il settore delle criptovalute?</h2><p>Come abbiamo evidenziato nei casi di Curve Finance e Blueberry Protocol, gli hacker white hat svolgono un ruolo fondamentale nella prevenzione e nell’annullamento degli attacchi crittografici dannosi. Utilizzano molti metodi per aiutare i progetti crittografici a prevenire gli attacchi.</p>
<p>In primo luogo, l’obiettivo degli hacker white hat è quello di aiutare l’ecosistema delle criptovalute a migliorare i sistemi di sicurezza al fine di prevenire gli sfruttamenti delle criptovalute. In altre parole, effettuano hacking white-hat, anche chiamato hacking etico o test di penetrazione.</p>
<p>In tali casi, i proprietari dei progetti digitali autorizzano gli hacker white hat a testare i loro sistemi e suggerire modi per migliorarli. Questo perché gli hacker crittografici sfruttano falle o vulnerabilità non identificate nei protocolli. In primo luogo, il penetration testing riduce al minimo le possibilità di malfunzionamenti e furti del sistema.</p>
<p>Anche se gli hacker bianchi utilizzano strumenti e tecniche simili ai cappelli neri, hanno buone intenzioni. Ad esempio, utilizzano software dannosi e attacchi DoS o <a href="https://www.gate.io/bitwiki/detail/152/distributed-denial-of-service-attack--ddos-attack" target="_blank">Attacchi DDoS</a> con l’obiettivo di identificare minacce <a href="https://www.gate.io/blog_detail/2460/security-measures-at-gateio-protecting-your-digital-assets-in-the-crypto-landscape" target="_blank">e proteggere gli asset crittografici</a>. Ad esempio, un cappello bianco può utilizzare un attacco di crypto bots. Nel complesso, lui/lei/loro hackerano per il bene dei progetti DeFi e all’interno delle ascelle della legge poiché sono agenti di rimozione delle minacce.</p>
<h2 id="h2-Conclusion66236"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Il famoso hacker white hat @ coffeebabe_eth ha sventato un exploit DeFi il 25 febbraio, evitando una perdita di 1,3 milioni di dollari per Blueberry Protocol. Lo stesso hacker etico ha anche recuperato oltre 5,4 milioni di dollari dopo che alcuni hacker di criptovalute hanno sfruttato Curve Finance nel 2023. In generale, i test di penetrazione aiutano a identificare le falle nei sistemi DeFi, il che riduce il numero di incidenti di 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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostare dell'articolo a condizione che venga referenziato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>