TWVlciBkYW4gJDM2IG1pbGpvZW4gZ2VzdG9sZW4gZ2VsZCBpcyB0ZXJ1Z2dlZ2V2ZW4gYWFuIGhldCBoZXJzdGVsYWRyZXMgdmFuIGhldCBmb25kcyB2YW4gTm9tYWQgQnJpZGdlLg==

2022-08-22, 05:44

<p><img src="https://gimg2.gateimg.com/image/article/1688624260a.jpeg" alt=""></p>
<h2 id="h2-TL20DR402735"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Tijdens de hack werden veel stablecoins gestolen van de brug, waaronder USDT, USDC, en <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a>, en sommige van de transacties werden uitgevoerd door white hat hackers die later beloofden om de gestolen fondsen terug te betalen.</p>
<p>Als onderdeel van zijn voortdurende poging om de $190 miljoen die verloren is gegaan bij de brugexploitatie terug te krijgen, bood Nomad een beloning van 10% aan voor hackers die de activa teruggeven.</p>
<p>Meer dan USD 36 miljoen is teruggestort naar het hersteladres van Nomad Bridge’s fonds.</p>
<p>Volgens Nomad voorkwam een bug dat het replica-contract berichten correct authenticeerde. Als gevolg hiervan hadden contracten die afhankelijk waren van de replica voor het authentiseren van inkomende berichten beveiligingsproblemen. Het Nomad-bridge-routercontract ontving frauduleuze transacties als gevolg van het authenticatiefout.</p>
<p>Een paar maanden geleden heeft Quantstamp het code van het Nomad protocol onderzocht en geauditeerd, en de kwetsbaarheid voor hacking werd ontdekt. Maar het rapport classificeerde de kwetsbaarheid als laag risico.</p>
<p><a href="http://https://app.nomad.xyz/" rel="nofollow noopener noreferrer" target="_blank">Nomad Bridge</a>, een cross-chain protocol, had vorige week voor $ 190 miljoen aan activa gestolen in wat velen ‘de eerste gedecentraliseerde diefstal’ noemden. Vóór de ‘chaotische’ exploit had de brug 190 miljoen dollar aan Total Value Locked (TVL); Meer dan de helft van het geld ging echter binnen een paar uur verloren tijdens de cross-chain aanval.</p>
<p>In een opmerking, het Nomad team <a href="http://https://medium.com/nomad-xyz-blog/nomad-bridge-hack-root-cause-analysis-875ad2e5aacd" rel="nofollow noopener noreferrer" target="_blank">Beschreven</a> de aanval als een ‘gedecentraliseerde beroving’ beschouwen, waarbij wordt beweerd dat er een bug was die ervoor zorgde dat het Replica-contract berichten niet correct kon verifiëren. Als gevolg hiervan kon iedereen deelnemen aan de aanval door de eerste hacktransactie te kopiëren en te plakken.</p>
<p>Tijdens de inbreuk, vele stablecoins, <a href="http://https://defi-planet.com/2022/08/more-than-36-million-returned-to-nomad-bridges-fund-recovery-address/" rel="nofollow noopener noreferrer" target="_blank">inclusief</a> USDT, USDC en <a href="/price/frax-frax" target="_blank" class="blog_inner_link">Frax</a> zijn van de brug verwijderd, waarna het Nomad-team <a href="http://https://twitter.com/nomadxyz_/status/1554679735006859264?t=S1zGtHOY8DeAtGEablE5PQ&amp;s=19" rel="nofollow noopener noreferrer" target="_blank">aangedrongen</a> white hat hackers om het geld terug te storten naar een aangewezen adres.</p>
<p>(geparafraseerd) Beste white hat hackers en ethische onderzoeksvrienden die ETH/ERC-20 tokens hebben beschermd,</p>
<p>Gelieve de fondsen over te maken naar het volgende portefeuilleadres op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>: 0x94A84433101A10aEda762968f6995c574D1bF154”.</p>
<h2 id="h2-Meer20dan203620miljoen20is20teruggestuurd20naar20het20herstelportemonnee20van20Nomad799422"><a name="Meer dan $36 miljoen is teruggestuurd naar het herstelportemonnee van Nomad." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Meer dan $36 miljoen is teruggestuurd naar het herstelportemonnee van Nomad.</h2><p><a href="http://https://cryptonews.com/news/over-usd-36m-returned-nomad-bridges-fund-recovery-address.htm" rel="nofollow noopener noreferrer" target="_blank">Vanaf 5 augustus</a> Peckshield meldde dat Whitehat-hackers ongeveer $22 miljoen hebben teruggegeven <a href="http://https://cryptoslate.com/nomad-bridge-drained-of-190m-after-hundreds-of-addresses-copy-hackers-code/" rel="nofollow noopener noreferrer" target="_blank">gestolen $190 miljoen</a> van Nomad Bridge. Volgens het blockchain-beveiligingsbedrijf wordt het erkende6 bedrag geschat op 4,8% van het totale verlies dat de brug heeft geleden. Ongeveer 11,6% van het opgenomen geld is teruggehaald, terwijl 50% sinds de inbreuk stabiel is gebleven.</p>
<p>Ondertussen, de huidige ( <a href="http://https://twitter.com/nomadxyz_/status/1556681397993058304?s=20&amp;t=lQAZyDunyiuLiw66mj1gIw" rel="nofollow noopener noreferrer" target="_blank">op 8 augustus</a>)Transactierecords op Etherscan tonen aan dat de herstelportemonnee cryptoholdings heeft ter waarde van $36,4 miljoen. Tot nu toe, <a href="http://https://cryptonews.com/news/over-usd-36m-returned-nomad-bridges-fund-recovery-address.htm" rel="nofollow noopener noreferrer" target="_blank">meer dan 36 miljoen USD</a> is terugbetaald naar het officiële fonds hersteladres dat is verstrekt door Nomad Bridge.<br><img src="https://gimg2.gateimg.com/image/article/1688624646b.jpeg" alt=""><br>source: <a href="http://https://twitter.com/nomadxyz_/status/1556681397993058304?s=20&amp;t=lQAZyDunyiuLiw66mj1gIw" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></p>
<h2 id="h2-Whitehat20Hackers20kregen201020Bounty20aangeboden617013"><a name="White-hat Hackers kregen 10% Bounty aangeboden." class="reference-link"></a><span class="header-link octicon octicon-link"></span>White-hat Hackers kregen 10% Bounty aangeboden.</h2><p>De officiële portemonnee voor fondsherstel was <a href="http://https://twitter.com/nomadxyz_/status/1554679735006859264" rel="nofollow noopener noreferrer" target="_blank">uitgegeven</a> door Nomad op 3 augustus, en het team maakte duidelijk dat iedereen die ten minste 90% van de gestolen fondsen terugbracht, zou worden beschouwd als een white-hat hacker. wat het betekent is dat Nomad geen strafrechtelijke vervolging tegen hen zou instellen. Echter, de teruggave van het gestolen geld kreeg naar verluidt tractie na deze aankondiging van een 10% beloning door het Nomad-team. De meeste Whitehat hackers <a href="http://https://cryptoslate.com/nomad-bridge-offers-10-bounty-to-recover-stolen-funds-whitehat-hackers-have-returned-22m/" rel="nofollow noopener noreferrer" target="_blank">reageerde</a> door op 5 augustus $22 miljoen terug te geven.</p>
<p>Op dit moment heeft de portemonnee, de ‘officiële Nomad-fondsen hersteladres’, zoals vermeld door Etherscan, <a href="https://crypto-academy.org/36-million-back-to-nomad-bridge-recovery-account/://" rel="nofollow noopener noreferrer" target="_blank">gewonnen</a> ETH 2.179,5 ($3,9 miljoen), USDC 9,77 miljoen, USDT 5 miljoen, WBTC 196 ($4,7 miljoen), DAI 3,7 miljoen, evenals variërende hoeveelheden van andere ERC-20 tokens. Een overzicht van de teruggekeerde fondsen toonde aan dat het grootste deel ervan stablecoins waren. Andere teruggegeven tokens zijn onder meer SUSHI, WETH, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en anderen. <a href="http:/https://defillama.com/protocol/nomad/" rel="nofollow noopener noreferrer" target="_blank" title="DeFi Llama">DeFi Llama</a> rapporteert dat per woensdag 10 augustus de totale waarde van het project (TVL) $95.963 was.</p>
<p>Op maandag, het team <a href="http://https://twitter.com/nomadxyz_/status/1556760803386175488" rel="nofollow noopener noreferrer" target="_blank">aangekondigd</a> de creatie van de Nomad Official Communication Key, die zal worden gebruikt om on-chain berichten te sturen naar uitstaande wallet adressen om meer ‘white hat hackers’ te vinden en meer geld terug te krijgen.<br><img src="https://gimg2.gateimg.com/image/article/1688624796c.jpeg" alt=""><br>bron: <a href="http://https://twitter.com/nomadxyz_/status/1556760803386175488?s=20&amp;t=rjIPUDfkemNi7xI27-TwQg" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></p>
<h2 id="h2-De20volgende20stap20voor20Nomad481076"><a name="De volgende stap voor Nomad" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De volgende stap voor Nomad</h2><p>Nomade <a href="http://https://cryptoslate.com/nomad-bridge-offers-10-bounty-to-recover-stolen-funds-whitehat-hackers-have-returned-22m/" rel="nofollow noopener noreferrer" target="_blank">verklaard</a> dat het actief samenwerkt met wetshandhavingsfunctionarissen en blockchainbedrijven om ervoor te zorgen dat alle fondsen van klanten worden hersteld. Medeoprichter en CEO van Nomad, Pranay Mohan, merkte ook op:</p>
<p>“Het belangrijkste in crypto is een community, en ons belangrijkste doel is het herstellen van verbonden gebruikersfondsen.”</p>
<p>Nomad gaf een <a href="http://https://cryptoslate.com/nomad-bridge-offers-10-bounty-to-recover-stolen-funds-whitehat-hackers-have-returned-22m/" rel="nofollow noopener noreferrer" target="_blank">waarschuwing</a> aan hackers die niet de vreedzame route zullen nemen door te benadrukken dat het de steun heeft ingeroepen van alle relevante instanties zoals TRM Labs, een toonaangevend bedrijf voor ketenanalyse/-intelligentie, en wetshandhaving om de gestolen fondsen op te sporen en de verantwoordelijken dienovereenkomstig te vervolgen. Het cryptobrugprotocol, Nomad, ook <a href="http://https://cryptoslate.com/whitehat-hackers-refund-9m-to-nomad/" rel="nofollow noopener noreferrer" target="_blank">onthuld</a> dat het samenwerkte met bewaarbedrijf Anchorage Digital om de herstelde fondsen te ‘accepteren en beveiligen’.</p>
<p>In een <a href="http://https://cryptonews.com/news/over-usd-36m-returned-nomad-bridges-fund-recovery-address.htm" rel="nofollow noopener noreferrer" target="_blank">opvolgtweet</a> Op 9 augustus erkende Nomad bepaalde adressen die hebben geholpen om $16,6 miljoen terug te sturen naar zijn hersteladres.<br><img src="https://gimg2.gateimg.com/image/article/1688625040d.jpeg" alt=""><br>source: <a href="http://https://twitter.com/nomadxyz_/status/1557064592303394818?s=20&amp;t=x99pXm5SeOHZec6lnrr0yw" rel="nofollow noopener noreferrer" target="_blank">Twitter</a></p>
<h2 id="h2-Nomad20ontkent20beweringen20dat20ze20vooraf20op20de20hoogte20waren20van20de20aanval789433"><a name="Nomad ontkent beweringen dat ze vooraf op de hoogte waren van de aanval" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Nomad ontkent beweringen dat ze vooraf op de hoogte waren van de aanval</h2><p>Volgens groeiende geruchten in de cryptocurrency-industrie had het Nomad-team naar verluidt een waarschuwing ontvangen over een beveiligingsfout in de code, maar deed er niets aan. Nomad weigerde deze beweringen dat een sonde van Quantstamp het had gewaarschuwd voor het risico van de hack, en volgens hen had het geïdentificeerde probleem in de gegeven analyse niets te maken met de hack. ConclusieOp de een of andere manier heeft Nomad zich gevestigd als een competent crypto-overbruggingsprotocol vanwege zijn snelle acties en drang naar herstel. Volgens rapporten werken ze achter de schermen slim om ervoor te zorgen dat elk gestolen object wordt gevonden en terugbetaald aan de rechtmatige eigenaren. Het is echter nog steeds onzeker hoe mogelijk het is om alle verloren activa terug te halen, hoewel ze zeiden: “Nomad blijft samenwerken met zijn gemeenschap, wetshandhavings- en blockchain-analysebedrijven om ervoor te zorgen dat al het geld wordt teruggegeven.”</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 mening van de onderzoeker en vormt geen investeringssuggesties.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>