RGVGaS1wcm90b2NvbGhhY2sgcmVzdWx0ZWVydCBpbiAkMjEySyB2ZXJsaWVzIGFscyBnZXZvbGcgdmFuIGt3ZXRzYmFhcmhlaWQgaW4gc2xpbSBjb250cmFjdA==

2024-08-14, 02:52

<p><img src="https://gimg2.gateimg.com/image/article/17236036501690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR239200"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Op 1 augustus werd het gedecentraliseerde financiële protocol Convergence getroffen door een beveiligingslek als gevolg van een kwetsbaarheid in het slimme contract.</p>
<p>Een hacker of een team van hackers slaagde erin om het lek te misbruiken, waardoor ze $210.000 aan zijn eigen token konden slaan en verkopen, en ook $2.000 aan ongeclaimde staking beloningen konden stelen.</p>
<p>Wireshark, de pseudonieme oprichter van Convergence, heeft een gedetailleerd post-mortem rapport verstrekt waarin wordt onthuld dat de hacker zich richtte op het CvxRewardDistributor-contract van het protocol.</p>
<p>Dit stelde de hacker in staat om 58 miljoen CVG-tokens te slaan en verkopen, met een opbrengst van ongeveer $210.000.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/defi-eco-2024-preview-key-trends-and-direction-predictions-for-the-industry/1387" target="_blank">DeFi Ecosysteem 2024 Outlook: Belangrijkste Trends en Richtingen</a></p>
<p>Bovendien heeft de hacker ongeveer $2.000 aan ongeclaimde beloningen gestolen van Convex, een DeFi-protocol gericht op het optimaliseren van beloningen. <a href="https://www.gate.io/learn/articles/what-is-curve/425" target="_blank">voor Curve</a> Liquiditeitsverschaffers. Etherscan-gegevens geven aan dat de aanval plaatsvond rond 3:00 uur UTC op 1 augustus.</p>
<p>PeckShield, een blockchain-beveiligingsbedrijf, merkte op dat nadat de CVG-tokens waren aangemaakt, de hacker ze snel heeft omgezet in 60 verpakte Ether en 15.900 Curve.fi. <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">FRAX</a> Als gevolg van deze acties heeft de CVG-bestuurstoken een bijna 100% prijscrash meegemaakt en wordt nu verhandeld op $0,0004 met een marktkapitalisatie van slechts $57.000, volgens CoinMarketCap.</p>
<h2 id="h2-Incidentdetails693609"><a name="Incidentdetails" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Incidentdetails</h2><p>Convergence heeft bekendgemaakt dat het incident zich heeft voorgedaan omdat het team per ongeluk een cruciale regel code heeft verwijderd in zijn slimme contract dat verantwoordelijk is voor het verdelen van CVG-staking beloningen. Deze wijziging werd doorgevoerd nadat het slimme contract vier keer was gecontroleerd. ‘De aanpassing, bedoeld als gasoptimalisatie, leidde ertoe dat we de regel code hebben verwijderd die de invoer controleerde die aan de functie werd gegeven’, legde het team uit.</p>
<p>De hacker heeft de CvxRewardDistributor contract misbruikt via de claimMultipleStaking functie, de validatie omzeild. Dit stelde de hacker in staat om een apart kwaadaardig contract te gebruiken met dezelfde handtekening als de claimCvgCvxMultiple functie. Als gevolg hiervan heeft de hacker alle tokens die waren toegewezen voor staking emissies gemunt en verkocht in CVG liquiditeitspools, meldde Convergence.</p>
<p>Hoewel Convergence heeft bevestigd dat de fondsen van gebruikers veilig zijn, wordt gebruikers aangeraden hun activa van het platform op te nemen. ‘Vanwege de aanval is het rewards-contract voor de Stake DAO-integratie momenteel niet functioneel. Het zal worden gerepareerd en stakers zullen in staat zijn om hun rewards op te eisen zodra het is opgelost. Er zijn geen rewards verloren gegaan voor gebruikers van de Stake DAO-integratie,’ aldus Convergence.</p>
<p>Convergence heeft als doel liquiditeit te bundelen, rendementen te verbeteren en vloeibaar sloten mogelijk te maken binnen het Curve Finance ecosysteem. Na de hack is de totale waarde die op Convergence is vergrendeld gedaald van $5,79 miljoen naar $3,69 miljoen, volgens gegevens van DefiLlama. In juli zag het cryptocurrency ecosysteem ongeveer $266 miljoen verloren gaan aan hacks, voornamelijk als gevolg van de $230 miljoen inbreuk op het Indiase handelsplatform. <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 op 18 juli</a>.</p>
<h2 id="h2-Uitleg20van20het20Convergence20Protocol608727"><a name="Uitleg van het Convergence Protocol" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Uitleg van het Convergence Protocol</h2><p>Convergence Protocol is een gedecentraliseerd financieel (DeFi) platform dat is ontworpen om de liquiditeit en rendementsmogelijkheden binnen het Curve Finance-ecosysteem te verbeteren. Het primaire doel is om liquiditeit uit verschillende bronnen samen te voegen, het rendement voor gebruikers te optimaliseren en liquide staking te vergemakkelijken, waardoor deelnemers hun activa kunnen vergrendelen terwijl ze toch liquiditeit behouden.</p>
<p>Het protocol bereikt dit door verschillende DeFi-diensten en -producten te integreren, waardoor een naadloze ervaring ontstaat voor gebruikers die hun rendement op ingezette activa willen maximaliseren. Het biedt een platform waar gebruikers hun tokens kunnen inzetten en beloningen kunnen verdienen, kunnen deelnemen aan liquiditeitspools en kunnen profiteren van yield farming-strategieën. Op deze manier helpt Convergence gebruikers optimaal gebruik te maken van hun digitale activa zonder de noodzaak van constante handmatige interventie en monitoring.</p>
<p>Recent nieuws: <a href="https://www.gate.io/blog_detail/3081/curve-founder-168m-stash-faces-stress" target="_blank">De $168 miljoen van de Curve-oprichter wordt geconfronteerd met stress</a></p>
<p>Een van de belangrijkste kenmerken van Convergence is de focus op gasoptimalisatie en efficiënt ontwerp van slimme contracten. Dit zorgt ervoor dat transacties op het platform kosteneffectief en snel zijn, waarbij de overheadkosten die gepaard gaan met blockchain-operaties worden geminimaliseerd. Daarnaast maakt Convergence gebruik van een robuust beveiligingsframework om gebruikersfondsen te beschermen en de integriteit van het platform te waarborgen.</p>
<p>Met zijn benadering van DeFi streeft Convergence ernaar toegang te bieden tot geavanceerde financiële tools en kansen, waardoor gebruikers met gemak en vertrouwen kunnen deelnemen aan de gedecentraliseerde economie. De integratie met het Curve Finance-ecosysteem versterkt verder zijn aantrekkingskracht.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/8-defi-protocols-with-potential/3682" target="_blank">8 DeFi-protocollen met potentieel - airdrops, opbrengst, GF</a></p>
<h2 id="h2-Marktreactie20na20exploit64593"><a name="Marktreactie na exploit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktreactie na exploit</h2><p>De marktreactie op de Convergence-protocolhack op 1 augustus 2024 was ernstig en onmiddellijk. De hack leidde tot het slaan en ongeoorloofd verkopen van 58 miljoen CVG-tokens, wat resulteerde in een verlies van ongeveer $ 210.000. Dit exploot zorgde ervoor dat de prijs van CVG met 99% daalde, van ongeveer $ 0,12 naar slechts $ 0,0004. Deze drastische daling veegde de volledig verwaterde marktwaarde van de token uit, die eerder werd geschat op $ 17 miljoen.</p>
<p>Na de hack heeft Convergence een dringende mededeling uitgegeven waarin gebruikers geadviseerd wordt om niet met het protocol te interacteren om verdere risico’s te voorkomen. Het gestolen geld van de hacker werd snel omgezet in wrapped Ether (wETH) en crvFRAX stablecoins, die vervolgens via Tornado Cash werden doorgesluisd om hun spoor te verbergen.</p>
<p>De marktreactie benadrukte een aanzienlijk verlies aan vertrouwen in het protocol, waarbij investeerders snel hun geld terugtrokken en het algemene sentiment sterk negatief werd. Het incident benadrukte het cruciale belang van een robuuste <a href="https://www.gate.io/learn/articles/how-defi-protocols-generate-revenue-and-why-its-important/2890" target="_blank">veiligheidsmaatregelen in DeFi-protocollen</a> en de mogelijke gevolgen van beveiligingslekken voor de waarde van tokens en het vertrouwen van investeerders.</p>
<h2 id="h2-DeFi20Hacks20van20202451652"><a name="DeFi Hacks van 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeFi Hacks van 2024</h2><p>In 2024 heeft de gedecentraliseerde financiële (DeFi) sector nog steeds te maken met aanzienlijke beveiligingsuitdagingen, met verschillende spraakmakende hacks die hebben geleid tot aanzienlijke financiële verliezen. Een van de meest opvallende incidenten deed zich voor bij Prisma Finance, een platform voor vloeibare herstaking dat in maart 2024 een verlies van $10 miljoen leed als gevolg van een flash-lening exploit. De aanvaller heeft ongeveer 3.257,7 ETH uit het protocol weggehaald, waardoor Prisma Finance zijn activiteiten moest pauzeren voor een grondig onderzoek.</p>
<p>Lees ook: <a href="https://www.gate.io/zh/learn/articles/a-defi-protocol-tailored-for-market-volatility/3618" target="_blank">Een DeFi-protocol op maat gemaakt voor marktvolatiliteit</a></p>
<p>Een andere grote inbreuk betrof BitForex, een cryptocurrency-uitwisseling die verdween nadat het bijna $57 miljoen had opgenomen uit zijn hot wallets in februari 2024. Deze gebeurtenis zorgde ervoor dat gebruikers geen toegang meer hadden tot hun accounts en benadrukte voortdurende regelgevende uitdagingen in Hong Kong, waar BitForex was geregistreerd.</p>
<p>Bovendien heeft PlayDapp, een crypto gaming- en NFT-platform, in februari te maken gehad met exploits die hebben geleid tot de ongeautoriseerde aanmaak van 1,79 miljard PLA-tokens, ter waarde van meer dan $290 miljoen. De hacker begon de fondsen te witwassen na de exploit, wat de complexiteit aantoont van het bijhouden en terugvorderen van gestolen activa in de DeFi-ruimte.</p>
<p>In de maand mei 2024 was er ook een aanzienlijk aantal hacks, met in totaal meer dan 600 miljoen dollar aan verliezen. Een van deze zaken leidde een inbreuk op een privésleutel tot een verlies van $ 70 miljoen voor een crypto-walvis, hoewel het gestolen geld later door de aanvaller werd teruggegeven. Daarnaast is GNUS, een <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a>-gebaseerd project, leed een hack van $1.27 miljoen door een kwetsbaarheid die het slaan van valse GNUS-tokens mogelijk maakte​.</p>
<div class="blog-details-info"><br><div>Auteur:<em>Andrei</em>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel wordt toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>