UG9ydGVtb25uZWUgdmFuIG1lZGVvcHJpY2h0ZXIgdmFuIEF4aWUgSW5maW5pdHkgZ2VoYWNrdCwgdmVybGllemVuIG5hZGVyZW4gJDEwIG1pbGpvZW4=

2024-03-06, 06:10

<p><img src="https://gimg2.gateimg.com/image/article/1709705993sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR291008"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Op 23 februari Jeff Zirlin, <a href="/price/axie-infinity-axs" rel="nofollow noopener noreferrer" target="_blank">Axie Infinity</a> medeoprichter, verloor ETH ter waarde van ongeveer $10 miljoen bij een crypto-roof.</p>
<p>In 2022 verloor de Ronin-brug cryptomiddelen ter waarde van $622 miljoen door hacking.</p>
<p>Marktanalisten hebben belanghebbenden aangemoedigd om samen te werken om crypto-overvallen te voorkomen.</p>
<p><strong>Trefwoorden</strong>: crypto verliezen, crypto heist, crypto hacks, crypto hackers, crypto portefeuilles, eth verliezen, gehackte portefeuille, Ronin portefeuille, crypto investeringen, crypto redden</p>
<h2 id="h2-Introductie332619"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Naarmate de prominentie van cryptocurrencies toeneemt, nemen ook cybercriminele activiteiten gericht op digitale activa toe. Alleen al in 2023 hebben kwaadwillende actoren meer dan $1 miljard gestolen, een cijfer dat het gevaar van hacking en andere gerelateerde cybercriminele activiteiten laat zien.</p>
<p>Helaas richten slechte hoeden hackers zich op andere persoonlijke en institutionele digitale portefeuilles. Het doel van dit artikel is om te onderzoeken hoe hackers de twee portefeuilles van Jeff Zirlin, mede-oprichter van Axie Infinity, hebben aanglen.</p>
<h2 id="h2-Jeff20Zirlin20verliest209720miljoen20aan20Ethereum20ETH20aan20hackers84634"><a name="Jeff Zirlin verliest $9,7 miljoen aan Ethereum (ETH) aan hackers" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Jeff Zirlin verliest $9,7 miljoen aan <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (ETH) aan hackers</h2><p>Op 23 februari werden de twee digitale portefeuilles van Jeff Zirlin, mede-oprichter van Axie Infinity, gehackt, wat resulteerde in een totaal verlies van 3.248 ETH, ter waarde van ongeveer $9,5 miljoen op het moment van de aanval.</p>
<p>Op 23 februari waarschuwde PeckShield, een blockchain onderzoeker, het publiek voor een gehackte portemonnee van een walvis. De hack heeft dit jaar het gestolen bedrag aan digitale activa verhoogd.<br><img src="https://gimg2.gateimg.com/image/article/170970494411.jpeg" alt=""><br>Bron: <a href="https://twitter.com/PeckShield/status/1760843091916042439" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Zirlin heeft de hack bevestigd en voegde eraan toe dat de digitale activa naar Tornado Cash zijn gestuurd, een cryptomixer. Als cryptomixer verduistert Tornado Cash transacties om hun anonimiteit voor het publiek te vergroten.</p>
<p>Zirlin <a href="https://twitter.com/Jihoz_Axie/status/1760845078757511562" rel="nofollow noopener noreferrer" target="_blank">zei op X</a> Dit is een zware ochtend voor mij geweest. Twee van mijn adressen zijn gecompromitteerd. De aanval is beperkt tot mijn persoonlijke accounts en heeft niets te maken met de validatie of operaties van de Ronin blockchain.</p>
<p>Zirlin verzekerde ook de Ronin-gebruikers dat hun digitale portefeuilles veilig waren. ‘Daarnaast hebben de gelekte sleutels niets te maken met de activiteiten van Sky Mavis. Ik wil iedereen verzekeren dat we strenge beveiligingsmaatregelen hebben voor alle ketengerelateerde activiteiten,’ voegde hij eraan toe.</p>
<p>Ondanks de hack-terugslag blijft Zirlin positief en veerkrachtig in zijn omgang met crypto-activa. Hij zei: “Ik zal blijven doorgaan met elk van jullie op deze magische reis. De missie: economische vrijheid brengen aan alle gebruikers van het internet, te beginnen bij gamers.”</p>
<p>Ook kort na het nieuws van de crypto-overval verzekerde mede-oprichter van Ronin, Aleksander Larsen, de gebruikers dat de brug een hoge beveiliging heeft en niet is geschonden.</p>
<p>Hij <a href="https://twitter.com/Psycheout86/status/1760837760179380279" rel="nofollow noopener noreferrer" target="_blank">opgehelderd over X</a>“De brug heeft geen probleem en Ronin is niet aangetast… Een portemonnee is duidelijk aangetast, zoals op elk netwerk gebeurt, en de fondsen worden omgezet in Tornado cash. De brug zelf heeft topbeveiliging, is door vele audits gegaan en wordt gepauzeerd wanneer er te veel wordt opgenomen.”</p>
<p>Zirlin erkende dat de oorzaak van de exploit een lek van zijn privésleutels was en niet een compromis van het Ronin-protocol. Zoals eerder opgemerkt, <a href="https://twitter.com/Psycheout86/status/1760837760179380279" rel="nofollow noopener noreferrer" target="_blank">PackShield ook bevestigd</a> dat de ETH-verliezen het gevolg waren van een compromis van de portemonnee.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-are-blockchain-bridges-and-how-do-they-work/146" target="_blank">Wat zijn blockchainbruggen en hoe werken ze?</a></p>
<h2 id="h2-De20Roningebruikers20hebben20nog20steeds20de20herinneringen20aan20de20hack20van202022521885"><a name="De Ronin-gebruikers hebben nog steeds de herinneringen aan de hack van 2022" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Ronin-gebruikers hebben nog steeds de herinneringen aan de hack van 2022</h2><p>Na de recente hack van de Ronin-portemonnee waren de gebruikers van het netwerk bezorgd, gezien het feit dat de brug in 2022 ook werd misbruikt, wat leidde tot cryptoverliezen van meer dan $622 miljoen.</p>
<p>Analisten wezen de hack toe aan de Noord-Korea-affiliated Lazarus Group die misbruik maakte van de kwetsbaarheid van het protocol. Ook hebben ze de protocollen opgeroepen om hun beveiliging te verhogen om crypto te redden.</p>
<p>Het gamingplatform slaagde erin slechts $30 miljoen aan cryptocurrencies te herstellen. Het slaagde er echter in om alle gestolen crypto-activa van zijn gebruikers terug te betalen. 2024 is niet immuun geweest voor crypto-overvallen.</p>
<p>Dit jaar hebben al verschillende crypto-hackings plaatsgevonden. Zo is het gestolen bedrag aan crypto-activa in januari en februari, vergeleken met 2023, respectievelijk met 713% en 710% gestegen.</p>
<p>Als gevolg hiervan bekritiseerde Philip Hoey, de directeur van CoinJournal, de stijging van crypto-verliezen in de eerste twee maanden van het jaar. Volgens Alexablockchain. <a href="https://alexablockchain.com/is-2024-the-year-of-crypto-heists/" rel="nofollow noopener noreferrer" target="_blank">publicatie</a>, Hoey zei: “<br><strong>De gegevens spellen een verontrustende trend voor de cryptocurrency-industrie. Dit benadrukt niet alleen de noodzaak van verhoogde beveiligingsmaatregelen, maar roept ook op tot internationale samenwerking om dit probleem aan te pakken.</strong>.”</p>
<p>Hij vervolgde: ‘Naarmate we de evolutie van digitale financiën waarnemen, is het van cruciaal belang dat we ook onze strategieën evolueren om het te beschermen. Dit omvat het verbeteren van beveiligingsmaatregelen, het bevorderen van gebruikerseducatie en het bevorderen van internationale samenwerking om effectiever te ontmoedigen en te reageren op crypto-criminaliteit.’</p>
<p>Naarmate het aantal crypto hacks toeneemt, is er behoefte aan proactieve maatregelen om crypto-investeringen te beschermen als de markt de adoptiegraad van cryptocurrencies wil verhogen. Dit vereist echter gezamenlijke inspanningen van verschillende belanghebbenden, zoals regelgevers, wetshandhavingsinstanties en de crypto-industrie.</p>
<h2 id="h2-Conclusie376298"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Hackers hebben misbruik gemaakt van de twee cryptowallets van Jeff Zirlin en hebben 3.248 ETH gestolen, ter waarde van ongeveer $9,5 miljoen. Mede-oprichter van Axie Infinity, Jeff Zirlin, wijt het cryptofraude aan gelekte privésleutels.</p>
<p>De <a href="https://www.gate.io/blog_detail/796/axie-infinity-and-its-mission-to-be-decentralized" target="_blank">Axie Infinity</a> de oprichters verzekerden de gebruikers dat <a href="https://www.gate.io/learn/articles/what-is-the-ronin-network/492" target="_blank">de Ronin Bridge</a> is veilig omdat het hoge beveiligingsmaatregelen heeft en voortdurend wordt gecontroleerd. Ondertussen hebben analisten aangedrongen op belanghebbenden om hun inspanningen en middelen te coördineren om de stijging van crypto cyberdiefstallen te voorkomen.</p>
<h2 id="h2-Veelgestelde20vragen20over20Crypto20Hacking346639"><a name="Veelgestelde vragen over Crypto Hacking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Crypto Hacking</h2><h3 id="h3-Zullen20crypto20hacks20toenemen20in202024384707"><a name="Zullen crypto hacks toenemen in 2024?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zullen crypto hacks toenemen in 2024?</h3><p>Op basis van eerdere trends is het waarschijnlijk dat het aantal crypto hackings zal afnemen in 2024. Dit komt doordat het aantal crypto hacks in 2023 is afgenomen in vergelijking met 2021 en 2022. Het hoogste aantal crypto-overvallen vond plaats in 2022.</p>
<h3 id="h3-De20grootste20cryptoroof20in202023148572"><a name="De grootste crypto-roof in 2023?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De grootste crypto-roof in 2023?</h3><p>De hack van Mixin Network die plaatsvond in september, waarbij aanvallers ongeveer $200 miljoen stalen, was waarschijnlijk de grootste crypto roof in 2023. De andere aanvallen betroffen Multichain, dat ongeveer $126 miljoen verloor, Poloniex ($126 miljoen), Atomic Wallet ($100 miljoen), Heco Chain ($87 miljoen), Curve Finance ($62 miljoen) en <a href="/price/coinex-cet" rel="nofollow noopener noreferrer" target="_blank">CoinEx</a>($55 miljoen).<br>Lees ook: <a href="https://www.gate.io/blog_detail/2158/the-biggest-crypto-heist-in-history" target="_blank">De grootste cryptoroof in de geschiedenis</a></p>
<h3 id="h3-Waar20crypto20veilig20bewaren948745"><a name="Waar crypto veilig bewaren?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waar crypto veilig bewaren?</h3><p>De beste plek om cryptocurrency veilig te bewaren zijn harde portefeuilles en veilige crypto-beurzen. Gate.io is een van de crypto-beurzen die een hoge beveiliging heeft waar mensen hun cryptocurrencies kunnen bewaren.</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 beleggingsaanbevelingen.<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>