TGEgc3RyYWRhIGRpIHJpcHJlc2EgZGkgQ3VydmUgRmluYW5jZTogbGUgc2ZpZGUgZGkgRGVGaSBwZXIgZ2FyYW50aXJlIGxhIHNpY3VyZXp6YQ==

2024-06-26, 06:11

<p><img src="https://gimg2.gateimg.com/image/article/1719382125sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR15409"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il 10 giugno UwU Lend è stato attaccato e ha perso cripto-asset valutati circa $20 milioni.</p>
<p>Le liquidazioni che sono seguite allo sfruttamento del prestito UwU hanno portato Michael Egorov a incorrere in un debito inesigibile che, tuttavia, ha ripagato.</p>
<p>Le aziende DeFi dovrebbero adottare tecnologie avanzate e competenze per prevenire future attacchi di prestiti flash.</p>
<h2 id="h2-Introduzione176595"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>I crimini crittografici sembrano continuare nel 2024 nonostante alcuni periodi tranquilli lungo la strada. Purtroppo, c’è una tendenza in evoluzione in cui gli aggressori sfruttano i bug nelle piattaforme che offrono prestiti flash. L’attacco a UwU Lend, un protocollo di prestito decentralizzato (DeFi) che esiste sul <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La blockchain mostra la gravità della situazione. Nonostante gli sforzi di diversi protocolli di prestito per migliorare le loro misure di sicurezza, gli attori malintenzionati sembrano trovare modi per sfruttarli.</p>
<p>Oggi ci concentriamo su come l’attacco al protocollo di prestito UwU abbia creato caos per Curve Finance. Guarderemo anche al percorso di ripresa completo di Curve Finance.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/2637/curve-finance-crvusd-expanding-its-defi-stablecoin-platform" target="_blank">Curve Finance crvUSD, ampliando la sua piattaforma DeFi Stablecoin</a></p>
<h2 id="h2-Turbolenza20nel20settore20DeFi20coinvolgente20Curve20Finance957839"><a name="Turbolenza nel settore DeFi coinvolgente Curve Finance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Turbolenza nel settore DeFi coinvolgente Curve Finance</h2><p>Il protocollo di prestito UwU ha avuto due hack che sono avvenuti nella seconda settimana di giugno, creando turbolenza <a href="https://www.gate.io/blog_detail/648/what-is-curve-war-gain-insight-into-curve-the-stablecoin-exchange-leader" target="_blank">sulla piattaforma Curve Finance</a> Purtroppo, il secondo attacco è avvenuto mentre la società di criptovalute stava rimborsando le vittime del primo attacco.</p>
<p>L’attacco avvenuto il 10 giugno ha portato a una serie di eventi che hanno causato a Michael Egorov la perdita di oltre 100 milioni di dollari di prestiti che aveva su varie piattaforme. Quando i prestiti sono stati liquidati, <a href="https://www.gate.io/price/curve-dao-crv" target="_blank">prezzo dei token CRV</a> è crollato di circa il 30%. In un’altra sviluppo, UwU ha perso oltre 20 milioni di dollari dopo l’attacco del prestito flash.</p>
<p>Senza dubbio, la causa delle liquidazioni multimilionarie e dei debiti inesigibili di Curve Finance è stato l’attacco di prestito flash. Per contestualizzare, UwU Lend consente ai suoi utenti di prestare, prendere in prestito e scommettere su vari asset crypto. Secondo una pubblicazione di CoinDesk, <a href="https://www.coindesk.com/tech/2024/06/14/defi-heavyweight-curve-focused-on-becoming-safest-lending-platform-founder-says/" rel="nofollow noopener noreferrer" target="_blank">Michael Egorov ha detto</a>, ‘Il 15 aprile hanno (UwU Lend) implementato codice vulnerabile per i nuovi mercati (sUSDe) e quei mercati non sono isolati, quindi l’intera piattaforma corre il rischio.’</p>
<p>Ha continuato: “UwU è stato hackerato e l’hacker, come parte della strategia di incassare, ha depositato i CRV presi da UwU su lend.curve.fi (LlamaLend) e poi è scomparso con i fondi, lasciando il suo debito nel sistema”.</p>
<p>In <a href="https://x.com/newmichwill/status/1801255607137165390" rel="nofollow noopener noreferrer" target="_blank">un post X Egorov</a> spiegato: ‘Molti di voi sono consapevoli che ho liquidato tutti i miei prestiti. La dimensione delle mie posizioni era troppo grande per i mercati da gestire e ha causato 10M di debiti inesigibili. Solo il mercato CRV (dove la posizione era la più grande) è stato interessato’.</p>
<p>Egorov ha dato ragioni per la situazione critica. In un <a href="https://cointelegraph.com/news/curve-ceo-clarifies-uwu-hack-misinformation" rel="nofollow noopener noreferrer" target="_blank">intervista con Cointelegraph, ha detto</a>«I CRV depositati come garanzia per i prestiti ammontavano probabilmente al 30% dell’offerta circolante; la metà di questo era su Curve, quindi effettivamente si è generato un debito inesigibile. È stato già rimborsato. Nessuno è stato colpito.</p>
<p>Per le criptovalute non principali (ad esempio, non BTC o ETH come garanzia), probabilmente è opportuno stabilire limiti di prestito; i dati mostrano che i mercati specifici di Curve possono essere ben parametrizzati per resistere anche a queste condizioni.</p>
<p>Egorov ha anche sottolineato che il <a href="https://www.gate.io/learn/articles/what-is-curve/425" target="_blank">Piattaforma Curve Finance</a> stava lavorando per risolvere i problemi di liquidazione sorti dall’exploit crypto UwU. Secondo lui, sebbene il mercato DeFi di Curve Finance sia separato dagli altri pool di prestiti, i depositanti non ritireranno il loro CRV finché esisteranno i crediti inesigibili di Curve Finance. Egorov ha chiarito: “<br><strong>Il team di Curve Finance ed io abbiamo lavorato per risolvere il problema di rischio di liquidazione che è accaduto oggi</strong>,” ha aggiunto Michael.</p>
<p>Nonostante le liquidazioni multimilionarie e i debiti inesigibili, Egorov ha assicurato agli utenti di Curve Finance che saranno tutti in grado di prelevare i loro depositi. In modo ancora più significativo, ha promesso di rendere il protocollo criptato la piattaforma di prestito più sicura all’interno del mercato DeFi. Il fondatore di Curve Finance crede che i prodotti di prestito / prestito della piattaforma saranno i più sicuri nel settore.</p>
<p>Inoltre, Egorov ha parlato delle misure di sicurezza necessarie per prevenire future frodi crittografiche. Ad esempio, ha raccomandato che UwU Lend dovrebbe “ri-verificare tutti i contratti e connetterli a buoni revisori di sicurezza.” Ciò garantirà che i loro meccanismi di prestito collettivo siano affidabili e sicuri. Le revisioni periodiche aiuteranno anche a identificare eventuali codici vulnerabili nel sistema, evitando così future frodi crittografiche.</p>
<p>Egorov ha anche affermato che il settore dovrebbe utilizzare “bot di liquidazione open-source” e l’istruzione della comunità sulle liquidazioni. Secondo lui, se la giusta tecnologia e competenza fossero state utilizzate nel caso dello sfruttamento di UwU, le successive liquidazioni e i cattivi debiti sarebbero stati evitati. A tal fine, Egorov ha spiegato: Sembra che i giganti del settore non sapessero pienamente come affrontare le liquidazioni; non hanno tentato di fare liquidazioni parziali dure per la mia posizione su Curve. Alla fine, ho dovuto farlo da solo.</p>
<p>Secondo l’ultimo aggiornamento di Egorov, Curve Finance ha già ripagato i 10 milioni di dollari di debito inesigibile che è emerso dalle liquidazioni soft innescate dall’exploit UwU.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/curve-dao-crv" target="_blank">Previsione del prezzo e previsione di Curve DAO per il 2024, 2025, 2030</a></p>
<h2 id="h2-La20strategia20degli20hacker20che20coinvolge20i20token20CRV283164"><a name="La strategia degli hacker che coinvolge i token CRV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La strategia degli hacker che coinvolge i token CRV</h2><p>Per comprendere appieno quanto discusso sopra, spieghiamo come è avvenuto lo sfruttamento crittografico UwU e il suo effetto sul token CRV. In primo luogo, lo sfruttatore crittografico ha sfruttato un codice vulnerabile all’interno degli oracoli dei prezzi del protocollo, un componente che determina i prezzi degli asset. Dopo aver prosciugato vari asset crittografici, ha depositato CRV in LlamaLend, consentendogli di prendere in prestito oltre 8 milioni di crvUSD. Di conseguenza, lo sfruttatore è riuscito a scambiare i token CRV a un tasso migliore.</p>
<p>Tuttavia, il team UwU ha messo in pausa le transazioni quando hanno scoperto l’exploit. Nello sforzo di mitigare l’impatto dell’exploit sugli utenti, le piattaforme hanno impostato i tassi di prestito e deposito allo 0. Inoltre, nel tentativo di attirare l’hacker a restituire il bottino criptato, UwU ha offerto una ricompensa del 20% come bounty white-hat.</p>
<p>In sostanza, quella taglia era superiore al benchmark del settore del 10%. Il team ha promesso di pagare la ricompensa della taglia di $5 milioni in ETH. Chiunque aiuti a catturare l’attaccante può ottenere i promessi $5 milioni. Alcuni degli asset crittografici rubati dagli hacker erano uLUSD, uFRAX, uDAI di UwU, uCRVUSD, uWETH e uUSDT.</p>
<h2 id="h2-Conclusion548189"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Curve Finance ha perso $100 milioni a causa di liquidazioni multimilionarie a seguito dello sfruttamento crittografico di UwU Lend. Attraverso lo stesso hack, UwU Lend ha perso asset del valore di $20 milioni. Nel frattempo, UwU ha annunciato una ricompensa di $5 milioni per chiunque aiuti a trovare l’attaccante. Egorov ha esortato le aziende criptografiche del settore a migliorare le loro misure di sicurezza e a effettuare costanti audit per prevenire futuri attacchi.</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 venga fatto 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>