T3ZlcndlZ2luZ2VuIG5hYXIgYWFubGVpZGluZyB2YW4gZGUgZGllZnN0YWwgdmFuIDEsNDYgbWlsamFyZCBkb2xsYXIgYmlqIEJ5Yml0IG5hIGhldCBFVEgtZGllZnN0YWxpbmNpZGVudA==

2025-02-24, 05:15

<p><img src="https://gimg2.gateimg.com/image/article/17403735231735785827default.jpeg" alt=""><br>In februari 2025 vond er een schokkende gebeurtenis plaats in de wereld van cryptocurrency - <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (ETH) werd het slachtoffer van grootschalige diefstal, waarbij de bekende beurs Bybit maar liefst 14,6 miljard dollar aan ETH-vermogen verloor. Dit was niet alleen het meest opvallende nieuws met als sleutelwoord ‘ETH gestolen’, maar ook een van de grootste cryptocurrency-hackaanvallen aller tijden qua bedrag. Dit artikel zal dieper ingaan op de oorzaken en gevolgen van dit incident, de impact op de markt en hoe gewone gebruikers soortgelijke risico’s kunnen voorkomen om de veiligheid van hun activa te waarborgen.</p>
<h2 id="h2-Het20verloop20van20de20diefstal20van20ETH20hoe20heeft20Bybit2014620miljard20dollar20verloren767708"><a name="Het verloop van de diefstal van ETH: hoe heeft Bybit 14,6 miljard dollar verloren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het verloop van de diefstal van ETH: hoe heeft Bybit 14,6 miljard dollar verloren?</h2><p>Op de avond van 21 februari 2025 waarschuwde de blockchain-detective ZachXBT als eerste dat er abnormale fondsen uit de cold wallet van Bybit werden verplaatst. Vervolgens bevestigde de CEO van Bybit, Ben Zhou, dat hackers door een valse gebruikersinterface en kwaadaardige URL’s de wallet-ondertekenaars hebben verleid om een ‘maskertransactie’ goed te keuren, waardoor met succes de logica van het smart contract werd gemanipuleerd en ongeveer 401.346 ETH (ter waarde van 11,3 miljard dollar) en andere liquiditeitsgesteunde activa (zoals stETH, mETH, totaal ter waarde van 14,6 miljard dollar) naar een onbekend adres werden overgeboekt. Dit incident kreeg al snel de titel ‘de grootste cryptodiefstal in de geschiedenis’.</p>
<p>Na het succes van de hacker verspreidde hij het geld over 53 portefeuilles en waste hij een deel van de activa schoon via mixer (zoals eXch) en cross-chain bridge (ChainFlip), zelfs 5.000 ETH omzette in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (BTC), wat wijst op een hoge mate van technische bekwaamheid en voorbedachtheid. Ondanks de snelle activering van noodmaatregelen en het herstel van het opname systeem door Bybit, leidde het incident nog steeds tot een ‘bankrun’ van meer dan $ 4 miljard, wat een ernstige test van het vertrouwen van de gebruikers veroorzaakte.</p>
<h2 id="h2-Waarom20wordt20ETH20zo20vaak20gestolen20De20redenen20en20lessen20erachter810764"><a name="Waarom wordt ETH zo vaak gestolen? De redenen en lessen erachter" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom wordt ETH zo vaak gestolen? De redenen en lessen erachter</h2><p>Ethereum, as the world’s second largest cryptocurrency, its high market value and wide application make it a “sweet cake” for hackers. This “ETH theft” incident is not accidental, similar cases have been seen in history, such as The DAO attack in 2016. So, why is ETH so easily targeted?</p>
<p><strong>1. Hoge liquiditeit en liquiditeitspositie</strong><br>ETH heeft een enorme handelsvolume op grote beurzen en DeFi-protocollen, nadat hackers snel geld kunnen verkopen of witwassen via gedecentraliseerde platforms, wat extreem moeilijk te traceren is.</p>
<p><strong>2. De complexiteit en kwetsbaarheden van slimme contracten</strong><br>Bij het Bybit-incident hebben hackers gebruikgemaakt van kwetsbaarheden in de front-end interface en handtekeningen omzeild, waardoor ze het multi-signature mechanisme konden omzeilen. Dit toont aan dat zelfs cold wallets niet absoluut veilig zijn en dat de complexiteit van smart contracts kansen biedt voor aanvallen.</p>
<p><strong>3. Risico van centralisatie blootgesteld</strong><br>Hoewel cryptocurrencies decentralisatie benadrukken, blijven gecentraliseerde platforms zoals beurzen nog steeds de kernpunten van vermogensbeheer, met ondenkbare gevolgen als ze worden gehackt.</p>
<h2 id="h2-Impact20van20gestolen20ETH20op20de20markt20schommelingen20en20herstel20gaan20hand20in20hand730277"><a name="Impact van gestolen ETH op de markt: schommelingen en herstel gaan hand in hand" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Impact van gestolen ETH op de markt: schommelingen en herstel gaan hand in hand</h2><p>Na de blootstelling van het evenement, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">ETH prijs</a> Met een daling van meer dan 4% in 24 uur, onder de cruciale ondersteuning van $2.800, heeft de cryptomarkt een totale liquidatie van $570 miljoen gezien. Echter, dankzij Bybit die brugleningen verstrekt (inclusief de steun van 40.000 ETH van Bitget) en hun eigen reserves om de situatie stabiel te houden, is de prijs van ETH in 48 uur gestegen naar $2.830, wat de veerkracht van de markt laat zien.</p>
<p>Bovendien heeft het ‘ETH-diefstal’ incident een heftig debat in de gemeenschap over blockchain-rollback veroorzaakt. Sommige mensen (zoals Samson Mow) pleiten voor het terugdraaien van de Ethereum-chain om fondsen terug te halen, maar kernontwikkelaars wijzen erop dat dit een verwoestende klap zou toebrengen aan de DeFi-ecosysteem en cross-chain bruggen, en uiteindelijk niet is aangenomen. Op korte termijn is het vertrouwen van investeerders geschaad, waardoor de DEX-handelsvolumes met 40% stijgen, wat aangeeft dat gebruikers voorzichtig zijn met gecentraliseerde platforms.</p>
<h2 id="h2-Hoe20kunnen20gewone20gebruikers20zichzelf20beschermen20tegen20diefstal20van20ETH358005"><a name="Hoe kunnen gewone gebruikers zichzelf beschermen tegen diefstal van ETH?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kunnen gewone gebruikers zichzelf beschermen tegen diefstal van ETH?</h2><p>Met het toenemende risico van diefstal van ETH, moeten individuele gebruikers proactieve maatregelen nemen om hun activa te beschermen. Hier zijn enkele praktische suggesties:</p>
<ul>
<li><p>Koude opslag voorrang<br>Bewaar het grootste deel van ETH in een hardware wallet (zoals Ledger of Trezor) om langdurige blootstelling in een warme wallet of op een beurs te vermijden. Zorg ervoor dat de herstelzin offline is opgeslagen en niet gedigitaliseerd wordt opgeslagen.</p>
</li><li><p>Wees op je hoede voor phishing en autorisatie<br>Controleer de handtekeningsinhoud van elke transactie om te voorkomen dat u op onbekende links klikt of onbeperkte autorisatie verleent. Het gebruik van anti-phishing plug-ins (zoals ScamSniffer) kan het risico verder verminderen.</p>
</li><li><p>Risico’s spreiden<br>Verspreid uw activa over meerdere portefeuilles, gebruik kleine bedragen voor dagelijkse transacties en bewaar grote bedragen in koude opslag, zodat zelfs als één portefeuille wordt gehackt, de verliezen beperkt blijven.</p>
</li></ul>
<h2 id="h2-Toekomstperspectief930901"><a name="Toekomstperspectief" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toekomstperspectief</h2><p>De diefstal van 1,46 miljard dollar van Bybit heeft de zwakke punten van de cryptosector op het gebied van veiligheid blootgelegd, vooral op het gebied van multi-signature wallets en gebruikersinterfaces. In de toekomst kan het Ethereum-ecosysteem mogelijk de implementatie van decentrale identiteitsverificatie (DID) en smart contract auditstandaarden versnellen. Tegelijkertijd moeten beurzen hun samenwerking met on-chain analysebedrijven versterken om een efficiënter mechanisme voor het volgen en bevriezen van fondsen op te bouwen.</p>
<p>Voor gewone gebruikers is dit incident met “ETH-diefstal” zowel een wake-up call als een kans. Alleen door het beveiligingsbewustzijn te verbeteren en beveiligingsvaardigheden onder de knie te krijgen, kunt u uw digitale rijkdom beschermen in de schaduw van hackers.</p>
<p>Het ‘ETH-hack’-incident van Bybit in 2025 is ongetwijfeld een mijlpaalg in de geschiedenis van de beveiliging van cryptogeld. Het herinnert ons eraan dat ondanks hoe geavanceerd de technologie ook is, menselijke nalatigheid en systeemkwetsbaarheden mogelijk fatale zwakke punten kunnen worden. Onder de schaduw van de ETH-hack moeten individuele gebruikers en professionals in de sector samenwerken om een veiliger cryptografisch ecosysteem te creëren.</p>
<div class="blog-details-info"><br><div>Auteur: Rooick, Gate.io-onderzoeker<div class="info-tips"><em>Deze tekst vertegenwoordigt alleen de mening van de auteur en vormt geen beleggingsadvies. Beleggen brengt risico's met zich mee, beslissingen moeten zorgvuldig worden genomen.<br></em><div><em></em>De inhoud van dit artikel is origineel, het auteursrecht is eigendom van Gate.io, als u moet herdrukken, vermeld dan de auteur en bron, anders wordt u wettelijk verantwoordelijk gehouden.<br></div><p></p><br></div></div></div>