SGVkZ2V5IEZpbmFuY2UgZ2V0cm9mZmVuIGRvb3IgJDQ1IG1pbGpvZW4gY3liZXJhYW52YWw6IEVlbiB3YWtlLXVwIGNhbGwgdm9vciBkZSBCbG9ja2NoYWluIFNlY3VyaXR5

2024-05-08, 06:48

<p><img src="https://gimg2.gateimg.com/image/article/1715150452rdzz.jpeg" alt=""></p>
<h2 id="h2-TL20DR806195"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Hedgey Finance verloor bijna $45 miljoen aan crypto-activa nadat hackers DeFi-kwetsbaarheden in het protocol hadden benut.<br>Cyvers s roept op tot realtime monitoring van transacties op DeFi-protocollen.</p>
<p>Cyvers  heeft gewaarschuwd voor mogelijke witwassen nadat de gestolen crypto-activa van Hedgey Finance en FixedFloat naar hetzelfde portefeuilleadres op Bybit-exchange werden geleid.</p>
<h2 id="h2-Introductie415834"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De dreiging van cyberaanvallen op DeFi-protocollen en andere op blockchain gebaseerde platforms blijft bestaan. Ondanks de waarschuwingen die al lange tijd worden gegeven, slagen sommige blockchain-protocollen er niet in om sterke beveiligingsmaatregelen te implementeren om mogelijke bedreigingen te voorkomen. Het trieste is dat de aanvallers meestal dezelfde methoden gebruiken om digitale activa te misleiden.</p>
<p>Dit artikel gaat over hoe enkele kwaadwillende aanvallers bijna $45 miljoen aan crypto-activa hebben gestolen van Hedgey Finance. In het bijzonder zullen we analyseren hoe de aanvallers hebben geprofiteerd van de zwaktes in het protocol.</p>
<h2 id="h2-Cyberaanval20op20Hedgey20Finance20resulteert20in20een20verlies20van204520miljoen820553"><a name="Cyberaanval op Hedgey Finance resulteert in een verlies van $45 miljoen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cyberaanval op Hedgey Finance resulteert in een verlies van $45 miljoen</h2><p>Op 19 april werd Hedgey Finance het slachtoffer van een cyberaanval, wat leidde tot een verlies van cryptotegoeden ter waarde van ongeveer $45 miljoen. De aanvallers hebben de cryptocurrencies afgetapt door middel van een reeks transacties. Cryptotegoeden ter waarde van $2,1 miljoen werden weggelekt uit de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> mainnet, terwijl er voor $42.6 miljoen aan digitale activa gestolen werden <a href="https://www.gate.io/learn/articles/a-deep-dive-into-arbitrum/487" target="_blank">van het Arbitrum blockchain</a>. In totaal werd er via de Hedge Finance Cyberaanval voor ongeveer $44,7 aan cryptocurrencies gestolen.</p>
<p>In feite is Hedgey Finance een blockchain-protocol dat on-chain token vesting, claimportalen en lock-ups creëert en beheert, naast andere cryptodiensten. De aanval op Hedgey Finance heeft geleid tot een hernieuwde <a href="https://www.gate.io/blog_detail/1672/10-best-defi-protocols-to-invest-during-bear-markets" target="_blank">roept op tot DeFi-protocollen</a> om hun blockchain-beveiliging te versterken om verlies van geïnvesteerde fondsen te voorkomen.</p>
<p>Kort nadat Hedgey Finance de cyberaanval had opgemerkt, heeft het zijn gebruikers op de hoogte gebracht van de ontwikkelingen. Postend <a href="https://twitter.com/hedgeyfinance/status/1781400318644810138" rel="nofollow noopener noreferrer" target="_blank">op X, zei het</a>“We zullen de komende dagen een volledige post mortem uitvoeren. Op dit moment richten we ons op het werken met de getroffen gebruikers van het tokenclaims-product en het herstellen van verloren fondsen.”</p>
<p>Het voegde eraan toe: “Naast onze bestaande beveiligingsaudits werken we samen met ConsenSys Diligence om aanvullende audits en beveiligingsprocedures voor al onze producten voor te bereiden. We zullen updates delen en meer gedetailleerde informatie verstrekken naarmate de week vordert.”</p>
<h2 id="h2-Cyvers20het20cyberbeveiligingsbedrijf20dat20het20incident20heeft20opgespoord816968"><a name="Cyvers, het cyberbeveiligingsbedrijf dat het incident heeft opgespoord" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cyvers, het cyberbeveiligingsbedrijf dat het incident heeft opgespoord</h2><p>Cyvers s, een van de toonaangevende waakhonden op het gebied van cyberbeveiliging, was de eerste die de crypto-gemeenschap waarschuwde voor de crypto cyberaanval op Hedgey Finance. Nadat het de exploit had opgemerkt, probeerde het te communiceren met Hedgey Finance via verschillende kanalen, maar kreeg geen reactie. Ook waarschuwde Etherscan de gebruikers via zijn site voor de aanval, zoals de volgende afbeelding aangeeft.<br><img src="https://gimg2.gateimg.com/image/article/17151506901.jpeg" alt=""><br>Bron <a href="https://etherscan.io/address/0xd84f48b7d1aafa7bd5905c95c5d1ffb2625ada46" rel="nofollow noopener noreferrer" target="_blank">Etherscan</a></p>
<p>Opmerkelijk is dat de hackers de gestolen crypto-activa hebben omgewisseld naar DAI voordat ze deze naar hun digitale portemonnee verplaatsten. Het niet opmerken door Hedgey Finance van waarschuwingen van het cybersecuritybedrijf wijst op de noodzaak voor blockchainbedrijven om te allen tijde waakzaam te zijn.</p>
<h2 id="h2-Verkennen20van20de20Exploitmethode20CreateLockedCampaignfunctie20en20Flashleningen178168"><a name="Verkennen van de Exploit-methode: ‘CreateLockedCampaign’-functie en Flash-leningen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verkennen van de Exploit-methode: ‘CreateLockedCampaign’-functie en Flash-leningen</h2><p>De aanvallers hebben de cryptomiddelen afgetapt op <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Arbitrum en <a href="https://www.gate.io/price/view/binance-smart-chain" target="_blank">Binance Smart Chain</a> na het overwinnen van de digitale verdediging van Hedgey Finance. Momenteel richten veel hackers zich op flashleningen, een vorm van ongedekt krediet dat wordt gebruikt in DeFi, omdat ze verschillende crypto-activa kunnen leeghalen via enkele transactieblokken.</p>
<p>In dit g gaf Cyvers s een update over de aanvalsmethode die de uitbuiters gebruikten. De kwaadwillende aanvallers maakten gebruik van de DeFi-kwetsbaarheden binnen het Hedgey Finance-protocol. Hun aanvalsmethode was een flashlening kwetsbaarheid. Om toegang te krijgen tot de flashleningen maakten ze misbruik van de ‘createLockedCampaign’-functie van het protocol.</p>
<p>Het werkelijke probleem was het ontbreken van invoervalidatie aan de kant van Hedgey Finance-gebruikers. Vanwege die zwakte in de crypto-cyberbeveiliging heeft de aanvaller het systeem gemanipuleerd en ongeautoriseerde token-goedkeuringen verkregen. Nadat ze toegang hadden gekregen tot de tokens, hebben de hackers een oproep gedaan naar de ‘cancelCampaign-functie’, waarmee ze de goedgekeurde en ongeclaimde activa konden ophalen.</p>
<p>De laatste activiteit was het overdragen van de activa van het slachtoffercontract naar het hunne. Om te slagen met deze stap vermeden ze de front-run door bots. De aanvallers hebben USDC, NOBL en MASA-tokens gestolen die ze hebben omgezet naar DAI. <a href="https://www.gate.io/learn/articles/what-is-pegging-in-crypto/802" target="_blank">een stablecoin gekoppeld</a> naar de Amerikaanse dollar. Bovendien hebben ze ook 77,74 miljoen BONUS-tokens verworven.</p>
<p>In de nasleep van die aanval adviseerde Cyvers de crypto-industrie om een gecoördineerde aanpak te hanteren om soortgelijke bedreigingen voor de crypto-industrie te voorkomen. Het benadrukte de noodzaak voor gedecentraliseerde applicaties (dApps) en beveiligingsbedrijven om samen te werken om de risico’s die in de sector bestaan te beperken, zodat het vertrouwen en het vertrouwen in het crypto-ecosysteem kunnen worden hersteld.</p>
<h2 id="h2-Reactie20en20Antwoord20van20Hedgey484735"><a name="Reactie en Antwoord van Hedgey" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Reactie en Antwoord van Hedgey</h2><p>Het Hedgey Team erkende de diefstal van cryptocurrency via de flash loan exploit. Het plaatsen op zijn X-pagina. <a href="https://twitter.com/hedgeyfinance/status/1781257581488418862" rel="nofollow noopener noreferrer" target="_blank">het zei</a> We onderzoeken een aanval op het Hedgey Token Claim Contract. Als je actieve claims hebt gemaakt, annuleer deze dan met behulp van de “End Token Claim”.</p>
<p>Ondertussen kondigde het team aan dat het een onderzoek uitvoerde naar wat er gebeurd was. Het zei dat het samenwerkte met auditors om de echte oorzaak van de exploit te identificeren en beloofde sterkere maatregelen te implementeren voor de bescherming van digitale activa om te zorgen dat er in de toekomst geen vergelijkbare exploitatie zal plaatsvinden.</p>
<p>Een andere trieste ontwikkeling die plaatsvond nadat het nieuws van de aanval de crypto-markt bereikte, was de imitatie van Hedge Finance door meerdere oplichtersaccounts. Ze plaatsten berichten met mogelijk schadelijke links en vroegen de gebruikers van Hedgey Finance om hun smart contract-goedkeuringen in te trekken of om terugbetalingen te vragen.</p>
<h2 id="h2-Zorgen20over20witwassen20van20geld462566"><a name="Zorgen over witwassen van geld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zorgen over witwassen van geld</h2><p>Cyvers heeft gesuggereerd dat de gestolen crypto activa mogelijk worden gebruikt voor het witwassen van geld in crypto doeleinden. Dit volgt op een overdracht van een groot bedrag aan fondsen naar de Bybit crypto exchange. Eerder ontving hetzelfde adres veel crypto fondsen van FixedFloat, een andere cryptocurrency exchange, die ook te maken kreeg met een crypto diefstal van $2,8 miljoen.</p>
<p>De diefstal van crypto van Hedgey Finance duidt op een toename van beveiligingsdreigingen binnen de DeFi-sector. Daarom benadrukt het de noodzaak voor DeFi-bedrijven om real-time monitoring van crypto-services te implementeren en de adoptie van snelle responsmechanismen.</p>
<h2 id="h2-Geschiedenis20van20Crypto20Exploits20in202024380362"><a name="Geschiedenis van Crypto Exploits in 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Geschiedenis van Crypto Exploits in 2024</h2><p>De aanval op Hedgey Finance maakt deel uit van een bredere trend binnen de cryptocurrency sector. Sommige van deze hacks zijn gekoppeld aan het witwassen van geld in crypto, gepleegd door georganiseerde criminele groepen zoals de Lazarus Group, een Noord-Koreaans overheidsfiliaal. Volgens Cyvers s is er tot nu toe in 2024 in totaal bijna $739,7 miljoen aan cryptocurrency gestolen, zoals blijkt uit de volgende grafiek.<br><img src="https://gimg2.gateimg.com/image/article/17151508472.jpeg" alt=""><br>Bron: <a href="https://twitter.com/Cyvers_/status/1777640598230684103/photo/1" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Op basis van dergelijke statistieken is het duidelijk dat de cyberaanvallers die DeFi-protocollen viseren, vertrouwd zijn met de evoluerende beveiligingsmaatregelen van blockchain. Tegelijkertijd is het vereist dat er een gezamenlijke inspanning is onder spelers in de blockchainsector om toekomstige schade te voorkomen.</p>
<h2 id="h2-Conclusie535335"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Hedgey Finance verloor bijna $45 miljoen aan cryptomiddelen door een recente beveiligingsinbreuk op zijn protocol. Cyber kwaadwillende actoren richten zich steeds vaker op platforms die flashleningen aanbieden omdat ze weg kunnen komen met veel cryptocurrencies door een paar transacties. Ondertussen heeft Cyvers  opgeroepen tot eenheid van doeleinden tussen blockchain beveiligingsbedrijven en DeFi-protocollen om toekomstige crypto-exploitaties 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 visie 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 is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>