RWVuIHNuZWxsZSBjcnlwdG8tb3ZlcnZhbDogaG9lIHR3ZWUgYnJvZXJzIG5hYXIgdmVybHVpZHQgJDI1IG1pbGpvZW4gaGViYmVuIGdlc3RvbGVu

2024-05-29, 06:03

<p><img src="https://gimg2.gateimg.com/image/article/1716962408rdzz.jpeg" alt=""></p>
<h2 id="h2-TL20DR916951"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>James Peraire-Bueno en Anton Peraire-Bueno hebben een kwetsbaarheid in het Ethereum-netwerk misbruikt en hebben crypto-activa ter waarde van ongeveer $25 miljoen gestolen.</p>
<p>De broers Peraire-Bueno gebruikten de kennis die ze hadden opgedaan aan het Massachusetts Institute of Technology (MIT) om cryptocurrencies te stelen.</p>
<p>Belangrijke belanghebbenden in de blockchainsector moeten samenwerken wanneer crypto-zwendel plaatsvindt om de kans op het herstellen van gestolen activa te vergroten.</p>
<h2 id="h2-Introductie137700"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Bij veel glen van crypto-overvallen zijn specialisten uit gerelateerde vakgebieden op de een of andere manier betrokken. De Ethereum-crypto-overval van 2023, waarbij cryptocurrencies ter waarde van ongeveer $ 25 miljoen werden gestolen, is een typisch voorbeeld van hoe intelligent de daders waren. Dit artikel onderzoekt hoe twee broers, die studeerden aan een van de meest gerenommeerde onderwijsinstellingen, een succesvolle blockchain-beveiligingsinbreuk hebben georkestreerd.</p>
<h2 id="h2-Het20uitpakken20van20de202520miljoen20cryptocurrency20diefstal163762"><a name="Het uitpakken van de $25 miljoen cryptocurrency diefstal" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het uitpakken van de $25 miljoen cryptocurrency diefstal</h2><p>Het Amerikaanse ministerie van Justitie (DOJ) heeft onlangs twee broers, James Peraire-Bueno, 28, en Anton Peraire-Bueno, 24, aangeklaagd voor verschillende aanklachten, waaronder samenzwering tot het witwassen van cryptocurrency, wirefraude en samenzwering tot het plegen van wirefraude. Volgens de aanklagers hebben de twee broers die aan het Massachusetts Institute of Technology (MIT) hebben gestudeerd, crypto-activa ter waarde van ongeveer $25 miljoen gestolen van het Ethereum-netwerk.</p>
<p>De twee broers die informatica en wiskunde studeerden, werden op 15 mei gearresteerd nadat agenten van de Amerikaanse Internal Revenue Service (IRS) hen in verband brachten met de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> transactie-exploitatie.</p>
<p>Zoals vermeld in een recent persbericht van de overheid, <a href="https://www.justice.gov/opa/pr/two-brothers-arrested-attacking-ethereum-blockchain-and-stealing-25m-cryptocurrency" rel="nofollow noopener noreferrer" target="_blank">De adjunct-officier van justitie Lisa Monaco zei</a> Zoals beweerd in de aanklacht van vandaag, hebben de broers Peraire-Bueno $25 miljoen aan Ethereum-cryptocurrency gestolen via een technologisch geavanceerd, baanbrekend plan dat ze maandenlang hebben beraamd en binnen seconden hebben uitgevoerd.</p>
<p>Hij/zij ging verder: ‘Helaas voor de verdachten waren hun vermeende misdaden geen partij voor de aanklagers van het Ministerie van Justitie en de IRS-agenten, die dit voor het eerst voorkomende wirefraude- en witwasregeling ontrafelden. Terwijl de cryptocurrency-markten blijven evolueren, zal het Ministerie doorgaan met het uitroeien van fraude, slachtoffers ondersteunen en het vertrouwen in deze markten herstellen.’<br>Lees ook: <a href="https://www.gate.io/blog_detail/2158/biggest-crypto-heist-history" target="_blank">De grootste cryptodiefstal in de geschiedenis</a></p>
<p>De technologische verfijning achter de Ethereum-heist<br>De manier waarop de twee broers Peraire-Bueno hun plan voor Ethereum-diefstal uitvoerden, toonde aan dat ze hun aanvalsstrategie hadden gerepeteerd en beheersten, aangezien het exploitatieproces slechts 12 seconden duurde om $25 miljoen aan crypto-activa te stelen. Primair gebruikten ze hun kennis van wiskunde, wetenschap en cryptocurrency om hun plan uit te voeren.</p>
<p>De twee broers mikten op Ethereum’s <a href="https://www.gate.io/learn/articles/what-is-mev/104 &quot;maximal extractable value (MEV" rel="nofollow noopener noreferrer" target="_blank">maximale te halen waarde (MEV)</a>”) software die de meeste Ethereum-handelaren gebruiken om hun transacties te optimaliseren. Gelukkig voor hen en helaas voor de investeerders konden ze een kwetsbaarheid in de blockchain-technologie exploiteren in de MEV-boost, een stuk software dat de validators gebruiken om de blockchain te draaien.</p>
<p>Aangezien ze verschillende kwaadwillende validators hadden opgezet, konden ze de bots misbruiken die niet genoeg controles hadden om bepaalde omstandigheden te voorkomen. Zo konden de kwaadaardige validatorbots beveiligde en ondertekende transacties benaderen, waardoor ze de digitale activa konden wegsluizen.</p>
<p>In dit verband een speciaal agent in charge Thomas Fattorusso van de IRS Criminal Investigation (IRS-CI) New York Field Office <a href="https://www.justice.gov/opa/pr/two-brothers-arrested-attacking-ethereum-blockchain-and-stealing-25m-cryptocurrency" rel="nofollow noopener noreferrer" target="_blank">zei</a> Deze broers zouden zich schuldig hebben gemaakt aan een unieke manipulatie van de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain door frauduleuze toegang te verkrijgen tot hangende transacties, de beweging van de elektronische valuta te veranderen en uiteindelijk $25 miljoen aan cryptocurrency van hun slachtoffers te stelen.</p>
<p>Volgens de <a href="https://www.justice.gov/opa/media/1351996/dl" rel="nofollow noopener noreferrer" target="_blank">aanklacht tegen de twee broers werd gemanipuleerd</a> met de “gevestigde MEV-Boost-voorstellen, waarop de overgrote meerderheid van Ethereum-gebruikers vertrouwt” die “de stabiliteit en integriteit van de Ethereum-blockchain voor alle netwerkdeelnemers bedreigen.”</p>
<p>De rechtbank beschuldigde de twee broers er ook van een ‘valse handtekening’ naar een ‘relais’ te hebben gestuurd, dat vervolgens de digitale activa vrijgaf. De aanklacht voegde eraan toe: ‘Het relais zal de transacties binnen het voorgestelde blok niet vrijgeven aan de validator totdat de validator via een digitale handtekening heeft bevestigd dat hij het voorgestelde blok zoals gestructureerd door de bouwer op de blockchain zal publiceren.’</p>
<p>Recent nieuws: <a href="https://www.gate.io/de/blog_detail/3880/axie-infinity-co-founder-s-wallet-hacked-losses-approach-10-million" target="_blank">Portemonnee van mede-oprichter Axie Infinity gehackt</a></p>
<p>De aanklagers beweerden dat de beklaagde ‘wist dat de informatie die in de valse handtekening stond ontworpen was om de Relay te misleiden en de volledige inhoud van het voorgestelde blok vroegtijdig vrij te geven aan de verdedigers, inclusief de privétransactie-informatie’. Sommige analisten beweren echter dat het Ethereum-netwerk meestal vatbaar is voor twijfelachtige MEV-handelspraktijken, wat soms leidt tot twijfel over de blockchain-integriteit en cryptocurrency-beveiliging.</p>
<h2 id="h2-De20Ethereum20Cryptodiefstal20Een20voorbedachte20zet736643"><a name="De Ethereum Crypto-diefstal: Een voorbedachte zet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Ethereum Crypto-diefstal: Een voorbedachte zet</h2><p>De gemak waarmee de twee broers Peraire-Bueno hun crypto fraudestrategie succesvol uitvoerden, laat zien dat ze de aanval al lange tijd gepland hadden. Volgens de aanklacht hebben ze zelfs meer dan zeven maanden besteed aan het plannen van hoe ze cryptocurrencies uit het Ethereum-netwerk konden wegsluizen. Bijvoorbeeld, het IRS-onderzoek toonde aan dat ze veel tijd namen om het gedrag van verschillende handelaren te bestuderen.</p>
<p>Ze planden ook hoe ze hun identiteiten konden verhullen. Als voorbeeld hebben ze verschillende schijnbedrijven geregistreerd en verschillende cryptocurrency wallet-adressen in bezit bij lokale en buitenlandse crypto-uitwisselingen. Als de twee broers schuldig worden bevonden, kunnen ze elk tot 25 jaar gevangenisstraf krijgen.</p>
<h2 id="h2-De20toekomst20van20cryptobeveiliging20lessen20van20de202520miljoen20overval459234"><a name="De toekomst van crypto-beveiliging: lessen van de $25 miljoen overval" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De toekomst van crypto-beveiliging: lessen van de $25 miljoen overval</h2><p>De cryptosector heeft veel te leren van de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum crypto</a> Diefstal. Allereerst moeten cryptoplatforms hun cryptocurrency-beveiliging verbeteren. Het uitgangspunt is dat blockchain-gebaseerde protocollen regelmatig audits moeten uitvoeren, vooral nadat ze nieuwe upgrades hebben gelanceerd of nieuwe DeFi-toepassingen hebben geïntroduceerd.</p>
<p>Bovendien is er behoefte aan relevante cryptocurrency-regelgeving die kan helpen om vergelijkbare incidenten te voorkomen. Als voorbeeld is het essentieel dat verschillende DeFi-protocollen en crypto-uitwisselingen voldoen aan <a href="https://www.gate.io/learn/articles/what-is-anti-money-laundering/81 &quot;anti-money laundering (AML" rel="nofollow noopener noreferrer" target="_blank">antiwitwaspraktijken (AML)</a>” ) en <a href="https://www.gate.io/learn/articles/what-is-kyc-2/103 &quot;know-your-customer (KYC" rel="nofollow noopener noreferrer" target="_blank">ken-uw-klant (KYC) regelgeving</a> regelgeving”).</p>
<p>Ten derde is er behoefte aan samenwerking tussen belanghebbenden om cryptoroof, het witwassen van cryptovaluta te voorkomen en gestolen digitale activa te herstellen. Ook zouden wetshandhavingsautoriteiten, cryptobeurzen en DeFi-platforms hun inspanningen moeten coördineren wanneer er sprake is van cryptozwendel of diefstal.</p>
<p>Tot slot vestigt dit incident de aandacht op de noodzaak van educatie en bewustwording onder cryptocurrency gebruikers. Verschillende belanghebbenden in de sector, waaronder gebruikers, leiders van crypto projecten en regelgevers, zouden bijvoorbeeld bekend moeten zijn met de huidige ontwikkelingen op het gebied van cryptocurrency-beveiliging. In dit opzicht zouden ze de risico’s die in de digitale sector veelvoorkomend zijn moeten volgen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1008/15-biggest-crypto-hacks-and-heists" target="_blank">De grootste crypto hacks en diefstallen in de geschiedenis</a></p>
<h2 id="h2-Conclusie316163"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>In 2023 hebben twee broers, James Peraire-Bueno en Anton Peraire-Bueno, die zijn afgestudeerd aan het Massachusetts Institute of Technology (MIT), cryptocurrencies ter waarde van ongeveer $25 miljoen gestolen van het Ethereum-netwerk. Om dat te bereiken hebben ze de software voor de maximale te extraheren waarde (MEV) van Ethereum gemanipuleerd. Als ze veroordeeld worden, kunnen ze tot 25 jaar gevangenisstraf krijgen.</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 opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>