QmV2ZWlsaWdpbmdzd2FhcnNjaHV3aW5nOiAyMjAgRGVGaS1wcm90b2NvbGxlbiBibG9vdGdlc3RlbGQgYWFuIG1vZ2VsaWprZSBTcXVhcmVzcGFjZSBETlMta2FwaW5nLg==

2024-07-24, 07:50

<p><img src="https://gimg2.gateimg.com/image/article/1721807281sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR698343"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>DNS-aanvallen kunnen DNS-records omleiden naar kwaadaardige websites die de portefeuilles van gebruikers kunnen leegmaken.</p>
<p>Gedurende de eerste twee weken van juli hebben enkele slechte acteurs geprobeerd om MetaMask te compromitteren, <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a> en Celer Networks, onder anderen.</p>
<p>Gebruikers moeten sterke wachtwoorden gebruiken voor e-mails, evenals tweestapsverificatie voor hun digitale accounts.</p>
<h2 id="h2-Inleiding622414"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Cryptoaanvallers verhogen hun methoden om digitale activa te stelen van argeloze investeerders. Daarom is het essentieel voor mensen die crypto-transacties uitvoeren om attent te zijn op ongebruikelijke activiteiten op de blockchainnetwerken waarmee ze interacteren. Vandaag richten we ons op hoe cryptoaanvallers DNS-kaping gebruiken om van mensen te stelen. We zullen ook verkennen manieren waarop investeerders hun activa kunnen beschermen tegen dergelijke aanvallen.</p>
<h2 id="h2-Cryptocriminelen20verbeteren20hun20methoden20Hoe20DNSaanvallen20de20sector20bedreigen851019"><a name="Cryptocriminelen verbeteren hun methoden: Hoe DNS-aanvallen de sector bedreigen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cryptocriminelen verbeteren hun methoden: Hoe DNS-aanvallen de sector bedreigen</h2><p>Een nieuwe crypto-aanvalsmethode genaamd DNS-hijacking bedreigt de beveiliging van verschillende blockchainnetwerken. Deze geavanceerde methode die door de slechte actoren wordt gebruikt, kan veel gedecentraliseerde financiële protocollen beïnvloeden, met de vrees dat meer dan 220 DeFi-protocollen momenteel ernstig worden bedreigd.</p>
<p>Via Squarespace DNS-kaping kunnen kwaadwillende actoren DNS-records omleiden naar kwaadaardige IP-adressen die worden gebruikt om digitale activa uit de portefeuilles van nietsvermoedende gebruikers te halen. Met behulp van deze methode hebben aanvallers al verschillende DeFi-protocollen, waaronder Compound, gecompromitteerd. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>-gebaseerd DeFi-protocol, en Celer Network, een multi-chain interoperabiliteitsprotocol. De digitale portefeuilles van de gebruikers die interageren met de front-ends van de gerichte protocollen zullen worden doorgestuurd naar webpagina’s die hun portefeuilles zullen legen. Het is essentieel om op te merken dat in de meeste glen de slachtoffers worden misleid om kwaadaardige transacties te ondertekenen die de aanvallers volledige controle geven over hun activa. De leegloopkits worden meestal ingezet via gecompromitteerde domeinen en phishingwebsites, waardoor veel crypto-investeerders te maken krijgen met DeFi-beveiligingsrisico’s.</p>
<p>Sommige waarnemers hebben erop gewezen dat deze aanvallers banden hebben met de beruchte Inferno Drainer, die geavanceerde portemonnee-drainagekits gebruikt om controle te krijgen over de cryptotegoeden van slachtoffers via misleidende transacties. Volgens een recente publicatie van Decrypt is Ido Ben-Natan, medeoprichter en CEO van Blockaid, ervan overtuigd dat Inferno Drainer betrokken is bij deze cryptoroof. In een <a href="https://decrypt.co/239524/220-defi-protocols-risk-squarespace-dns-hijack" rel="nofollow noopener noreferrer" target="_blank">In een interview met Decrypt zei Ben-Natan</a> De associatie met Inferno Drainer is duidelijk vanwege de gedeelde onchain- en offchain-infrastructuur. Dit omvat onchain-portemonnee- en smart contract-adressen, evenals offchain IP-adressen en domeinen die aan Inferno zijn gekoppeld.</p>
<p>Aangezien deze cybercriminelen echter on-chain en off-chain infrastructuur delen, is het mogelijk om ze te volgen. Digitale bedrijven zoals Blockaid die samenwerken met getroffen gemeenschappen en partijen kunnen bijvoorbeeld helpen bij het identificeren van DNS-kwetsbaarheden en het beperken van de effecten van dergelijke aanvallen. Duidelijke communicatie en samenwerking van verschillende betrokken partijen is echter essentieel om de omvang van de schade die de aanval kan veroorzaken te beperken. Ben-natan legt uit: “Blockaid is in staat om de adressen te traceren. Ons team heeft ook nauw samengewerkt met de gemeenschap om ervoor te zorgen dat er een open kanaal is om gecompromitteerde sites te melden.”<br>Lang geleden, in november 2023, kondigde Inferno Drainer zijn voornemen aan om zijn operatie te ontbinden. Zo te zien vormt de groep echter nog steeds veel cyberbeveiliging bij crypto-bedreigingen via DNS-kaping en andere gerelateerde methoden. Op basis van de recente trends op het gebied van cryptocurrency-beveiliging heeft Inferno Drainer voor meer dan $ 180 miljoen aan digitale activa gestolen.</p>
<h2 id="h2-DNS20Hijackprobleem20Hoe20het20werkt667915"><a name="DNS Hijack-probleem: Hoe het werkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DNS Hijack-probleem: Hoe het werkt</h2><p>Een DNS-aanval treedt op wanneer de slechte actoren zoekopdrachten omleiden naar ongeautoriseerde domeinnamenservers. In feite gebruikt de aanvaller ongeautoriseerde wijzigingen of malware om het DNS-record van de doelwebsite te wijzigen, waardoor de gebruikers naar een kwaadaardige bestemming worden omgeleid. In het g van de Squarespace-aanval geloven sommige experts dat de aanvallers DNS-cachevergiftiging zouden hebben kunnen gebruiken, waarbij valse gegevens in de DNS-caches worden geïnjecteerd. Als gevolg daarvan zouden de DNS-query’s onjuiste antwoorden teruggeven voordat gebruikers naar kwaadaardige websites worden omgeleid.</p>
<p>De <a href="https://www.gate.io/learn/articles/how-defi-protocols-generate-revenue-and-why-its-important/2890" target="_blank">DeFi-protocollen</a> Die werden aanglen gebruikten verschillende methoden om grootschalige diefstallen van de digitale activa van de gebruikers te voorkomen. Een van de veelgebruikte SquareSpace-beveiligingsreacties was om de gebruikers te waarschuwen voor het bestaande gevaar. Bijvoorbeeld, MetaMask waarschuwde zijn gebruikers voor het gevaar via sociale media platforms zoals <a href="https://x.com/MetaMask/status/1811436757759701391" rel="nofollow noopener noreferrer" target="_blank">X.com</a>.<br><img src="https://gimg2.gateimg.com/image/article/17218082771.jpeg" alt=""><br>Bron: <a href="https://x.com/MetaMask/status/1811436757759701391" rel="nofollow noopener noreferrer" target="_blank">X.com</a></p>
<p>Nadat de doelgerichte DeFi-protocollen de waarschuwingen deelden op verschillende sociale mediaplatforms, hielpen veel leden van verschillende cryptogemeenschappen door het bericht te verspreiden en waarschuwden ze veel gebruikers van digitale activa voor de bestaande bedreigingen.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/six-major-indicators-every-beginner-must-know-about-defi/563" target="_blank">Zes belangrijke indicatoren die elke beginner moet weten over DeFi</a></p>
<h2 id="h2-Scope20of20Impact2022020DeFiprotocollen20in20gevaar22536"><a name="Scope of Impact: 220 DeFi-protocollen in gevaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Scope of Impact: 220 DeFi-protocollen in gevaar</h2><p>Op dit moment is er geen tastbare informatie over de volledige omvang van de recente Squarespace DNS-kaping. De eerste DNS-aanvallen werden op 6 en 11 juli van dit jaar gedetecteerd toen de kwaadwillende actoren probeerden controle te krijgen over <a href="/price/compound-comp" target="_blank" class="blog_inner_link">Compound</a> en Celer Network. In het g van Celer Network wist het monitoringsysteem echter de aanval te dwarsbomen. De eerste beoordeling van de aanvallen door Blockaid geeft aan dat de aanvallers zich richten op domeinnamen die Squarespace levert. Dit zet meer dan 220 DeFi-protocollen bloot aan DeFi-beveiligingsrisico’s. Dit komt doordat alle <a href="https://www.gate.io/blog_detail/1038/everything-you-need-to-know-about-defi" target="_blank">DeFi-apps</a> die Squarespace-domeinen gebruiken, lopen risico op DNS-aanvallen.</p>
<p>Hierover, via een <a href="https://x.com/blockaid_/status/1811423284409602184" rel="nofollow noopener noreferrer" target="_blank">X bericht, zei Blockaid</a> Vanuit de eerste beoordeling lijkt het erop dat de aanvallers opereren door DNS-records van projecten gehost op SquareSpace te kapen. Aanvallen op verschillende DeFi-protocollen, digitale portefeuilles en crypto-uitwisselingen werden gedwarsboomd door hun robuuste beveiligingsen. In de meeste glen waarschuwden de voorzijden gebruikers voor het dreigende gevaar, zoals blijkt uit de volgende schermafbeelding.<br><img src="https://gimg2.gateimg.com/image/article/17218083422.jpeg" alt=""><br>Bron: x.com</p>
<p>Zoals waargenomen, hebben digitale portefeuilles zoals Coinbase Wallet en MetaMask de bijbehorende websites aangemerkt als kwaadaardig en onveilig. Voorbeelden van sommige DeFi-protocollen die risico lopen, zijn Thorchain, Flare, Pendle Finance. <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> Labs, Polymarket, Satoshi Protocol, Near, <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a>, Nirvana, MantaDAO en Ferrum.</p>
<h2 id="h2-De20rol20van20DNS20in20Crypto20Security259548"><a name="De rol van DNS in Crypto Security" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De rol van DNS in Crypto Security</h2><p>In eenvoudige bewoordingen zet een Domain Name  (DNS) website namen om in computer-vriendelijke adressen. Zo vertalen ze domeinnamen zoals www.tcore.com) naar numerieke IP-adressen zoals 82.223.84.85 waardoor apparaten verbinding kunnen maken met verschillende online bestemmingen. Een DNS speelt echter een belangrijke rol bij het beveiligen van online cryptoplatforms. Omdat het een gedecentraliseerd systeem is, heeft het geen centraal faalpunt dat vele cyberaanvallen voorkomt. Bovendien maakt blockchain DNS het onmogelijk voor slechte actoren om te knoeien met transacties, waardoor digitale activa die op verschillende gedecentraliseerde netwerken bestaan, worden beveiligd.</p>
<h2 id="h2-Hoe20DeFiplatforms20zichzelf20kunnen20beschermen20tegen20vergelijkbare20kwetsbaarheden776311"><a name="Hoe DeFi-platforms zichzelf kunnen beschermen tegen vergelijkbare kwetsbaarheden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe DeFi-platforms zichzelf kunnen beschermen tegen vergelijkbare kwetsbaarheden</h2><p>Na de DNS-aanvallen hebben cybersecurity-experts verschillende methoden voorgesteld om vergelijkbare DNS-kwetsbaarheden aan te pakken. DeFi-bedrijven kunnen meer beveiligingslagen toevoegen aan hun protocollen. Bijvoorbeeld, ze kunnen hun smart contracts opnieuw configureren om updates te voorkomen, tenzij ze zijn geverifieerd door onchain-handtekeningen. In dit g moet een DNS vóór een update een handtekening aanvragen van de portemonnee van de gebruiker. Dit zal het voor hackers moeilijker maken om te slagen in hun missies, omdat ze zowel de portemonnee als de registrar zouden moeten hacken.</p>
<p>Bovendien moeten DeFi-protocollen mogelijk vertrouwde URL’s markeren en alle bijbehorende websiteadressen verifiëren. Ze kunnen ook relevante browserextensies toevoegen, zoals HTTPS en tweefactorauthenticatie (2FA) voor digitale accounts en portefeuilles. Bovendien moet het DeFi-protocol communicatiekanalen hebben om verdachte crypto-activiteiten te melden. Met dat kunnen getroffen platforms ondersteuning krijgen van andere beveiligingspartners.</p>
<p>Een andere manier van <a href="https://www.gate.io/learn/articles/what-is-defi/2815" target="_blank">bescherming van DeFi-platforms</a> is het gebruik van inhoudsfiltering om te voorkomen dat kwaadaardige websites communiceren met hun slimme contracten. Ze kunnen bijvoorbeeld robuuste malware gebruiken <a href="https://www.gate.io/learn/articles/common-phishing-methods-and-security-prevention-suggestions-in-web3/3061" target="_blank">om de phishingwebsites te blokkeren</a>.</p>
<h2 id="h2-Gebruikershandleiding20Hoe20u20persoonlijke20activa20kunt20beschermen618199"><a name="Gebruikershandleiding: Hoe u persoonlijke activa kunt beschermen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gebruikershandleiding: Hoe u persoonlijke activa kunt beschermen</h2><p>Naast de DeFi-protocolbeveiligingsmaatregelen die zijn geïmplementeerd, moeten gebruikers hun eigen strategieën voor de bescherming van crypto-activa aannemen. Zo zouden ze antimalwaresoftware moeten installeren op hun elektronische apparaten. Ze moeten ook tweefactorauthenticatie, VPN’s en sterke firewalls gebruiken. Bovendien moeten individuen sterke wachtwoorden gebruiken voor hun e-mails en domeinregistraties.</p>
<h2 id="h2-Conclusie248481"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Meer dan 220 DeFi-protocollen worden bedreigd door DNS-aanvallen. Gedurende de eerste twee weken van juli hebben enkele kwaadwillende aanvallers geprobeerd om verschillende DeFi-protocollen en digitale portefeuilles, waaronder Compound, Celer Network, Coinbase wallet en MetaMask, te compromitteren. De meeste van deze platforms hebben echter de aanvallen afgeslagen. Om toekomstige aanvallen te voorkomen, kunnen crypto-bedrijven <a href="https://www.gate.io/blog_detail/4278/stay-safe-with-gate.io-essential-security-measures-every-user-should-know" target="_blank">introduceer aanvullende beveiligingsmaatregelen</a> zoals tweestapsverificatie en relevante browserextensies zoals HTTPS.</p>
<h2 id="h2-Veelgestelde20vragen20over20DNSaanvallen804419"><a name="Veelgestelde vragen over DNS-aanvallen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over DNS-aanvallen</h2><h3 id="h3-Wat20gebeurt20er20als20DNS20wordt20gekaapt866785"><a name="Wat gebeurt er als DNS wordt gekaapt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat gebeurt er als DNS wordt gekaapt?</h3><p>Als DNS wordt gekaapt, zal het DNS-records omleiden naar kwaadaardige websites, wat kan leiden tot het leeglopen van gebruikersportefeuilles. Om DNS-aanvallen te voorkomen, moeten DeFi-bedrijven mogelijk hun slimme contracten opnieuw configureren om updates te stoppen die normaal gesproken plaatsvinden zonder geverifieerde onchain-handtekeningen.</p>
<h3 id="h3-Hoe20ga20je20DNSkaping20tegen582768"><a name="Hoe ga je DNS-kaping tegen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe ga je DNS-kaping tegen?</h3><p>Gebruikers kunnen verschillende strategieën gebruiken, zoals sterke e-mailwachtwoorden en tweefactorauthenticatie, om DNS-kaping te verminderen. Aan de andere kant moeten DeFi-protocollen vertrouwde URL’s markeren en alle bijbehorende websiteadressen verifiëren.</p>
<h3 id="h3-Voorkomt20VPN20DNSkaping460365"><a name="Voorkomt VPN DNS-kaping?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voorkomt VPN DNS-kaping?</h3><p>Een VPN kan DNS-kaping voorkomen. Dit komt doordat de VPN in staat is om de onderschepping van DNS-query’s te voorkomen. Gebruikers moeten echter betrouwbare VPN’s gebruiken.</p>
<h2 id="h2-Wat20is20het20verschil20tussen20DNSbewijs20en20DNSkaping547743"><a name="Wat is het verschil tussen DNS-bewijs en DNS-kaping?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het verschil tussen DNS-bewijs en DNS-kaping?</h2><p>DNS-hijacking houdt in dat de DNS-instellingen worden gewijzigd, terwijl DNS-proofing de DNS-records wijzigt. Gewoonlijk gebruiken de aanvallers malware om DNS-hijacking mogelijk te maken.</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 enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>