RWlnZW5sYXllciBYLWFjY291bnQgaXMgZ2VoYWNrdDogUGFzIG9wIHZvb3IgcGhpc2hpbmcgc2NhbXM=

<p><img src="https://gimg2.gateimg.com/image/article/17303433661690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR286409"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Op 18 oktober hebben enkele slechte actoren het Eigenlayer X-account geschonden en phishinglinks geplaatst.</p>
<p>Tijdens Q3 2024 werd meer dan $314 miljoen gestolen via crypto-phishing scams.</p>
<p>In september leidde een enkele crypto phishing scam tot een verlies van cryptocurrencies ter waarde van ongeveer $32.43 miljoen.</p>
<h2 id="h2-Introductie359916"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Kwaadwillende actoren in de crypto sector worden steeds gedurfder en innovatiever om te stelen van argeloze individuen. Fraude, hacks en phishing scams zijn enkele van de methoden die deze kwaadwillende actoren gebruiken om cryptocurrencies te stelen. Echter, de spelers in de gedecentraliseerde digitale sector bevorderen eenheid om incidenten van crypto diefstal te voorkomen of te verminderen. Vandaag bespreken we hoe oplichters phishing hebben gebruikt om crypto gebruikers te misleiden.</p>
<h2 id="h2-Eigenlayer20krijgt20opnieuw20te20maken20met20een20phishingschrik904162"><a name="Eigenlayer krijgt opnieuw te maken met een phishing-schrik" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Eigenlayer krijgt opnieuw te maken met een phishing-schrik</h2><p>Op 18 oktober braken kwaadwillenden in op het X-account van Eigenlayer in een poging om cryptocurrencies van zijn gebruikers te stelen via phishing. Ze wilden profiteren van Eigenlayer’s geschiedenis van succesvolle airdrops. Na de overname van de <a href="https://www.gate.io/learn/articles/a-comprehensive-interpretation-of-eigenlayer-a-new-favorite-project-both-loved-and-hated-by-ethereum/1784" target="_blank">Eigenlaag</a> Account X hebben de oplichters een bericht geplaatst waarin zij beweren dat de blockchain nog een airdrop heeft. Ze beweren dat alle gebruikers die in aanmerking kwamen tijdens de vorige airdrop ronde moeten deelnemen aan de huidige. Ze hebben een <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">link</a> waardoor de Eigenlayer-gebruikers de airdrop zouden claimen. Desalniettemin, de <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">link</a> leidde de gebruikers naar de phishingwebsite van de oplichters.</p>
<p>PeckShield, het blockchain-beveiligingsbedrijf, was de eerste die cryptogebruikers waarschuwde voor het valse airdrop-programma. In zijn oplichterswaarschuwing op X waarschuwde PeckShield de cryptogebruikers om niet op de verstrekte URL-links te klikken.<img src="https://gimg2.gateimg.com/image/article/17303435381.jpeg" alt=""><br>PeckShield Oplichting  - x.com/PeckShield</p>
<p>Na de waarschuwing van PeckShield X aan de cryptogemeenschap over de phishingzwendel, informeerde Eigenlayer zijn leden over de ontwikkeling. Het zei: Het @EigenLayer-account is gecompromitteerd. Ga niet in op verdachte links en controleer actief en verifieer dat u betrokken bent bij ‘eigenlayer.xyz’. Er wordt een update gegeven zodra het beveiligd is.</p>
<p>Als de twee crypto-bedrijven niet snel hadden gehandeld, zouden veel leden van de Eigenlayer X-gemeenschap mogelijk zijn opgelicht. Dit komt omdat de oplichters een geavanceerde methode gebruikten om de <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> te verbergen. Zo had het bericht van de oplichters een ogenschijnlijk legitieme afbeelding van de Eigenlayer restaking-website, inclusief de blog-URL. Dit komt omdat de aanvaller een anti-oplichting afbeelding aan de tweet-thread heeft toegevoegd om de geloofwaardigheid te vergroten. Ook gebruikten de oplichters meerdere versies van de scam-link. Ze roteerden de URL’s om gemakkelijke detectie te voorkomen. Het is belangrijk op te merken dat de zogenaamde airdrop enkele weken na het officiële seizoen 2-stakedrop plaatsvond.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/exploring-the-re-staking-potential-of-eigenlayer/4069" target="_blank">Het verkennen van het rekencapaciteitspotentieel van EigenLayer</a></p>
<p>Het goede is dat er snel oplichtingslinkdetectie was. Als gevolg hiervan werd de post van de oplichters binnen korte tijd verwijderd. De populariteit van de Eigenlayer, het op één na grootste protocol op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> netwerk heeft geresulteerd in <a href="https://www.gate.io/blog/1425/What-is-phishing-and-how-to-protect-ourselves-from-phishing-attacks" target="_blank">vele phishing scams</a> Tot nu toe waren er alleen al in oktober twee phishing scams. Eerst, op 4 oktober, kondigde het team aan dat het een “niet-goedgekeurde verkoopactiviteit” onderzocht die betrokken was bij een adres eindigend op “f10D.” Eigenlayer beweerde dat de portemonnee ongeveer 1,6 miljoen heeft verkocht. <a href="https://www.gate.io/how-to-buy/eigenlayer-eigen" target="_blank">EIGEN tokens</a> gewaardeerd op ongeveer $5,7 miljoen. Echter, op 5 oktober informeerde het team zijn X gemeenschap dat de transactie het gevolg was van een crypto hack.</p>
<p>Lees over <a href="https://www.gate.io/learn/articles/eigenlayers-risk-management/1955" target="_blank">Risicobeheer bij Eigenlayer</a></p>
<h2 id="h2-De20Groeiende20Dreiging20van20Overnames20van20Sociale20Media20Accounts20en20de20Effecten20op20de20Crypto20Sector936003"><a name="De Groeiende Dreiging van Overnames van Sociale Media Accounts en de Effecten op de Crypto Sector" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Groeiende Dreiging van Overnames van Sociale Media Accounts en de Effecten op de Crypto Sector</h2><p>De hack van het Eigenlayer X-account benadrukt het groeiende gevaar van overname van socialemedia-accounts en phishing. Een recent rapport van Security.Org heeft aangetoond dat glen van accountovernames onder inwoners van de Verenigde Staten sinds 2021 met 29% zijn toegenomen. In het rapport werden manieren geïdentificeerd om overname van socialemedia-accounts te voorkomen. Deze omvatten het gebruik van sterke unieke wachtwoorden, het inschakelen van beveiligingsvragen en het gebruik van multi-factor authenticatie.</p>
<p>In de cryptosector misleiden sommige oplichters gebruikers om hun digitale portefeuilles te verbinden met frauduleuze diensten. Als iemand zijn/haar cryptowallet verbindt met phishing-websites, plunderen de oplichters hun digitale activa. In die situatie is er geen behoefte aan enige authenticatie.</p>
<p>Aan de andere kant, als de oplichters de accounts van cryptoprojecten overnemen, kunnen ze deze gebruiken om nepbeleggingsprogramma’s en airdrops te adverteren. Dergelijke aanvallen zijn meestal succesvol omdat ze worden uitgevoerd op betrouwbare socialemediaplatforms zoals het Eigenlayer’s X-profiel.</p>
<h2 id="h2-Prentie20van20Phishing20Scams20in20Crypto387481"><a name="Prentie van Phishing Scams in Crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prentie van Phishing Scams in Crypto</h2><p>Volgens Chainanalysis heeft goedkeuringsphishing - waarbij slachtoffers worden misleid om kwaadaardige transacties uit te voeren - geleid tot diefstal van miljarden digitale activa, waaronder cryptocurrencies en NFT’s. Social media platforms die eigendom zijn van legitieme cryptoprojecten zijn de belangrijkste doelwitten van oplichters. Zo gebruiken sommige bedriegers misleidende links in opmerkingen op social media platforms van bekende cryptoprojecten.</p>
<p>In september resulteerden crypto phishing scams in het verlies van $46 miljoen aan cryptocurrencies. Gedurende deze periode werden meer dan 10.800 slachtoffers getroffen. Aan de andere kant werd er in het derde kwartaal van 2024 voor meer dan $127 miljoen aan cryptocurrencies gestolen als gevolg van phishing. De grootste crypto phishing scam in september leidde tot het verlies van crypto assets ter waarde van ongeveer $32,43 miljoen.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/common-phishing-methods-and-security-prevention-suggestions-in-web3/3061" target="_blank">Gemeenschappelijke phishing-methoden en beveiligingspreventie suggesties in Web3</a><img src="https://gimg2.gateimg.com/image/article/17303437712.jpeg" alt=""></p>
<p>Het grootste crypto-phishingincident in september 2024 - x.com/scamsniffer</p>
<p>In het bovenstaande g verloor het slachtoffer 2.083 spWETH. Gedurende september richtten de slechte acteurs zich voornamelijk op <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, MATIC en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>. Een ander rapport van Scam Sniffers toont aan dat er meer dan $314 miljoen aan cryptocurrencies is gestolen via phishing scams tijdens Q3, 2024.<br><img src="https://gimg2.gateimg.com/image/article/17303438003.jpeg" alt=""><br>Glen van Crypto Phishing Scam in Q3,2024 - Scam Sniffer</p>
<p>Zoals uit de bovenstaande cijfers blijkt, is er voor meer dan $314 miljoen aan digitale valuta gestolen. Aan de andere kant werden 266.713 personen getroffen. Het is opmerkelijk dat het merendeel van deze verliezen via goedgekeurde sociale media verloopt. Dit benadrukt de noodzaak voor individuen om de veiligheid van hun crypto-accounts te verbeteren. Een manier om dit te bereiken is door het vermijden van het klikken op links van onbekende partijen. Aan de andere kant moeten cryptoprojectteams ervoor zorgen dat er zeer weinig kans is op social media phishing. Zo kunnen ze bijvoorbeeld mensen toewijzen om nauwlettend toezicht te houden op alle activiteiten op hun sociale media platforms.</p>
<p>De volgende grafiek toont de trend met betrekking tot phishing scams.<br><img src="https://gimg2.gateimg.com/image/article/17303438344.jpeg" alt=""><br>Phishing Scams Trend in 2024 - Scam Sniffer</p>
<p>Zoals te zien is in de bovenstaande grafiek, is het niveau van crypto phishing scams zeer hoog gebleven. Dit toont de noodzaak aan om de beveiliging van blockchain te verbeteren. Sterker nog, zowel crypto-projecten als gebruikers zouden goedgekeurde en geteste crypto-beveiligingsmaatregelen moeten aannemen.</p>
<h2 id="h2-Conclusie896818"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Op 18 oktober hebben enkele kwaadwillende actoren het Eigenlayer X-account gehackt. Als gevolg hiervan adverteerden ze een nep EIGEN airdrop in een poging om van de gebruikers te stelen. In hun bericht hebben ze een link naar hun phishing-website opgenomen. Echter, zowel PeckShield, het blockchain-beveiligingsbedrijf, als Eigenlayer waren in staat om de hack op te merken. Hierdoor hebben ze de cryptogemeenschap op de hoogte gebracht van de ontwikkeling. Bovendien heeft Eigenlayer het bericht en de bijbehorende links binnen een korte periode verwijderd.</p>
<h2 id="h2-Veelgestelde20vragen20over20phishing20scams838629"><a name="Veelgestelde vragen over phishing scams" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over phishing scams</h2><h3 id="h3-Wat20is20er20gebeurd20met20het20Eigenlayer20Xaccount260951"><a name="Wat is er gebeurd met het Eigenlayer X-account?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is er gebeurd met het Eigenlayer X-account?</h3><p>Het Eigenlayer X-account werd gecompromitteerd door geavanceerde phishing-tactieken, wat leidde tot de verspreiding van scamlinks die verborgen zijn achter legitiem ogende voorbeeldafbeeldingen.</p>
<h3 id="h3-Hoe20hebben20hackers20scamlinks20verborgen20in20de20Eigenlayer20Xaccount20hack500658"><a name="Hoe hebben hackers scamlinks verborgen in de Eigenlayer X-account hack?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe hebben hackers scamlinks verborgen in de Eigenlayer X-account hack?</h3><p>Hackers hebben scamlinks verborgen door gebruik te maken van het ontwerp van het platform van X om een voorbeeldafbeelding van de legitieme Eigenlayer-website weer te geven, waardoor gebruikers worden misleid door de schijn van authenticiteit.</p>
<h3 id="h3-Wat20zijn20de20risicos20van20het20overnemen20van20sociale20mediaaccounts20in20de20cryptoruimte203367"><a name="Wat zijn de risico’s van het overnemen van sociale media-accounts in de cryptoruimte?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn de risico’s van het overnemen van sociale media-accounts in de cryptoruimte?</h3><p>Overnames van sociale media-accounts, zoals de hack van het Eigenlayer X-account, brengen aanzienlijke risico’s met zich mee, waaronder de verspreiding van phishing-scams, verlies van gebruikersvertrouwen en mogelijke financiële verliezen als gevolg van misleidende praktijken.</p>
<h3 id="h3-Hoe20wijdverbreid20zijn20phishing20scams20in20de20cryptocurrency20gemeenschap349399"><a name="Hoe wijdverbreid zijn phishing scams in de cryptocurrency gemeenschap?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe wijdverbreid zijn phishing scams in de cryptocurrency gemeenschap?</h3><p>Phishing scams zijn steeds vaker voorkomend in de cryptocurrency gemeenschap, waarbij misbruik wordt gemaakt van het vertrouwen dat gebruikers stellen in officiële kanalen om kwaadaardige inhoud te verspreiden en goedkeuringsphishing uit te voeren, wat heeft geleid tot miljarden aan verliezen sinds 2021.</p>
<h3 id="h3-Hoe20kunnen20gebruikers20zich20beschermen20tegen20phishingpogingen20op20platforms20zoals20X497214"><a name="Hoe kunnen gebruikers zich beschermen tegen phishingpogingen op platforms zoals X?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kunnen gebruikers zich beschermen tegen phishingpogingen op platforms zoals X?</h3><p>Gebruikers wordt geadviseerd informatie te verifiëren via meerdere kanalen, voorzichtig te zijn bij interactie met links en waakzaam te blijven voor tekenen van phishing, zoals misleidende previews of onverwachte verzoeken om informatie of goedkeuringen.</p>
<h3 id="h3-Hoe20kunnen20gebruikers20phishinglinks20op20sociale20mediaplatforms20identificeren20en20vermijden940368"><a name="Hoe kunnen gebruikers phishinglinks op sociale media-platforms identificeren en vermijden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe kunnen gebruikers phishinglinks op sociale media-platforms identificeren en vermijden?</h3><p>Gebruikers kunnen phishinglinks identificeren en vermijden door URL’s zorgvuldig te onderzoeken, het vermijden van het klikken op ongevraagde links, en het controleren van de authenticiteit van de berichtbron voordat ze zich bezighouden met enige inhoud.</p>
<h3 id="h3-Wat20zijn20goedkeuringsphishing20scams20en20wat20is20hun20impact20op20de20cryptoindustrie132898"><a name="Wat zijn goedkeuringsphishing scams en wat is hun impact op de crypto-industrie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn goedkeuringsphishing scams en wat is hun impact op de crypto-industrie?</h3><p>Goedkeuringsphishingoplichting misleidt slachtoffers om kwaadaardige transacties te ondertekenen, wat leidt tot ongeautoriseerde toegang en financiële verliezen. Dergelijke oplichting heeft een aanzienlijke impact gehad op de cryptobranche, met miljarden verloren sinds 2021.</p>
<h3 id="h3-Welke20recente20statistieken20benadrukken20de20ernst20van20hacks20in20de20cryptoruimte851144"><a name="Welke recente statistieken benadrukken de ernst van hacks in de cryptoruimte?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke recente statistieken benadrukken de ernst van hacks in de cryptoruimte?</h3><p>Recente statistieken van PeckShield melden meer dan 200 grote hacks in de cryptoruimte in de eerste helft van 2024 alleen, resulterend in ongeveer $1.56 miljard aan verliezen, waarvan slechts een fractie werd teruggevonden.</p>
<div class="blog-details-info"><br><div>Auteur: Mashell C., Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<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 zal er juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>