Q3VydmUgRmluYW5jZSdzIHdlZyBuYWFyIGhlcnN0ZWw6IERlRmktdWl0ZGFnaW5nZW4gb20gZGUgYmV2ZWlsaWdpbmcgdGUgZ2FyYW5kZXJlbg==

2024-06-26, 06:11

<p><img src="https://gimg2.gateimg.com/image/article/1719382125sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR694626"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Op 10 juni werd UwU Lend aanglen en verloor crypto-activa ter waarde van ongeveer $20 miljoen.</p>
<p>De liquidaties die volgden op de UwU-lening exploitatie leidden ertoe dat Michael Egorov een slechte schuld opliep die hij echter terugbetaalde.</p>
<p>DeFi-bedrijven moeten geavanceerde technologie en expertise aannemen om toekomstige flash-leningaanvallen te voorkomen.</p>
<h2 id="h2-Introductie564213"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Crypto misdaden lijken door te gaan in 2024 ondanks enkele stille periodes onderweg. Helaas is er een evoluerende trend waarbij de aanvallers profiteren van bugs in platforms die flashleningen aanbieden. De aanval op UwU Lend, een gedecentraliseerd financieel (DeFi) uitleenprotocol dat bestaat op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain, toont de ernst van de situatie. Ondanks de inspanningen van verschillende uitleenprotocollen om hun beveiligingsmaatregelen te verbeteren, lijken kwaadwillende actoren manieren te vinden om ze te misbruiken.</p>
<p>Vandaag richten we ons op hoe de aanval van het UwU-uitleenprotocol onrust veroorzaakte voor Curve Finance. We zullen ook kijken naar de weg van Curve Finance naar volledig herstel.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/blog_detail/2637/curve-finance-crvusd-expanding-its-defi-stablecoin-platform" target="_blank">Curve Finance crvUSD, breidt zijn DeFi Stablecoin Platform uit</a></p>
<h2 id="h2-Onrust20in20de20DeFisector20met20betrekking20tot20Curve20Finance174648"><a name="Onrust in de DeFi-sector met betrekking tot Curve Finance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Onrust in de DeFi-sector met betrekking tot Curve Finance</h2><p>Het UwU uitleenprotocol had twee hacks die plaatsvonden in de tweede week van juni, wat voor onrust zorgde. <a href="https://www.gate.io/blog_detail/648/what-is-curve-war-gain-insight-into-curve-the-stablecoin-exchange-leader" target="_blank">op het Curve Finance-platform</a> Helaas vond de tweede aanval plaats toen het cryptobedrijf bezig was met het terugbetalen van slachtoffers van de eerste aanval.</p>
<p>De aanval die plaatsvond op 10 juni leidde tot een reeks gebeurtenissen die ertoe leidden dat Michael Egorov meer dan $100 miljoen verloor aan leningen die hij op verschillende platforms had. Toen de leningen werden geliquideerd <a href="https://www.gate.io/price/curve-dao-crv" target="_blank">CRV-tokenprijs</a> daalde met ongeveer 30%. In een gerelateerde ontwikkeling verloor UwU meer dan $20 miljoen na de flash-leningaanval.</p>
<p>Zonder twijfel was de oorzaak van de multimiljoenenverliezen en slechte schulden van Curve Finance de flash loan-aanval. Ter info, UwU Lend stelt zijn gebruikers in staat om verschillende crypto-activa uit te lenen, te lenen en te staken. Volgens een publicatie van 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 zei</a> Op 15 april hebben ze (UwU Lend) kwetsbare code geïmplementeerd voor nieuwe (sUSDe) markten, en die markten zijn niet geïsoleerd, dus het hele platform loopt risico.</p>
<p>Hij ging verder: “UwU werd gehackt, en de hacker, als onderdeel van een cash-out spel, deponeerde CRV’s die van UwU waren genomen om uit te lenen.curve.fi (LlamaLend) en verdween met de fondsen, waarbij hij zijn schuld in het systeem achterliet.”</p>
<p>In <a href="https://x.com/newmichwill/status/1801255607137165390" rel="nofollow noopener noreferrer" target="_blank">een X post Egorov</a> legt uit: “Velen van jullie zijn op de hoogte dat al mijn leningen geliquideerd zijn. De omvang van mijn posities was te groot voor de markten om te verwerken en veroorzaakte 10 miljoen aan slechte schulden. Alleen de CRV-markt (waar de positie het grootst was) werd beïnvloed.”</p>
<p>Egorov gaf redenen voor de benarde situatie. In een <a href="https://cointelegraph.com/news/curve-ceo-clarifies-uwu-hack-misinformation" rel="nofollow noopener noreferrer" target="_blank">in een interview met Cointelegraph zei hij</a>“De CRV’s die als onderpand voor leningen werden geplaatst, bedroegen waarschijnlijk 30% van de circulerende voorraad; de helft daarvan stond op Curve, dus inderdaad, er was sprake van enige slechte schuld. Het is al terugbetaald. Niemand is hierdoor getroffen.</p>
<p>Voor niet-belangrijke cryptovaluta (bijv. niet BTC of ETH als onderpand), moet men waarschijnlijk leenlimieten verstrekken; gegevens tonen aan dat Curve-specifieke markten goed geparameteriseerd kunnen worden om zelfs deze omstandigheden te weerstaan.</p>
<p>Egorov benadrukte ook dat de <a href="https://www.gate.io/learn/articles/what-is-curve/425" target="_blank">Curve Finance-platform</a> het team werkte aan het oplossen van liquidatieproblemen die voortkwamen uit de UwU crypto exploit. Volgens hem zouden de deposito’s hun CRV niet opnemen zolang de slechte schuld van Curve Finance bestond.<br><strong>Het Curve Finance-team en ik hebben gewerkt aan het oplossen van het liquidatierisico dat vandaag is opgetreden.</strong>,” voegde Michael toe.</p>
<p>Ondanks de multimiljoen liquidaties en slechte schulden verzekerde Egorov de Curve Finance gebruikers dat ze allemaal in staat zullen zijn om hun deposito’s op te nemen. Belangrijker nog, hij beloofde om het crypto-protocol het veiligste uitleenplatform binnen de DeFi-markt te maken. De oprichter van Curve Finance gelooft dat de uitleen/leenproducten van het platform de veiligste in de sector zullen zijn.</p>
<p>Bovendien sprak Egorov over de noodzakelijke veiligheidsmaatregelen om toekomstige crypto-exploits te voorkomen. Zo raadde hij aan dat UwU Lend alle contracten opnieuw zou moeten controleren en deze zou moeten koppelen aan goede beveiligingsauditors. Dit zal ervoor zorgen dat hun collectieve uitleenmechanismen solide en veilig zijn. Eeuwige audits zullen ook helpen bij het identificeren van kwetsbare code in het systeem, waardoor toekomstige crypto-exploitaties worden voorkomen.</p>
<p>Egorov zei ook dat de industrie ‘open-source liquidatiebots’ zou moeten gebruiken en de gemeenschap zou moeten voorlichten over liquidaties. Volgens hem zouden de daaropvolgende liquidaties en slechte schulden in het g van de UwU-exploit vermeden zijn geweest als de juiste technologie en expertise waren gebruikt. In dit verband legde Egorov uit: Het lijkt erop dat zwaargewichten in de industrie niet volledig wisten hoe ze met liquidaties moesten omgaan; ze hebben geen poging gedaan om gedeeltelijke harde liquidaties uit te voeren voor mijn positie bij Curve. Uiteindelijk moest ik het zelf doen.</p>
<p>Volgens de meest recente update van Egorov heeft Curve Finance al de $10 miljoen aan slechte schulden terugbetaald die ontstonden door de zachte liquidaties die werden veroorzaakt door het UwU-exploit.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/curve-dao-crv" target="_blank">Curve DAO prijsvoorspelling en prognose voor 2024, 2025, 2030</a></p>
<h2 id="h2-Strategie20van20de20hacker20met20betrekking20tot20CRVtokens990909"><a name="Strategie van de hacker met betrekking tot CRV-tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Strategie van de hacker met betrekking tot CRV-tokens</h2><p>Om volledig te begrijpen wat we hierboven hebben besproken, laten we uitleggen hoe het UwU crypto-exploitantie plaatsvond en welk effect dit had op de CRV-token. Allereerst maakte de crypto-exploitant gebruik van een kwetsbare code binnen de prijsorakels van het protocol, een component die de prijzen van de activa bepaalt. Nadat de hacker verschillende crypto-activa had leeggehaald, stortte hij/zij CRV in LlamaLend, waardoor hij/zij meer dan 8 miljoen crvUSD kon lenen. Als gevolg hiervan kon de exploitant de CRV-tokens tegen een betere koers omwisselen.</p>
<p>Echter heeft het UwU-team de transacties gepauzeerd toen ze het lek ontdekten. Om de impact van het lek op de gebruikers te beperken, heeft het platform de uitleen- en stortingsrente op 0 gezet. Ook heeft UwU een beloning van 20% aangeboden aan de hacker in een poging om de gestolen crypto terug te krijgen.</p>
<p>Eigenlijk was die beloning hoger dan de branchestandaard van 10%. Het team beloofde de beloning van $5 miljoen uit te betalen in ETH. Iedereen die helpt om de aanvaller te pakken te krijgen, kan de beloofde $5 miljoen krijgen. Enkele van de crypto-activa die de hackers hebben gestolen, waren uLUSD, uFRAX, UwU’s uDAI, uCRVUSD, uWETH en uUSDT.</p>
<h2 id="h2-Conclusie248851"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Curve Finance verloor $100 miljoen als gevolg van multimiljoen liquidaties als gevolg van de UwU Lend crypto exploit. Via dezelfde hack verloor UwU Lend activa ter waarde van $20 miljoen. Ondertussen heeft UwU een beloning van $5 miljoen aangekondigd voor iedereen die helpt om de aanvaller te vinden. Egorov drong er bij crypto-bedrijven in de sector op aan om hun beveiligingsmaatregelen te verbeteren en regelmatige audits uit te voeren om toekomstige hacks te voorkomen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>