V2F6aXJYIEhhY2sgRmFsbG91dDogJDE0OSBtaWxqb2VuIGFhbiBBbHRjb2lucyBvbWdlemV0IGluIEV0aGVyIHRlIG1pZGRlbiB2YW4gdG9lbmVtZW5kZSBUZXRoZXItendlbmRlbA==

2024-07-31, 06:40

<p><img src="https://gimg2.gateimg.com/image/article/17224075431690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR833407"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Cryptocurrency exchange WazirX verloor cryptocurrencies ter waarde van meer dan $230 na een beveiligingsinbreuk.</p>
<p>De WazirX-exploitanten hebben altcoins ter waarde van ongeveer $149 miljoen omgezet in ETH.</p>
<p>Crypto-investeerders moeten zich bewust zijn van opkomende bedreigingen zoals het gebruik van valse <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT.</p>
<h2 id="h2-Introductie72611"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Cybercriminaliteit lijkt door te gaan ondanks de inspanningen die veel crypto-bedrijven leveren om ze te voorkomen. De hoge incidentie <a href="https://www.gate.io/blog_detail/2237" target="_blank">van cryptocurrency-diefstallen</a> de rol die zij spelen in de wereldeconomie aantast, waardoor de <a href="https://www.gate.io/learn/articles/predicting-the-next-five-years-of-cryptocurrency-2024-2029-innovations-regulations-and-market-predictions/3267" target="_blank">adoptiesnelheid van digitale activa</a>. Deze analyse richt zich op de WazirX-hack waarbij de beurs altcoins ter waarde van ongeveer $230 verloor. We zullen ook kijken naar beveiligingsmaatregelen die door op blockchain gebaseerde bedrijven kunnen worden geïmplementeerd. <a href="https://www.gate.io/learn/articles/blockchain-inion-fraud-schemes-and-how-to-prevent-them/3092" target="_blank">om diefstal van digitale activa te voorkomen</a>.</p>
<h2 id="h2-WazirX20Beveiligingsinbreuk20Een20gedetailleerd20overzicht170210"><a name="WazirX Beveiligingsinbreuk: Een gedetailleerd overzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WazirX Beveiligingsinbreuk: Een gedetailleerd overzicht</h2><p>Op 18 juli werd WazirX, een van de toonaangevende Indiase cryptobeurzen, het slachtoffer van een cyberaanval met verlies van altcoins. <a href="https://www.gate.io/learn/articles/gate-research-bitcoin-retraces-to-the-63000-support-level-wazirx-suffers-over-230-million-loss-due-to-attack/3567" target="_blank">waard meer dan $230 miljoen</a>. De aanvallers compromitteerden een van de multisig-portefeuilles van WarzirX. Feit is dat sinds februari 2023 de gecompromitteerde portefeuille werd beheerd met behulp van de wallet-infrastructuur en digitale activabewaring van Liminal. Na de hack werd het voor de cryptobeurs moeilijk om zijn 1.1 onderpand tegen andere activa te handhaven.</p>
<p>Het is belangrijk op te merken dat de gecompromitteerde digitale portemonnee zes ondertekenaars had, bedoeld om ervoor te zorgen dat transacties veilig waren door middel van meerdere goedkeuringen. Uit eerdere onderzoeken bleek dat de belangrijkste oorzaak van de portemonnee-inbreuk de verschillen waren die optraden tussen de inhoud van de daadwerkelijke transacties en de gegevens die op de interface van Liminal werden weergegeven. Ook hebben de onderzoekers onthuld dat de aanvallers de payload hebben vervangen, waardoor ze controle kregen over de cryptocurrencies.</p>
<p>Verduidelijking van het probleem over X <a href="https://x.com/WazirXIndia/status/1813981143437611440" rel="nofollow noopener noreferrer" target="_blank">WazirX zei</a> Tijdens de cyberaanval was er een mismatch tussen de informatie die op de interface van Liminal werd weergegeven en wat er daadwerkelijk werd ondertekend. We vermoeden dat de payload is vervangen om de controle over de portemonnee over te dragen aan een aanvaller.</p>
<p>Het is niet erg duidelijk hoe de beveiligingsinbreuk van cryptocurrency is gelukt, gezien het feit dat verschillende veiligheidsmaatregelen, waaronder het whitelistbeleid en <a href="/price/gnosis-gno" rel="nofollow noopener noreferrer" target="_blank">Gnosis</a> Veilig multisig smart contract platform stonden op zijn plaats. Hierover <a href="https://x.com/WazirXIndia/status/1813981143437611440" rel="nofollow noopener noreferrer" target="_blank">WazirX zei</a> Ondanks dat we alle nodige stappen hebben genomen om de klantactiva te beschermen, lijkt het erop dat de cyberaanvallers mogelijk dergelijke beveiligingsfuncties hebben geschonden en dat de diefstal heeft plaatsgevonden.</p>
<p>Desalniettemin stelt Liminal dat de infrastructuur en de WazirX-portemonnee op zijn platform niet zijn aangetast, wat betekent dat de aanvallen buiten zijn infrastructuur plaatsvonden. Ondertussen heeft de beurs beloofd er alles aan te doen om een deel van de gestolen activa te herstellen en de daders op te sporen. Desalniettemin heeft het de cryptocurrency-beveiligingsinbreuk beschreven als buiten zijn controle. In een <a href="https://x.com/WazirXIndia/status/1813981143437611440" rel="nofollow noopener noreferrer" target="_blank">X post WazirX verklaard</a>“Dit is een overmachtssituatie buiten onze controle, maar we laten geen steen onberoerd om de fondsen te lokaliseren en te herstellen. We hebben al enkele stortingen geblokkeerd en contact opgenomen met betrokken portefeuilles voor herstel.”</p>
<h2 id="h2-WarzirXs20Reactie20Actie20tegen20de20aanvallers35839"><a name="WarzirX’s Reactie: Actie tegen de aanvallers" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WarzirX’s Reactie: Actie tegen de aanvallers</h2><p>Hoewel de crypto-uitwisseling tijdelijk stopte met stortingen en handel, heeft het verschillende stappen ondernomen tegen de aanvallers. Ten eerste heeft het de cyberdiefstal gemeld bij een aantal wetshandhavingsinstanties zoals het National Cyber Crime Reporting Portal en de Financial Intelligence Unit (FIU) India en CERT-In.</p>
<p>Het heeft ook samengewerkt met verschillende cryptocurrency-beurzen om de portefeuilles te blokkeren die zijn gebruikt tijdens de aanvallen. In een poging om een deel van de gestolen cryptocurrencies terug te krijgen. <a href="https://www.gate.io/how-to-buy/wazirx-wrx" target="_blank">WazirX</a> geëngageerde cybersecurity-experts. Uiteindelijk heeft het een beloning aangeboden tot 10% van de gestolen crypto-assets. In een X-post legde het uit wat de beloning is die het biedt aan iedereen die kan helpen bij het herstelproces van de gestolen digitale activa. <a href="https://x.com/WazirXIndia/status/1813981143437611440" rel="nofollow noopener noreferrer" target="_blank">Het verklaarde</a>“Beloningen tot $10.000 aan USDT worden gegeven voor bruikbare informatie die leidt tot het bevriezen en terugvorderen van de gestolen fondsen. We bieden 10%, d.w.z. tot $23 miljoen, als White Hat Bounty.”</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/wazirx-wrx" target="_blank">WazirX Prijsvoorspelling &amp; Voorspelling voor 2025-2030</a></p>
<h2 id="h2-Hackers20poging20om20niet20gepakt20te20worden20omzetting20van20gestolen20altcoins20naar20Ether636323"><a name="Hackers’ poging om niet gepakt te worden: omzetting van gestolen altcoins naar Ether" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hackers’ poging om niet gepakt te worden: omzetting van gestolen altcoins naar Ether</h2><p>In wat leek op een voorbedachte rade zetten de hackers het grootste deel van de crypto buit om in ETH. Op basis van de analyse van Elliptic heeft de hacker crypto-activa gestolen, bestaande uit <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a>, PEPE, Matic en Ether, met een waarde van meer dan $235 miljoen zoals blijkt uit de volgende grafiek.<br><img src="https://gimg2.gateimg.com/image/article/17224077931.jpg" alt=""><br>WarzirX’s Crypto Loss- Elliptic</p>
<p>Zoals waargenomen op <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">de grafiek</a> verschillende cryptocurrencies, waaronder USDT en Floki, zijn gestolen. Volgens <a href="https://wazirx.com/blog/wazirx-releases-proof-of-reserves-for-june-2024/" rel="nofollow noopener noreferrer" target="_blank">WazirX de slechte acteurs hebben meer dan 45% gestolen</a> van zijn reserve-activa. Lookonchain, een digitaal analysebedrijf, meldt dat de aanvallers het grootste deel van de gestolen cryptocurrencies hebben omgezet in ETH.<br><img src="https://gimg2.gateimg.com/image/article/17224078242.jpg" alt=""><br>Bron: x.com</p>
<p>Zoals de afbeelding aangeeft, hebben de WazirX-exploitanten de activa omgezet in 43.800 ETH ter waarde van ongeveer $149,46 miljoen op dat moment. Het heeft nog steeds 59.097 ETH ter waarde van $201,67 miljoen. Bovendien hebben ze 7,7 miljoen DENT gestort in een Binance-portemonnee die nog nooit eerder was gebruikt. Ze zijn overgegaan tot altcoin naar Ether conversie vanwege de hoge liquiditeit van ETH. Bovendien is het niet mogelijk om ETH op de zwarte lijst te zetten, aangezien het een gedecentraliseerde token is. Een dergelijke conversie heeft echter niet geleid tot enige negatieve <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> markteffect doordat de prijs tijdens de genoemde periode normaal bleef.</p>
<h2 id="h2-Opkomst20van20nepTether20Verkenning20van20de20toename20van20valse20Tethertransacties20binnen20de20regio20Asia20Express533124"><a name="Opkomst van nep-Tether: Verkenning van de toename van valse Tether-transacties binnen de regio Asia Express" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Opkomst van nep-Tether: Verkenning van de toename van valse Tether-transacties binnen de regio Asia Express</h2><p>Zoals je opmerkt in het g van WarzirX, bedenken hackers nieuwe methoden om digitale activa te stelen. Op dit moment is er een nieuwe trend waarbij sommige aanvallers valse <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> gebruiken om fondsen te bedriegen van nietsvermoedende cryptogebruikers. Met deze Tether-zwendel, vooral veelvoorkomend in de regio Asia Express, creëren de aanvallers valse USDT-tokens die ze verkopen aan andere cryptogebruikers.</p>
<p>Het gedrag van de nep Tether is vergelijkbaar met dat van echte USDT. Bijvoorbeeld, het is gemakkelijk over te maken naar een USDT-portemonnee. Je kunt ook naar de block explorer gaan en de transactie bevestigen. Echter, als iemand je de nep USDT stuurt, komt het niet in je digitale portemonnee terecht. De beste manier om oplichting met Tether te voorkomen, is om transacties te doen met mensen die je kent. Het is ook verstandig om Tether USDT-transacties uit te voeren op crypto-beurzen zoals Gate.io en Coinbase.</p>
<h2 id="h2-Cybersecurityanalyse20is20er20een20verband20tussen20de20WazirXexploit20en20Tetherzwendel907893"><a name="Cybersecurity-analyse: is er een verband tussen de WazirX-exploit en Tether-zwendel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cybersecurity-analyse: is er een verband tussen de WazirX-exploit en Tether-zwendel?</h2><p>Op dit moment is er geen direct verband tussen de WazirX-exploit en Tether-oplichting. Er zijn echter verschillende dingen om op te merken over de twee. Het lijkt erop dat de daders van de WazirX-exploit dezelfde mensen zijn achter de Tether-oplichting. Dit komt doordat de portemonnee-adressen die werden gebruikt tijdens de WazirX-exploit ook werden gebruikt voor Tether-oplichting. Bovendien vonden de WazirX-exploit en enkele Tether-oplichting rond dezelfde tijd plaats. Er is echter nog geen officiële reactie geweest van WazirX en onderzoeksteams over het verband tussen de twee gebeurtenissen.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/top-10-crypto-scams-and-how-to-avoid-them/2556" target="_blank">Top 10 Crypto Scams en hoe ze te vermijden</a></p>
<h2 id="h2-De20toekomst20van20de20cryptocurrency20sector20in20het20licht20van20beveiligingsdreigingen646108"><a name="De toekomst van de cryptocurrency sector in het licht van beveiligingsdreigingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De toekomst van de cryptocurrency sector in het licht van beveiligingsdreigingen</h2><p>Zonder twijfel worden crypto-gebruikers van tijd tot tijd geconfronteerd met vele bedreigingen. Er zijn verschillende blockchain-beveiligingsmaatregelen die gedecentraliseerde digitale activa-investeerders moeten nemen om hun activa te beschermen. Ten eerste is het belangrijk om op de hoogte te zijn van de bestaande cryptocurrency-regelgeving in de jurisdictie waarin u opereert. Bijvoorbeeld, weet hoe belastingwetten werken in uw land om financiële verplichtingen te voorkomen die kunnen voortvloeien uit het niet naleven van deze regelgeving.</p>
<p>Evenzo moet u vertrouwd zijn met de richtlijnen voor cryptoinvesteerders om onnodige verliezen te voorkomen. Bijvoorbeeld, elke investeerder moet het grootste deel van zijn cryptomiddelen opslaan in harde wallets. Ze moeten ook gebruik maken van crypto-uitwisselingen en DeFi-platforms die tweestapsverificatie en ken-uw-klant (KYC) gebruiken voor het uitvoeren van cryptotransacties. Ten slotte moet elke cryptoinvesteerder zijn cryptoinvesteringen diversifiëren in plaats van alle fondsen in één cryptocurrency te plaatsen zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">bitcoin</a>. Dit komt omdat als de prijs van dat actief volatiel wordt, men veel geld kan verliezen.</p>
<p>lees ook: <a href="https://www.gate.io/learn/articles/frequent-scams-and-theft-in-the-cryptocurrency-space-how-can-ordinary-people-protect-themselves/3497" target="_blank">Veelvoorkomende oplichting en diefstal in de cryptowereld</a></p>
<h2 id="h2-Hoe20Gateio20uw20fondsen20beschermt668871"><a name="Hoe Gate.io uw fondsen beschermt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe Gate.io uw fondsen beschermt</h2><p>Het is ook belangrijk voor cryptoinvesteerders om gebruik te maken van veilige beurzen die hun activa beschermen. Gate.io is een van de meest veilige cryptobeurzen op de markt, aangezien het verschillende blockchain-beveiligingsmaatregelen instelt.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2460/security-measures-at-gateio-protecting-your-digital-assets-in-the-crypto-landscape" target="_blank">Het beschermen van uw digitale activa in de cryptosector</a></p>
<p>Koude opslag: Gate.io bewaart het grootste deel van de digitale activa in zijn beheer in offline portefeuilles die moeilijk te hacken zijn.</p>
<p>Multi-Signature Wallets: Het maakt gebruik van multisig-wallets die zeer moeilijk te doorbreken zijn en de activa te stelen.</p>
<p>Twee-factor authenticatie: De beurs maakt gebruik van een robuust en bewezen tweefactor-authenticatiesysteem dat een extra beveiligingslaag biedt voor uw digitale activa.</p>
<p>Gegevensversleuteling: De gevoelige gegevens op het platform zoals wachtwoorden worden versleuteld, waardoor het moeilijk is voor potentiële misbruikers om deze te kraken.</p>
<p>Andere beveiligingsmaatregelen: Naast het bovenstaande voldoet Gate.io aan de regelgeving in de landen waarin het actief is. Het heeft ook transparante beleidsmaatregelen, veilige datacenters en regelmatige beveiligingsaudits.</p>
<h2 id="h2-Conclusie169147"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Bij een recente crypto exploit verloor WazirX cryptocurrencies ter waarde van meer dan $230 miljoen. Van deze heeft de hackers altcoins ter waarde van ongeveer $149 miljoen omgezet in ETH omdat het een hoge liquiditeit heeft. Afgezien hiervan was er in dezelfde periode een opkomst van een nieuw type oplichting, de ontwikkeling en het gebruik van nep Tether USDT. Om onnodig verlies van crypto-activa te voorkomen, moeten beleggers ze opslaan in koude opslag en veilige beurzen zoals Gate.io gebruiken.</p>
<div class="blog-details-info"><br><div>Auteur:<em> Mashell C.</em>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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>