VGFpd2FuZXNlIENyeXB0by1leGNoYW5nZSBCaXRvUHJvIERvZWx3aXQgdmFuIE5vb3JkLUtvcmVhYW5zZSBIYWNrZXJz

<p><img src="https://gimg2.gateimg.com/image/gatemarketnews2202506271624044471051323.webp" alt="">
</p><p>Op 2 juni 2025 veroorzaakte een korte post van blockchain-onderzoeker ZachXBT op Telegram opschudding in de Crypto Assets-industrie: meerdere hot wallets op de Taiwanese Crypto Assets-uitwisseling BitoPro registreerden verdachte geldstromen, in totaal tot wel 11,5 miljoen USD.</p>
<p>Op dit moment zijn er bijna 3 weken verstreken sinds de daadwerkelijke aanval plaatsvond, en de beurs heeft alleen de diensten opgeschort onder het voorwendsel van “systeemonderhoud”, zonder een woord te vermelden over de hackeraanval.</p>
<h2 id="h2-Tijdlijn20van20gebeurtenissen20van20geheime20aanval20tot20openbare20bekendmaking184630"><a name="Tijdlijn van gebeurtenissen, van geheime aanval tot openbare bekendmaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tijdlijn van gebeurtenissen, van geheime aanval tot openbare bekendmaking</h2><p>De aanval vond plaats tussen 8 en 9 mei 2025. Op dat moment maakte de hacker gebruik van de overgangsperiode voor wallet-systeemupgrades en activamigraties op de beurs om een aanval uit te voeren op zijn oude hot wallet.</p>
<p>Meerdere openbare ketens zijn getroffen: Tron, Ethereum, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> De activa in de hot wallet op de beurs werden geleidelijk overgedragen. Nadat de hacker was geslaagd, handelden ze snel, liquidatie van de fondsen tegen marktprijs via gedecentraliseerde beurzen (DEX) en overgedragen naar de Tornado Cash-mixer, of via <a href="/price/thorchain-rune" rel="nofollow noopener noreferrer" target="_blank">Thorchain</a> Storten naar de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> netwerk via cross-chain in de Wasabi-portemonnee, in een poging het traceerpad van de fondsen af te snijden.</p>
<p>Ondanks dat gebruikers problemen met opnames meldden, kwam de officiële verklaring van BitoPro die de aanval bevestigde op 2 juni, nadat ZachXBT deze openbaar maakte, met de bewering dat “gebruikersactiva intact zijn en het platform voldoende reserves heeft.”</p>
<p>De behandelmethode, die drie weken verborgen was, heeft sterke twijfels binnen de gemeenschap gewekt over de transparantie en crisisbeheersingscapaciteiten.</p>
<h2 id="h2-Analyse20van20Aanvalstechnieken20Een20Klassieke20Sociale20Engineering20Inbraak141730"><a name="Analyse van Aanvalstechnieken: Een Klassieke Sociale Engineering Inbraak" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analyse van Aanvalstechnieken: Een Klassieke Sociale Engineering Inbraak</h2><p>Op 19 juni publiceerde BitoPro een rapport van een derde partij beveiligingsbedrijf dat bevestigde dat de aanvaller de beruchte Noord-Koreaanse hackerorganisatie Lazarus Group was.</p>
<p>Het aanvallingspad toont duidelijk zijn hooggespecialiseerde modus operandi aan:</p>
<ul>
<li>Social engineering phishingaanval: Hackers verbergen communicatie om BitoPro-medewerkers te targeten, en lokken hen om op kwaadaardige links of bestanden te klikken.</li><li>Malware-infiltratie: De met succes geïmplanteerde malware wist de antivirusystemen van de beurs, endpointbescherming en cloudbeveiligingsdetectie te omzeilen.</li><li>Infiltratie Observatie: Hackers loeren lange tijd op de computers van de werknemers van het slachtoffer, waarbij ze de operationele processen observeren, met name gericht op cloud zakelijke medewerkers die de controle over Amazon AWS resourcebeheer hebben.</li><li>Tokenontvoering en omzeiling van MFA: het stelen van AWS-sessietokens en het rechtstreeks omzeilen van mechanismen voor multi-factor authenticatie (MFA).</li><li>Beheer de host van de hot wallet: Maak verbinding met de C2-server van de aanvaller, injecteer kwaadaardige instructies in de host die verantwoordelijk is voor hot wallet-transacties, en simuleer uiteindelijk legitieme transacties om de overdracht om 1 uur ‘s nachts op 9 mei uit te voeren.</li></ul>
<p>Deze methode is zeer consistent met de eerdere aanvallen van Lazarus op het wereldwijde bancaire SWIFT-systeem en verschillende beurzen, wat de volwassenheid van zijn aanvalssjabloon benadrukt.</p>
<h2 id="h2-De20Verborgen20Hand20De20Schaduw20van20de20Lazarus20Groep571954"><a name="De Verborgen Hand: De Schaduw van de Lazarus Groep" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Verborgen Hand: De Schaduw van de Lazarus Groep</h2><p>De Lazarus Groep is geen eerste overtreding. De organisatie wordt algemeen beschouwd als een netwerk criminelen ondersteund door het Noord-Koreaanse regime, dat al lange tijd gericht is op het stelen van crypto-activa om zijn wapenprogramma’s te financieren.</p>
<p>Zijn strafblad is schokkend:</p>
<ul>
<li>In 2016 probeerde men 1 miljard dollar van de centrale bank van Bangladesh te stelen door gebruik te maken van een kwetsbaarheid in het SWIFT-systeem (uiteindelijk werden er 81 miljoen dollar succesvol overgemaakt)</li><li>In februari 2025 werd de beurs ByBit aangevallen, wat resulteerde in een recorddiefstal van 1,5 miljard dollar aan crypto-activa.</li><li>Voortdurend gericht op wereldwijde aanvallen op de supply chain van crypto-activa-uitwisselingen, kwetsbaarheidsuitbuitingen en complexe sociale-engineeringfraude.</li></ul>
<p>Beveiligingsexperts wijzen erop dat de organisatie uitblinkt in het combineren van technische kwetsbaarheden met menselijke zwakheden, en het BitoPro-incident bevestigt dit opnieuw.</p>
<h2 id="h2-De20reactie20van20de20beurs20maatregelen20om20de20schade20te20herstellen20nadat20de20schapen20verloren20zijn20gegaan370665"><a name="De reactie van de beurs, maatregelen om de schade te herstellen nadat de schapen verloren zijn gegaan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De reactie van de beurs, maatregelen om de schade te herstellen nadat de schapen verloren zijn gegaan</h2><p>Na de onthulling van het incident nam BitoPro een reeks crisisresponsmaatregelen:</p>
<ul>
<li>Zet het hot wallet-systeem onmiddellijk uit om het aanvalspad af te snijden.</li><li>Vervang alle relevante versleutelsleutels</li><li>Isolateer geïnfecteerde systemen en voer milieuherschepping uit</li><li>Schakel een derde partij blockchain beveiligingsbedrijf in om de gestolen fondsen te traceren.</li></ul>
<p>Om het vertrouwen te herwinnen, heeft BitoPro proactief een nieuw hot wallet-adres ingediend bij het on-chain data-analyseplatform Arkham op 19 mei, waarbij de liquiditeitsgegevens voor openbare controle zijn bijgewerkt.</p>
<p>De oprichter van het bedrijf, Zheng Guangtai, benadrukte dat “klantactiva niet verloren zullen gaan; eventuele verliezen zullen door het platform worden gedragen,” en beloofde de processen voor portefeuillebeheer en de niveaus van monitoring te verbeteren. De Financiële Toezichthoudende Commissie van Taiwan heeft ook ingegrepen en geëist dat het bedrijf de cyberbeveiliging versterkt en een uitleg over het incident indient.</p>
<h2 id="h2-Beveiligingsinzicht20De20meest20kwetsbare20schakel20blijft20menselijk746395"><a name="Beveiligingsinzicht: De meest kwetsbare schakel blijft “menselijk”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Beveiligingsinzicht: De meest kwetsbare schakel blijft “menselijk”</h2><p>Het BitoPro-incident, hoewel het verloren bedrag veel minder is dan de enorme diefstal van $1,5 miljard van ByBit, onthult kwetsbaarheden in de industrie die universeel zijn:</p>
<ul>
<li>Onderhoudsperioden worden risicovolle vensters: tijdens systeemupgrades of activa-migraties kunnen risicobeheersmechanismen tijdelijke blinde vlekken hebben.</li><li>Technische verdedigingen zijn moeilijk te weerstaan tegen social engineering-inbreuken: zelfs de meest geavanceerde firewalls en MFA-mechanismen kunnen volledig worden gecompromitteerd door een werknemer die op een kwaadaardige <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> klikt.</li><li>De crisis van transparantie verergert de instorting van vertrouwen: vertraagde openbaarmaking en vage communicatie schaden vaak het vertrouwen van gebruikers meer dan de gebeurtenissen zelf.</li></ul>
<p>“De zwakste <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">link</a> in elk beveiligingssysteem is altijd de menselijke factor,” een conclusie die herhaaldelijk is bevestigd in beveiligingsrapporten.</p>
<h2 id="h2-Conclusie20De20Evolutie20van20Verdediging20en20de20Eindeloze20Aanval20en20Verdedigingsstrijd579438"><a name="Conclusie: De Evolutie van Verdediging en de Eindeloze Aanval en Verdedigingsstrijd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie: De Evolutie van Verdediging en de Eindeloze Aanval en Verdedigingsstrijd</h2><p>De aanval van de Lazarus-groep is een systematische bedreiging waarmee het wereldwijde ecosysteem van crypto-activa blijft worden geconfronteerd. Van de centrale bank van Bangladesh, ByBit tot BitoPro, hun aanvallingsmethoden evolueren voortdurend, maar de kern blijft onveranderd: het uitbuiten van menselijke zwakheden om technische barrières te doorbreken.</p>
<p>BitoPro heeft een verlies van 11,5 miljoen USD geleden en zijn systeem geüpgraded, maar de grotere uitdaging is: hoe de beurs een interne controlecultuur kan vestigen die “anti-social engineering” is en een snelle en transparante reactie kan bereiken wanneer zij wordt geconfronteerd met een inbraak.</p>
<p>In de wereld van blockchain is vertrouwen de onderliggende valuta, en elk hackingincident test of de werkelijke reserves voldoende zijn.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Blogteam</strong><br><div class="info-tips"><em>De inhoud hierin vormt geen aanbod, sollicitatie of aanbeveling. U moet altijd onafhankelijk professioneel advies inwinnen voordat u investeringsbeslissingen neemt.<br><div></div>Houd er rekening mee dat Gate het gebruik van alle of een deel van de Diensten vanuit Beperkte Locaties kan beperken of verbieden. Voor meer informatie, lees de Gebruikersovereenkomst via <a href="https://www.gate.com/legal/user-agreement" data-index="6">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>