RGVlcCBGYWtlIEVsb24gTXVzayBvdmVyc3BvZWx0IFlvdVR1YmUgdGlqZGVucyBTcGFjZVgtbGFuY2VyaW5nIGluIENyeXB0byBTY2FtIFN1cmdl

2024-06-19, 07:44

<p><img src="https://gimg2.gateimg.com/image/article/17187827461690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR593501"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Onlangs hebben sommige oplichters gebruik gemaakt van deepfake-technologie om de stem en acties van Elon Musk na te bootsen om mensen te misleiden om te investeren in een crypto-zwendelprogramma.</p>
<p>Oplichters gebruiken kunstmatige intelligentie en machine learning om ai-gegenereerde stemmen en manieren van prominente personen te creëren om cryptozwendel te promoten.</p>
<p>Organisaties moeten hun personeel voorlichten over het detecteren en afhandelen van deepfake glen.</p>
<h2 id="h2-Kennismaking360072"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>De vooruitgang in technologie heeft grotere risico’s met zich meegebracht dan ooit tevoren. Zo gebruiken sommige kwaadwillende actoren kunstmatige intelligentie en gerelateerde technologieën om stemmen en acties van prominente personen na te bootsen om hun publiek te misleiden en hun digitale activa te stelen. In het bijzonder maken deze slechte acteurs nepnieuws en deepfake video’s om investeerders te misleiden en op te lichten. Dit artikel bekijkt hoe sommige van deze kwaadwillende acteurs Elon Musk deepfake’ten op YouTube tijdens de lancering van SpaceX.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1325/elon-musk-is-accused-of-manipulating-dogecoin" target="_blank">Elon Musk wordt beschuldigd van het manipuleren van Dogecoin</a></p>
<h2 id="h2-Het20bedrog20ontvouwt20zich2020Hoe20meer20dan203520nepElon20Musk20livestreams20verschenen20op20YouTube77754"><a name="Het bedrog ontvouwt zich - Hoe meer dan 35 nep-Elon Musk livestreams verschenen op YouTube" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het bedrog ontvouwt zich - Hoe meer dan 35 nep-Elon Musk livestreams verschenen op YouTube</h2><p>Op 6 juni hebben enkele oplichters YouTube overspoeld met deepfake-video’s van Elon Musk in een poging om crypto-investeerders van hun digitale activa te misbruiken tijdens de SpaceX-lanceringsperiode. Tijdens het evenement van de lancering van de Starship-raket hebben de oplichters de AI-gegenereerde stem van Musk live gestreamd op meer dan 35 YouTube-kanalen. Via de livestream hebben ze de stem en maniertjes van Musk nagemaakt om investeerders te lokken naar een crypto-project waar ze beloofden dat investeerders hun geïnvesteerde bedragen zouden verdubbelen.</p>
<p>De videobeelden toonden alsof Musk buiten bij SpaceX aan het praten was. Echter, de beelden hadden vervaagde secties die opzettelijk geprogrammeerd waren om de werkelijkheid van de situatie te verbergen. De frauduleuze streams die samenvielen met de lancering van de vierde test van SpaceX zonden de raket uit naar een punt waar hij de atmosfeer van de aarde binnenging. Het toonde ook het moment waarop de raket in de Indische Oceaan dook, zoals gepland.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/blockchain-inion-fraud-schemes-and-how-to-prevent-them/3092" target="_blank">Iniefraudeplannen en hoe ze te voorkomen</a></p>
<h2 id="h2-Het20identificeren20van20de20valse20streams20Deepfaketechnologie20gebruikt20om20de20uitstraling20en20stem20van20Elon20Musk20na20te20bootsen554890"><a name="Het identificeren van de valse streams: Deepfake-technologie gebruikt om de uitstraling en stem van Elon Musk na te bootsen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het identificeren van de valse streams: Deepfake-technologie gebruikt om de uitstraling en stem van Elon Musk na te bootsen</h2><p>De imitators hebben verschillende elementen opgenomen om het publiek te laten geloven dat het Elon Musk was die met hen sprak. Volgens een <a href="https://cointelegraph.com/news/elon-musk-spacex-starship-launch-deep-fake-crypto-scams" rel="nofollow noopener noreferrer" target="_blank">Publicatie van Cointelegraph</a>, een YouTube-kanaal dat zich voordeed als de officiële account van SpaceX, had meer dan 170.000 kijkers bij de scam-livestream. Sommige experts geloven dat de meeste zogenaamde kijkers slechts bots waren die werden gebruikt om het publiek te overtuigen dat het een legitieme livestream was. Deze kijkersimpact was bedoeld om crypto-investeerders te lokken om te investeren in Musks vermeende investeringsproject.</p>
<p>De door AI gegenereerde stem met de gelijkenis van Musk overtuigde het publiek om verschillende soorten crypto-activa te sturen, zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> of Ether naar de genoemde digitale portefeuilleadressen te sturen. De makers van de deepfake-video hebben veel moeite gedaan om mensen te overtuigen dat het inderdaad Musk was die sprak. Zo hebben ze zijn gebruikelijke maniertjes en andere aspecten van zijn natuurlijke stem, zoals haperingen en pauzes, opgenomen. Dat werd duidelijk toen <a href="https://cointelegraph.com/news/elon-musk-spacex-starship-launch-deep-fake-crypto-scams" rel="nofollow noopener noreferrer" target="_blank">de stem zei</a>, “Dit is geen nep, dit is een echte weggeefactie. Ik garandeer het persoonlijk aan jou.” Er was ook een QR-code die de investeerders zouden scannen om hun crypto-deposito’s te maken.</p>
<p>De stem voegde eraan toe: ‘Je hebt de kans om je crypto exponentieel te zien groeien terwijl onze raket naar de sterren stijgt.’ Deze verklaring werd gevolgd door een applaudisserend publiek, waarvan de stemmen ook nep waren. Op dit moment is er geen juist aantal mensen bekend die via die YouTube-zwendel zijn opgelicht. Er is echter bewijs dat sommige mensen hun cryptocurrency naar de genoemde adressen hebben gestuurd. De volgende screenshot toont een persoon die crypto-activa ter waarde van $30 naar een van de portefeuilles van de oplichters heeft gestuurd.<br><img src="https://gimg2.gateimg.com/image/article/17187829151.jpg" alt=""><br>Bron: x.com</p>
<p>De video streams werden echter later verwijderd en het kanaal werd opnieuw gemerkt om te emuleren. <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> Foundation. Mysk, een onderzoeksgroep, was de eerste die waarschuwde voor de <a href="https://www.gate.io/learn/articles/top-10-crypto-scams-and-how-to-avoid-them/2556" target="_blank">cryptogemeenschap van de cryptocurrency-zwendel</a> zoals blijkt uit de volgende afbeelding.<br><img src="https://gimg2.gateimg.com/image/article/17187829462.jpg" alt=""><br>Bron: x.com</p>
<p>Zonder twijfel heeft Mysk de cryptogemeenschap geholpen om zich bewust te worden van het gevaar waarin ze destijds verkeerde. Dergelijke online beveiligingswaarschuwingen zijn essentieel om de waardigheid van de digitale activasector te behouden. Dit is echter niet de eerste keer dat Musk verstrikt raakte in zo’n oplichterij. De oplichters richten zich op de cryptomiljardair vanwege zijn openlijke steun voor cryptocurrencies en zijn goedkeuring van verschillende cryptoprojecten zoals <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> en <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> Bijvoorbeeld identificeerden Talal Haj Bakry en Tommy Mysk in april een ander nep-SpaceX YouTube-account met een soortgelijke boodschap, waarin cryptoinvesteerders worden uitgenodigd om te investeren in een dubbel-uw-geld-oplichtingsproject.</p>
<h2 id="h2-Ruimere20implicaties20voor20crypto20en20online20beveiliging502925"><a name="Ruimere implicaties voor crypto en online beveiliging" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ruimere implicaties voor crypto en online beveiliging</h2><p>Het is allereerst belangrijk om op te merken dat deepfakes krachtige technieken gebruiken die kunstmatige intelligentie en machine learning benutten om audio- en visuele inhoud te manipuleren om bepaalde delen van de gemeenschap te misleiden. Daarom is de beste manier om dergelijke manipulaties tegen te gaan, het gebruik van vergelijkbare technologieën om deepfakes te detecteren en de cybersecurity-bedreigingen die ze vormen te beperken.</p>
<p>Met andere woorden zouden organisaties, waaronder digitale bedrijven, machine learning- en kunstmatige intelligentietechnologieën moeten gebruiken om visuele en auditieve inhoud te authenticeren die zij als verdacht beschouwen. Daarom zouden organisaties moeten investeren in relevante machine learning-oplossingen die automatisering benutten voor levensdetectie en verificatie. Dit komt doordat wat het menselijk oog kan missen, machine learning-gebaseerde en kunnen detecteren.</p>
<p>Ten tweede moeten organisaties en implementeren om opkomende cybersecurityrisico’s met betrekking tot deepfakes en impersonification aan te pakken. Als voorbeeld zouden ze deepfake-bewustzijn moeten opnemen als onderdeel van hun educatieve cybersecurityprogramma’s voor de organisatie. Met andere woorden, ze zouden hun personeel op alle niveaus in de organisatie moeten trainen om deepfake-content te identificeren en hier gepast op te reageren.</p>
<p>Ten slotte is het essentieel voor organisaties die actief zijn in de digitale sector om middelen te bedenken om met elkaar te communiceren wanneer deepfake-incidenten zich voordoen. Ze zouden ook moeten samenwerken met wetshandhavingsorganisaties om dergelijke glen af te handelen.</p>
<h2 id="h2-Conclusie904111"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Het aantal glen van deepfake neemt toe in de digitale industrie, vooral in de cryptocurrencysector. Onlangs hebben sommige crypto-oplichters zich voorgedaan als Elon Musk om enkele investeerders te misleiden. <a href="https://www.gate.io/blog_detail/2594/avoiding-crypto-scams-5-red-flags-to-watch-out-for" target="_blank">hun geld in een cryptocurrency oplichting steken</a>. Echter, waakzame organisaties zoals Mysk waren in staat om die cybersecuritydreiging te detecteren. In de toekomst zouden organisaties in de digitale sector hun personeel moeten voorlichten over hoe ze deepfake glen kunnen detecteren en aanpakken.</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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>