SGV0IFR3aXR0ZXItYWNjb3VudCB2YW4gT3BlbkFJIENUTyB3ZXJkIGdlYnJ1aWt0IGluIGVlbiBwaGlzaGluZ2FhbnZhbCBvbSBvcGxpY2h0ZXJpaiBtZXQgY3J5cHRvLXRva2VucyB0ZSBwcm9tb3Rlbg==

2023-06-14, 03:24

<p><img src="https://gimg2.gateimg.com/image/article/1684401663RDZZ.jpeg" alt=""><br>Op 1 juni hebben sommige aanvallers het Twitter-account van de CTO van OpenAI gecompromitteerd en een nepcryptocurrency genaamd OPENAI-token gepromoot.</p>
<p>Er waren 83 retweets van de post en meer dan 800.000 weergaven.</p>
<p>MetaMask, Robinhood en Sandbox zijn voorbeelden van top crypto projecten die onlangs phishingaanvallen hebben ervaren.</p>
<p>Trefwoorden: Crypto phishing, scam crypto, phishingaanvallen, crypto oplichters, OpenAi, AI-platform, aanval e-mails, crypto airdrop</p>
<h2 id="h2-Kennismaking120889"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Sommige technologische innovaties die veel voordelen met zich meebrengen, kunnen ook leiden tot nieuwe vormen van criminele activiteiten die de cryptobranche beïnvloeden. In sommige glen maken criminelen misbruik van de sociale media-accounts van bekende personen om misdaden te plegen.</p>
<p>Onlangs hebben kwaadwillende personen sociale media-accounts van prominente zakenmensen gehackt en informatie doorgegeven die veel onschuldige mensen misleidt. In dit artikel bespreken we hoe sommige kwaadaardige actoren het Twitter-account van OpenAi’s CTO Mira Murati hebben gehackt om een ​​crypto-zwendel te promoten.</p>
<h2 id="h2-Het20Twitteraccount20van20Mira20Murati20is20gehackt20en20gebruikt20in20een20phishingaanval924185"><a name="Het Twitter-account van Mira Murati is gehackt en gebruikt in een phishingaanval" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het Twitter-account van Mira Murati is gehackt en gebruikt in een phishingaanval</h2><p>Op 1 juni hebben enkele oplichters een Twitter-account van OpenAI CTO Mira Murati gehackt om een scam crypto genaamd OPENAI-token te promoten. De fraudeurs beweerden dat OpenAI, het bedrijf achter ChatGPT - de populaire AI-tool - zijn token weggaf via een crypto airdrop.<br><img src="https://gimg2.gateimg.com/image/article/16867128161.png" alt=""><br>Mira Murati, OpenAI CTO - Invibrantcompany</p>
<p>De aanvallers hebben een phishingaanval geleverd <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> voor de zogenaamde airdrop die een uur lang op het Twitter-account bleef staan. Opmerkelijk is dat er een token genaamd OpenAI ERC is dat behoort tot een gratis te gebruiken telegram-bot waarmee gebruikers toegang hebben tot DALL-E en ChapGPT via chatcommando’s.</p>
<p>Binnen korte tijd nadat het was geplaatst, kreeg de tweet veel aandacht met 83 retweets en meer dan 800.000 weergaven. Desondanks konden mensen niet reageren op de tweet omdat niemand dat mocht doen. De oplichters hadden het account moeten beperken om te voorkomen dat leden van de gemeenschap anderen waarschuwen voor hun slechte bedoelingen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2594/avoiding-crypto-scams-5-red-flags-to-watch-out-for" target="_blank">Het vermijden van Crypto Scams: 5 rode vlaggen om op te letten</a></p>
<p>Beosin, een specialist bij een Blockchain-beveiligingsbedrijf, vertelde aan Cointelegraph dat de oplichters een crypto wallet-drainage kit hadden moeten gebruiken die digitale activa zoals NFT’s en ERC20-tokens van elke portemonnee zou kunnen leeghalen die ermee zou verbinden via de verstrekte link. Desalniettemin is er op het moment van schrijven geen bevestiging dat een persoon slachtoffer is geworden van de oplichting. Bovendien is er geen definitieve informatie over hoe de hack heeft plaatsgevonden. Sommige analisten geloven echter dat Murati slachtoffer zou zijn geweest van een sim-swapping aanval.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2148/how-not-to-fall-for-nft-scams" target="_blank">Hoe je niet in de val van NFT Scams trapt</a></p>
<h2 id="h2-Waarom20zouden20de20crypto20oplichters20zich20richten20op20Mira20Murati890857"><a name="Waarom zouden de crypto oplichters zich richten op Mira Murati?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom zouden de crypto oplichters zich richten op Mira Murati?</h2><p>De oplichters wilden dat mensen geloofden dat de zogenaamde airdrop echt was, omdat deze werd geadverteerd via het Twitter-account van de CTO van OpenAi. Ten tweede had Murai een grote aanhang van meer dan 126.000 leden, wat de kans vergrootte dat mensen ten prooi zouden vallen aan het aas.</p>
<h2 id="h2-Hoe20probeerden20de20oplichters20de20nietsvermoedende20crypto20liefhebbers20te20bedriegen3039"><a name="Hoe probeerden de oplichters de nietsvermoedende crypto liefhebbers te bedriegen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe probeerden de oplichters de nietsvermoedende crypto liefhebbers te bedriegen?</h2><p>De oplichters gebruikten verschillende middelen om de Twittergebruikers ervan te overtuigen dat OpenAi een echte airdrop aanbood. Om mensen over te halen om het op te eisen, beschreven ze de cryptocurrency als een AI-token, een categorie van een van de meest trending cryptocurrencies. Het bericht luidde: “<br><strong>Een baanbrekende token gedreven door op kunstmatige intelligentie gebaseerde taalmodellen.</strong>”</p>
<p>Meteen is alles wat te maken heeft met kunstmatige intelligentie aantrekkelijk voor veel mensen, inclusief investeerders. Het is dan ook niet verwonderlijk dat oplichters op die manier hebben geprobeerd mensen te bedriegen.</p>
<p>Bovendien leek de website waarnaar de oplichters de Twitter-gebruikers stuurden bijna hetzelfde als die van OpenAI, tot op het punt dat het voor iemand erg moeilijk zou zijn geweest om het verschil te zien. Het belangrijkste verschil was de functie om crypto-portefeuilles te verbinden.</p>
<h2 id="h2-De20opkomst20van20kunstmatige20intelligentie20in20oplichtingsactiviteiten9760"><a name="De opkomst van kunstmatige intelligentie in oplichtingsactiviteiten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De opkomst van kunstmatige intelligentie in oplichtingsactiviteiten</h2><p>Er is een toename geweest van incidenten van phishing scams op verschillende sociale media platforms, waaronder Facebook en Twitter. In dat opzicht hebben beveiligingsexperts internetgebruikers gewaarschuwd voor het gevaar van scams als gevolg van AI-platforms zoals ChatGPT, die geavanceerde aanval e-mails kunnen genereren.</p>
<p>Onlangs heeft het California Department of Financial Protection and Innovation (DFPI) mensen gewaarschuwd dat AI-beleggingszwendel die beweert snel en gemakkelijk geld te genereren voor investeerders in opkomst is. Sommige oplichters vertellen mensen dat ze AI-handelsrobots hebben die namens hen kunnen handelen.</p>
<p>In deze context zei Jeff Greene, directeur voor cybersecurity bij Aspen Digital, dat als gevolg van AI de phishing-e-mails zullen worden afgestemd op de eisen van individuen en een betere taal zullen hebben wat betreft grammatica en leesbaarheid.</p>
<h2 id="h2-Recente20phishingaanvallen213076"><a name="Recente phishingaanvallen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recente phishingaanvallen</h2><p>Het aantal phishingaanvallen is sinds het begin van dit jaar opmerkelijk toegenomen. Een van de opvallende scam-aanvallen was gericht tegen Robinhood. In januari gebruikten enkele slechte acteurs de socialemediaplatforms van Robinhood om een scam crypto te adverteren.</p>
<p>Ook de digitale portemonnee van de <a href="https://www.gate.io/price/moonbirds-nft-index-by-mexc-nmoon/ngn" target="_blank">Moonbirds NFT-collectie</a> Creators is gehackt met behulp van phishing-aanvallen. Daarnaast hebben hackers een computer van een Sandbox-medewerker geschonden en phishing-e-mails gestuurd naar Sandbox metaverse-gebruikers. Helaas <a href="https://www.gate.io/learn/articles/what-is-metamask/28" target="_blank">MetaMask</a> was een andere slachtoffer van soortgelijke kwaadaardige aanvallen. Een kwaadaardige acteur heeft zijn server gecompromitteerd en e-mails naar de gebruikers gestuurd waarin ze hun KYC-gegevens vroegen.</p>
<p>De bovenstaande voorbeelden van phishingaanvallen laten zien hoe serieus het probleem is. Helaas zal het ernstiger worden naarmate veel oplichters AI gaan gebruiken om hun doelwitten aan te vallen.</p>
<h2 id="h2-Conclusie34011"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Kwaadwillende acteurs hebben het Twitter-account van de CTO van OpenAI, Mira Murati, gecompromitteerd en een oplichterij met crypto gepromoot. Er is echter nog geen bevestiging geweest dat iemand zijn/haar waardevolle digitale activa heeft verloren. Eerder dit jaar waren verschillende cryptoprojecten zoals Sandbox, Robinhood en MetaMask onderwerp van kwaadaardige aanvallen.</p>
<h3 id="h3-Wat20is20een20phishingaanval417535"><a name="Wat is een phishingaanval?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een phishingaanval?</h3><p>Een phishingaanval <a href="https://www.gate.io/blog_detail/1342/what-are-the-most-common-types-of-nft-scams" target="_blank">is een soort crypto-zwendel</a> waar slechte acteurs de slachtoffers misleiden om hen hun persoonlijke informatie zoals privésleutels of zaadzinnen te geven. De aanvallers doen alsof ze zeer eerlijk en betrouwbaar zijn. Hun belangrijkste motief is echter om de digitale activa van de slachtoffers te stelen, zoals NFT’s en cryptocurrencies.</p>
<h3 id="h3-Hoe20cryptoactiva20veilig20te20houden480119"><a name="Hoe crypto-activa veilig te houden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe crypto-activa veilig te houden?</h3><p>Cryptoinvesteerders kunnen hun cryptocurrencies veilig bewaren op gevestigde en veilige beurzen zoals Gate.io. Bovendien heeft Gate.io verzekering voor de digitale activa en bewijs van reserves.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Onderzoeker bij Gate.io<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>