V2hpdGUgSGFja2VyIE9udGRla3QgZWVuICQxLDMgbWlsam9lbiBEZUZpIEV4cGxvaXQ=

2024-03-06, 02:23

<p><img src="https://gimg2.gateimg.com/image/article/1709691770sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR642669"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Een white hat hacker herstelde $1.3 miljoen aan gestolen crypto-activa van Blueberry Protocol.</p>
<p>Dezelfde white hat hacker, met de naam @ coffeebabe_eth, heeft in 2023 $5,4 miljoen hersteld voor Curve Finance.</p>
<p>White hat hacking stelt DeFi-protocollen in staat om kwetsbaarheden in hun en te identificeren</p>
<p><strong>Trefwoorden</strong>: DeFi-protocollen, ethische hacker, crypto-exploit, DeFi-exploit, crypto-hackers, white hat hacker, aanval van crypto-bots, crypto-verliezen, crypto-ecosysteem, cryptodreiging</p>
<h2 id="h2-Introductie611451"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De grootste bedreiging voor cryptocurrencies als een vorm van digitaal geld en opslag van waarde is hacken en andere vormen van cyberdiefstal zoals <a href="https://www.gate.io/blog_detail/1425/what-is-phishing-and-how-to-protect-ourselves-from-phishing-attacks" target="_blank">phishing</a> Sinds de vroege dagen van digitale activa hebben kwaadwillende actoren crypto-activa gestolen van investeerders en bedrijven die actief zijn in de cryptocurrency sector. In de loop der jaren hebben dergelijke bedreigingen de adoptiesnelheid van digitale activa beïnvloed.</p>
<p>De beste manier om diefstal van digitale activa te voorkomen, is door middel van een hoge infrastructuurbeveiliging en auditing. Desalniettemin kunnen cryptoprojecten ook gebruikmaken van ethische hackers om hun beveiligingsniveaus te testen en zo de mogelijkheid van Defi-exploit te verminderen. Vandaag kijken we naar hoe ethische hackers in het verleden diefstal van crypto-activa hebben voorkomen.<br>Lees ook: <a href="https://www.gate.io/learn/articles/what-is-a-sandwich-attack/936" target="_blank">Wat is Sandwich Attack?</a></p>
<h2 id="h2-Blueberry20Protocol20onder20dreiging20White20Hat20Hacker20neutraliseert20DeFiexploit20op202320februari950788"><a name="Blueberry Protocol onder dreiging: White Hat Hacker neutraliseert DeFi-exploit op 23 februari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Blueberry Protocol onder dreiging: White Hat Hacker neutraliseert DeFi-exploit op 23 februari</h2><p>Het Blueberry Protocol, een gedecentraliseerd platform dat leningen mogelijk maakt, werd op 23 februari aanglen en stond op het punt om crypto-verliezen van 457,6 te lijden. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> (ETH), ter waarde van ongeveer $1,3 miljoen op dat moment, maar werd gered door een white hat hacker die alleen bekend staat als “c0ffeebabe.eth.”</p>
<p>Wat leidde tot de interventie van c0ffeebabe.eth was de snelle reactie van de Blueberry Protocol Foundation nadat ze de DeFi-exploit hadden opgemerkt. Ze hebben hun klanten snel op de hoogte gebracht van de hack via het X social media platform.</p>
<p>Het team drong er bij de gebruikers op aan om hun holdings zo snel mogelijk op te nemen. Helaas was de frontend van het platform binnen korte tijd niet meer toegankelijk. Desalniettemin slaagde de stichting erin om het protocol na ongeveer 30 minuten te pauzeren, wat voorkwam dat de kwaadwillende actor de cryptocurrencies verder leegde.</p>
<p>In feite waren de uitbuiters erin geslaagd om leeg te pompen <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> (BTC), USDC en <a href="/price/olympus-ohm" rel="nofollow noopener noreferrer" target="_blank">Olympus</a> van geldmarkten. Op dat moment waren alle crypto-activa die zich in het Blueberry Protocol bevonden bedreigd. Naast het team hebben andere oplettende personen en organisaties geholpen om informatie over de bestaande crypto-dreiging te verspreiden.<img src="https://gimg2.gateimg.com/image/article/17096913441.jpeg" alt=""><br>Bron: <a href="https://twitter.com/BlockSecTeam/status/1760876339903558114" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Zoals te zien is op de screenshot, was het BlockSecTeam een van de organisaties die hebben geholpen om de informatie aan andere belanghebbenden door te geven.</p>
<p>Nadat de situatie onder controle was en verdere cryptoverliezen werden voorkomen, verzekerde de Blueberry Protocol Foundation haar gebruikers dat hun bezittingen veilig waren. Plaatsen <a href="https://twitter.com/blueberryFDN/status/1760872935982879030" rel="nofollow noopener noreferrer" target="_blank">op X zei het team</a>, “Alle leeggemaakte fondsen werden voorafgegaan door @coffeebabe_eth en zijn nu veilig in de Blueberry multisig, met uitzondering van de betaling aan de validator.”</p>
<p>Zoals het team heeft erkend, heeft een white hat hacker (@ coffeebabe_eth) het protocol gered van de dreigende cryptoverliezen. De ethische hacker heeft 366 ETH hersteld van een totaal van 457 Ether die de cryptohackers uit het protocol hadden gehaald.</p>
<p>Op dat moment zei het team dat het onderhandelde met de validators om 91 ETH terug te geven. Het <a href="https://twitter.com/blueberryFDN/status/1760876257078899016" rel="nofollow noopener noreferrer" target="_blank">verduidelijkt</a>“Gestorte fondsen zijn momenteel veilig. Slechts drie markten zijn getroffen en het grootste deel is al teruggegeven. Het totale betalingsverlies voor de validator is 91 ETH. We nemen contact op en streven naar volledige terugbetaling aan gebruikers als doel.”</p>
<p>Het is belangrijk om te beseffen dat ten tijde van de cryptografische exploit het Blueberry Protocol <a href="https://www.gate.io/de/blog_detail/1471/the-total-value-locked-tvl-of-the-defi-protocols-exceeds-70-billion &quot;had a total value locked (TVL" rel="nofollow noopener noreferrer" target="_blank">had a totale waarde vergrendeld (TVL)</a> van $4.5 miljoen maar het daalde naar $3.15 miljoen na de mislukte DeFi exploit.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-does-tvl-mean-in-defi/217" target="_blank">Wat betekent TVL in DeFi?</a><img src="https://gimg2.gateimg.com/image/article/17096914992.jpeg" alt=""><br>Blueberry Protocol totale waarde vergrendeld (TVL) - <a href="https://defillama.com/protocol/blueberry-lend" rel="nofollow noopener noreferrer" target="_blank">Defillama</a></p>
<p>Zoals u kunt zien op de foto, daalde de totale waarde die vergrendeld was in het protocol (TVL) van $4,5 miljoen naar $3,15 miljoen kort na de mislukte DeFi-aanval.</p>
<h2 id="h2-White20Hat20Hacker20c0ffeebabeeth20heeft20ook20Curve20Finance20gered20in202023441364"><a name="White Hat Hacker, c0ffeebabe.eth, heeft ook Curve Finance gered in 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>White Hat Hacker, c0ffeebabe.eth, heeft ook Curve Finance gered in 2023</h2><p>De ethische hacker, c0ffeebabe.eth, ook <a href="https://www.gate.io/blog_detail/3081/curve-founder-168m-stash-faces-stress" target="_blank">redde Curve Finance in 2023</a> toen hij/zij cryptocurrencies ter waarde van $5,4 miljoen terugvond die kwaadwillende hackers hadden gestolen.</p>
<p>In feite heeft c0ffeebabe.eth een Ethereum-arbitrage handelsrobot gebruikt om de aanvallers te slim af te zijn en de gestolen crypto-activa te herstellen. De ethische hacker heeft de fondsen aan het team teruggegeven.</p>
<h2 id="h2-DeFi20Verliezen20van202023752701"><a name="DeFi Verliezen van 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeFi Verliezen van 2023</h2><p>Het Blueberry-hackincident geeft aan hoe kwetsbaar DeFi-protocollen zijn voor kwaadwillende crypto-exploitatie. Zo heeft DeFi alleen al in 2023 verliezen geleden van meer dan $1 miljard als gevolg van cyberdiefstal, zoals blijkt uit de volgende grafiek.<br><img src="https://gimg2.gateimg.com/image/article/17096915623.jpeg" alt=""><br>DeFi verliezen voor 2023: <a href="https://twitter.com/intotheblock/status/1736054070492696827/photo/1" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Zoals waargenomen uit het diagram, leed DeFi in 2023 cryptoverliezen ter waarde van ongeveer $1,02 miljard. Dat betekende echter een enorme daling van de verliezen die de sector leed in 2021 en 2022, toen de DeFi-verliezen respectievelijk ongeveer $3,96 miljard en $53 miljard bedroegen.</p>
<h2 id="h2-Waarom20zijn20White20Hat20Hackers20essentieel20voor20de20Crypto20Sector979124"><a name="Waarom zijn White Hat Hackers essentieel voor de Crypto Sector?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom zijn White Hat Hackers essentieel voor de Crypto Sector?</h2><p>Zoals we hebben opgemerkt in de glen van Curve Finance en Blueberry Protocol spelen white hat hackers een grote rol in het voorkomen en dwarsbomen van kwaadaardige crypto-exploits. Ze gebruiken veel methoden om crypto-projecten te helpen de aanvallen te voorkomen.</p>
<p>Ten eerste is het doel van white hat hackers om het crypto-ecosysteem te helpen de beveiligingsen te verbeteren om zo cryptofraude te voorkomen. Met andere woorden, ze voeren white-hat hacking uit, ook wel ethisch hacken of penetratietesten genoemd.</p>
<p>In dergelijke glen machtigen de eigenaars van de digitale projecten de ethische hackers om hun en te testen en manieren voor verbetering voor te stellen. Dit komt doordat crypto hackers profiteren van onbekende zwakke plekken of kwetsbaarheden in de protocollen. In de eerste plaats minimaliseert penetratietesten de kans op systeemstoringen en diefstal.</p>
<p>Hoewel de white hackers vergelijkbare tools en technieken gebruiken als de black hats, hebben ze goede bedoelingen. Zo gebruiken ze kwaadaardige software en DoS of … <a href="https://www.gate.io/bitwiki/detail/152/distributed-denial-of-service-attack--ddos-attack" target="_blank">DDoS-aanvallen</a> met als doel bedreigingen te identificeren <a href="https://www.gate.io/blog_detail/2460/security-measures-at-gateio-protecting-your-digital-assets-in-the-crypto-landscape" target="_blank">en het beschermen van crypto-activa</a>. Een witte hoed kan bijvoorbeeld een crypto-botsaanval gebruiken. In het algemeen hackt hij/zij/zij voor het welzijn van de DeFi-projecten en binnen de grenzen van de wet, aangezien ze bedreigingsverwijderingsagenten zijn.</p>
<h2 id="h2-Conclusie630221"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Een populaire white hat hacker @ coffeebabe_eth heeft op 25 februari een DeFi-exploit verijdeld, waardoor Blueberry Protocol een verlies van $1,3 miljoen kon voorkomen. Dezelfde ethische hacker heeft ook meer dan $5,4 miljoen weten te herstellen nadat enkele cryptohackers Curve Finance hadden misbruikt in 2023. Over het algemeen helpt penetratietesten om zwakke plekken in DeFi-en te identificeren, wat het aantal hackincidenten vermindert.</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 standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 zullen juridische stappen worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>