VmlvbGF6aW9uZSBkZWwgcHJvdG9jb2xsbyBEZUZpIHNpIHRyYWR1Y2UgaW4gdW5hIHBlcmRpdGEgZGkgJDIxMi4wMDAgYSBjYXVzYSBkaSB1bmEgdnVsbmVyYWJpbGl0w6AgZGVsIGNvbnRyYXR0byBpbnRlbGxpZ2VudGU=

2024-08-14, 02:52

<p><img src="https://gimg2.gateimg.com/image/article/17236036501690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR682645"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il 1 agosto, il protocollo di finanza decentralizzata Convergence ha subito una violazione della sicurezza a causa di una vulnerabilità del contratto intelligente.</p>
<p>Un hacker o un team di hacker è riuscito a sfruttare la falla, coniando e vendendo 210.000$ del suo token nativo e rubando anche 2.000$ in ricompense di staking non reclamate.</p>
<p>Wireshark, lo pseudonimo fondatore di Convergence, ha fornito un dettagliato rapporto post-mortem che rivela che l’hacker ha preso di mira il contratto CvxRewardDistributor del protocollo.</p>
<p>Questo ha permesso all’hacker di coniare e vendere 58 milioni di token CVG, per un guadagno di circa $ 210.000.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/defi-eco-2024-preview-key-trends-and-direction-predictions-for-the-industry/1387" target="_blank">Panoramica dell’Ecosistema DeFi 2024: Tendenze Chiave e Direzioni</a></p>
<p>Inoltre, l’hacker ha rubato circa $2.000 di ricompense non reclamate da Convex, un protocollo DeFi finalizzato all’ottimizzazione delle ricompense <a href="https://www.gate.io/learn/articles/what-is-curve/425" target="_blank">per Curve</a> I fornitori di liquidità. I dati di Etherscan indicano che l’attacco è avvenuto intorno alle 3:00 UTC del 1 agosto.</p>
<p>PeckShield, una società di sicurezza blockchain, ha osservato che dopo aver coniato i token CVG, l’hacker li ha prontamente convertiti in 60 Ether avvolti e 15.900 Curve.fi <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">FRAX</a>. A seguito di queste azioni, il token di governance CVG ha subito un crollo del prezzo quasi del 100%, ora scambiato a $0.0004 con una capitalizzazione di mercato di soli $57,000, secondo CoinMarketCap.</p>
<h2 id="h2-Dettagli20dellincidente115659"><a name="Dettagli dell’incidente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dettagli dell’incidente</h2><p>Convergence ha rivelato che la violazione è avvenuta perché il team ha involontariamente rimosso una linea cruciale di codice nel suo contratto intelligente responsabile della distribuzione delle ricompense di staking CVG. Questa modifica è stata apportata dopo che il contratto intelligente era stato sottoposto a quattro audit. “La modifica, pensata come ottimizzazione del gas, ci ha portato a rimuovere la linea di codice che controllava l’input fornito alla funzione”, ha spiegato il team.</p>
<p>L’hacker ha sfruttato il contratto CvxRewardDistributor tramite la funzione claimMultipleStaking, eludendo la convalida. Ciò ha permesso all’hacker di utilizzare un contratto dannoso separato con la stessa firma della funzione claimCvgCvxMultiple. Di conseguenza, l’hacker ha coniato tutti i token allocati per le emissioni di staking e li ha venduti nei pool di liquidità CVG, ha riferito Convergence.</p>
<p>Mentre Convergence ha assicurato che i fondi degli utenti rimangono sicuri, ha raccomandato agli utenti di ritirare i propri asset dalla piattaforma. ‘A causa dell’attacco, il contratto delle ricompense per l’integrazione di Stake DAO è attualmente non funzionante. Sarà riparato e gli stakeholder potranno richiedere le loro ricompense una volta che sarà stato sistemato. Nessuna ricompensa è stata persa per gli utenti dell’integrazione di Stake DAO’, ha dichiarato Convergence.</p>
<p>Convergence mira ad aggregare liquidità, migliorare i rendimenti e consentire il blocco dei liquidi all’interno dell’ecosistema Curve Finance. In seguito all’hack, il valore totale bloccato su Convergence è sceso da 5,79 milioni di dollari a 3,69 milioni di dollari, secondo i dati di DefiLlama. A luglio, l’ecosistema delle criptovalute ha visto circa 266 milioni di dollari persi a causa degli hack, principalmente a causa della violazione della piattaforma di trading indiana per 230 milioni di dollari <a href="https://www.gate.io/learn/articles/gate-research-bitcoin-retraces-to-the-63000-support-level-wazirx-suffers-over-230-million-loss-due-to-attack/3567" target="_blank">WazirX il 18 luglio</a>.</p>
<h2 id="h2-Protocollo20di20convergenza20spiegato949793"><a name="Protocollo di convergenza spiegato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Protocollo di convergenza spiegato</h2><p>Convergence Protocol è una piattaforma di finanza decentralizzata (DeFi) progettata per migliorare la liquidità e le opportunità di rendimento all’interno dell’ecosistema di Curve Finance. Il suo obiettivo principale è quello di aggregare liquidità da diverse fonti, ottimizzare i rendimenti per gli utenti e facilitare lo staking liquido, consentendo ai partecipanti di bloccare i propri asset pur mantenendo la liquidità.</p>
<p>Il protocollo raggiunge questo obiettivo integrando vari servizi e prodotti DeFi, creando un’esperienza senza soluzione di continuità per gli utenti che desiderano massimizzare i rendimenti sui propri asset scommessi. Fornisce una piattaforma dove gli utenti possono scommettere i propri token e guadagnare ricompense, partecipare a pool di liquidità e impegnarsi in strategie di yield farming. In questo modo, Convergence aiuta gli utenti a sfruttare al massimo i loro asset digitali senza la necessità di costante intervento manuale e monitoraggio.</p>
<p>Ultime notizie: <a href="https://www.gate.io/blog_detail/3081/curve-founder-168m-stash-faces-stress" target="_blank">La riserva di $168 milioni del fondatore di Curve affronta lo stress</a></p>
<p>Una delle caratteristiche chiave di Convergence è il suo focus sull’ottimizzazione del gas e sul design efficiente dei contratti intelligenti. Ciò garantisce che le transazioni sulla piattaforma siano economiche e veloci, minimizzando i costi indiretti associati alle operazioni blockchain. Inoltre, Convergence utilizza un solido framework di sicurezza per proteggere i fondi degli utenti e mantenere l’integrità della piattaforma.</p>
<p>Attraverso il suo approccio a DeFi, Convergence mira ad aprire l’accesso a strumenti finanziari avanzati e opportunità, permettendo agli utenti di partecipare all’economia decentralizzata con facilità e fiducia. La sua integrazione con l’ecosistema di Curve Finance ne aumenta ulteriormente l’attrattiva.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/8-defi-protocols-with-potential/3682" target="_blank">8 protocolli DeFi con potenziale - airdrop, rendimento, GF</a></p>
<h2 id="h2-Reazione20del20mercato20postsfruttamento142293"><a name="Reazione del mercato post-sfruttamento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reazione del mercato post-sfruttamento</h2><p>La reazione del mercato all’hack del protocollo Convergence l’1 agosto 2024 è stata grave e immediata. L’hack ha portato alla coniazione e alla vendita non autorizzata di 58 milioni di token CVG, con una perdita di circa 210.000 dollari. Questo exploit ha causato il crollo del prezzo di CVG del 99%, scendendo da circa 0,12 dollari a soli 0,0004 dollari. Questo drastico declino ha azzerato il valore di mercato completamente diluito del token, precedentemente stimato a 17 milioni di dollari.</p>
<p>A seguito dell’hack, Convergence ha emesso una comunicazione urgente consigliando agli utenti di evitare di interagire con il protocollo per evitare ulteriori rischi. I fondi rubati dall’hacker sono stati rapidamente convertiti in wrapped Ether (wETH) e stablecoin crvFRAX, che sono stati poi convogliati attraverso Tornado Cash per oscurare la loro traccia.</p>
<p>La risposta del mercato ha evidenziato una significativa perdita di fiducia nel protocollo, con gli investitori che ritirano rapidamente i loro fondi e il sentiment generale che si trasforma in modo estremamente negativo. L’incidente ha sottolineato l’importanza critica di una robusta <a href="https://www.gate.io/learn/articles/how-defi-protocols-generate-revenue-and-why-its-important/2890" target="_blank">misure di sicurezza nei protocolli DeFi</a> e il potenziale impatto delle violazioni di sicurezza sul valore del token e sulla fiducia degli investitori.</p>
<h2 id="h2-Hacks20di20DeFi20del202024529755"><a name="Hacks di DeFi del 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hacks di DeFi del 2024</h2><p>Nel 2024, il settore della finanza decentralizzata (DeFi) ha continuato ad affrontare significativi problemi di sicurezza, con diversi attacchi di alto profilo che hanno causato consistenti perdite finanziarie. Uno degli incidenti più notevoli è avvenuto con Prisma Finance, una piattaforma di restaking liquido che ha subito una perdita di 10 milioni di dollari a causa di uno sfruttamento di un prestito flash nel marzo 2024. L’attaccante ha prosciugato circa 3.257,7 ETH dal protocollo, costringendo Prisma Finance a sospendere le sue operazioni per un’indagine approfondita.</p>
<p>Leggi anche: <a href="https://www.gate.io/zh/learn/articles/a-defi-protocol-tailored-for-market-volatility/3618" target="_blank">Un protocollo DeFi su misura per la volatilità di mercato</a></p>
<p>Un altro importante violazione coinvolse BitForex, un exchange di criptovalute che sparì dopo aver prelevato quasi 57 milioni di dollari dai suoi portafogli caldi nel febbraio 2024. Questo incidente ha lasciato gli utenti impossibilitati ad accedere ai loro account e ha evidenziato le sfide regolamentari in corso a Hong Kong, dove BitForex era registrato.</p>
<p>Inoltre, PlayDapp, una piattaforma di crypto gaming e NFT, ha subito degli attacchi a febbraio che hanno portato alla coniazione non autorizzata di 1,79 miliardi di token PLA, del valore di oltre 290 milioni di dollari. L’hacker ha iniziato a riciclare i fondi a seguito dell’attacco, dimostrando le complessità coinvolte nel tracciare e recuperare gli asset rubati nello spazio DeFi.</p>
<p>Anche il mese di maggio 2024 ha visto un numero significativo di hack, per un totale di oltre 600 milioni di dollari di perdite. Tra questi, una compromissione della chiave privata ha portato a una perdita di 70 milioni di dollari per una crypto whale, anche se i fondi rubati sono stati successivamente restituiti dall’aggressore. Inoltre, GNUS, un <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> Il progetto basato su GNUS ha subito un hack da 1,27 milioni di dollari a causa di una vulnerabilità che ha permesso la creazione di token GNUS falsi.</p>
<div class="blog-details-info"><br><div>Autore:<em>Andrei</em>, 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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>