RGVlcCBGYWtlIEVsb24gTXVzayBpbm9uZGEgWW91VHViZSBkdXJhbnRlIGlsIGxhbmNpbyBkaSBTcGFjZVggbmVsbCdpbXBlbm5hdGEgZGVsbGUgdHJ1ZmZlIGluIGNyaXB0b3ZhbHV0ZQ==

2024-06-19, 07:44

<p><img src="https://gimg2.gateimg.com/image/article/17187827461690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR747770"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Di recente, alcuni truffatori hanno utilizzato la tecnologia deepfake per emulare la voce e l’azione di Elon Musk per indurre le persone a investire in un programma di truffa crittografica.</p>
<p>Gli scammer utilizzano l’intelligenza artificiale e l’apprendimento automatico per creare voci e modi di fare generati dall’AI di personaggi prominenti per promuovere truffe criptate.</p>
<p>Le organizzazioni dovrebbero educare il loro personale a rilevare e gestire i casi di deep fake.</p>
<h2 id="h2-Introduzione923820"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il progresso della tecnologia ha portato a rischi maggiori che mai. Ad esempio, alcuni attori malintenzionati stanno utilizzando l’intelligenza artificiale e tecnologie correlate per falsificare voci e azioni di personaggi di spicco per ingannare il loro pubblico e rubare i loro asset digitali. In particolare, questi attori malvagi falsificano notizie e video deepfake per ingannare gli investitori e truffarli. Questo articolo esamina come alcuni di questi attori malevoli hanno deepfaked Elon Musk su YouTube durante il lancio di SpaceX.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1325/elon-musk-is-accused-of-manipulating-dogecoin" target="_blank">Elon Musk è accusato di manipolare Dogecoin</a></p>
<h2 id="h2-La20truffa20si20svela2020Come20sono20comparsi20su20YouTube20oltre203520falsi20live20stream20di20Elon20Musk19620"><a name="La truffa si svela - Come sono comparsi su YouTube oltre 35 falsi live stream di Elon Musk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La truffa si svela - Come sono comparsi su YouTube oltre 35 falsi live stream di Elon Musk</h2><p>Il 6 giugno, alcuni truffatori hanno inondato YouTube con video deepfake di Elon Musk nel tentativo di sfruttare gli investitori di criptovalute dei loro asset digitali durante il periodo di lancio di SpaceX. Durante l’evento di lancio del razzo Starship, i truffatori hanno trasmesso in diretta la voce generata dall’IA di Musk su oltre 35 canali YouTube. Attraverso la diretta, hanno falsificato la voce e le maniere di Musk per attirare gli investitori verso un progetto di criptovaluta dove promettevano agli investitori di guadagnare il doppio delle somme investite.</p>
<p>Le riprese video mostravano come se Musk stesse parlando all’aperto presso SpaceX. Tuttavia, le sezioni sfocate delle riprese erano programmate in modo da nascondere la realtà della situazione. I flussi fraudolenti, che hanno coinciso con il lancio del quarto test di SpaceX, hanno trasmesso il razzo fino a un punto in cui stava entrando nell’atmosfera terrestre. Ha anche mostrato il momento in cui il razzo è precipitato nell’oceano Indiano come previsto.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/blockchain-inion-fraud-schemes-and-how-to-prevent-them/3092" target="_blank">Schemi di frode nell’iscrizione e come prevenirli</a></p>
<h2 id="h2-Identificazione20dei20flussi20falsi20tecnologia20Deepfake20utilizzata20per20imitare20laspetto20e20la20voce20di20Elon20Musk845616"><a name="Identificazione dei flussi falsi: tecnologia Deepfake utilizzata per imitare l’aspetto e la voce di Elon Musk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Identificazione dei flussi falsi: tecnologia Deepfake utilizzata per imitare l’aspetto e la voce di Elon Musk</h2><p>Gli imitatori hanno incorporato vari elementi per far credere al pubblico che fosse Elon Musk a parlare con loro. Secondo un <a href="https://cointelegraph.com/news/elon-musk-spacex-starship-launch-deep-fake-crypto-scams" rel="nofollow noopener noreferrer" target="_blank">La pubblicazione di Cointelegraph</a>, un canale YouTube si è mascherato da livestream truffa dell’account ufficiale di SpaceX e ha attirato più di 170.000 spettatori. Alcuni esperti ritengono che la maggior parte degli spettatori fossero semplicemente bot usati per convincere il pubblico che si trattava di un livestream legittimo. Questo impatto sugli spettatori era stato progettato per attirare investitori di criptovalute a investire nel progetto di investimento di Musk.</p>
<p>La voce generata dall’IA con somiglianza a Musk ha persuaso il pubblico a inviare diversi tipi di asset crittografici come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> o Ether agli indirizzi del portafoglio digitale citati. I creatori del video deepfake hanno fatto molto per convincere le persone che fosse effettivamente Musk a parlare. Ad esempio, hanno incluso il suo solito modo di fare e altri aspetti della sua voce naturale come balbettii e pause. Ciò è stato evidente quando <a href="https://cointelegraph.com/news/elon-musk-spacex-starship-launch-deep-fake-crypto-scams" rel="nofollow noopener noreferrer" target="_blank">la voce ha detto</a>, “Questo non è un falso, è un vero regalo. Te lo garantisco personalmente.” C’era anche un codice QR che gli investitori avrebbero scansionato per effettuare i loro depositi in criptovaluta.</p>
<p>La voce ha aggiunto: “Hai la possibilità di vedere la tua criptovaluta propellere in modo esponenziale mentre il nostro razzo si dirige verso le stelle.” Questa affermazione è stata seguita da un applauso della folla, anche se le voci erano false. Al momento non esiste un dato preciso sul numero di persone che sono state truffate tramite questa truffa su YouTube. Tuttavia, ci sono prove che alcune persone abbiano inviato la loro criptovaluta agli indirizzi indicati. Lo screenshot seguente mostra un individuo che ha inviato asset di criptovaluta per un valore di $30 a uno degli indirizzi dei truffatori.<br><img src="https://gimg2.gateimg.com/image/article/17187829151.jpg" alt=""><br>Origine: x.com</p>
<p>Tuttavia, i video sono stati successivamente rimossi e il canale è stato rebrandizzato per emulare il <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> Foundation. Mysk, un gruppo di ricerca, è stato il primo a lanciare l’allarme <a href="https://www.gate.io/learn/articles/top-10-crypto-scams-and-how-to-avoid-them/2556" target="_blank">comunità cripto della truffa delle criptovalute</a> come indica l’immagine successiva.<br><img src="https://gimg2.gateimg.com/image/article/17187829462.jpg" alt=""><br>Origine: x.com</p>
<p>Senza dubbio, Mysk ha aiutato la comunità crittografica a realizzare il pericolo in cui si trovava in quel momento. Tali avvisi di sicurezza online sono essenziali per preservare la dignità del settore degli asset digitali. Tuttavia, questa non è la prima volta che Musk è stato coinvolto in un simile scandalo. Gli truffatori mirano al miliardario delle criptovalute a causa del suo sostegno aperto alle criptovalute e del suo sostegno a diversi progetti criptografici come <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> e <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a>. Ad esempio, ad aprile Talal Haj Bakry e Tommy Mysk hanno identificato un altro account falso di SpaceX su YouTube con un messaggio simile, invitando gli investitori di criptovaluta a investire in un progetto truffaldino che promette di raddoppiare i soldi.</p>
<h2 id="h2-Implicazioni20pi20ampie20per20la20criptovaluta20e20la20sicurezza20online266675"><a name="Implicazioni più ampie per la criptovaluta e la sicurezza online" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicazioni più ampie per la criptovaluta e la sicurezza online</h2><p>Innanzitutto, è importante notare che i deepfake sfruttano potenti tecniche che utilizzano l’intelligenza artificiale e l’apprendimento automatico per manipolare contenuti audio e visivi al fine di ingannare determinate sezioni della comunità. Pertanto, il miglior modo per contrastare tali macchinazioni è utilizzare tecnologie simili per rilevare i deepfake e mitigare le minacce alla sicurezza informatica che rappresentano.</p>
<p>In altre parole, le organizzazioni, tra cui le aziende digitali, dovrebbero utilizzare tecnologie di apprendimento automatico e intelligenza artificiale per autenticare i contenuti visivi e audio che potrebbero considerare sospetti. Pertanto, le organizzazioni dovrebbero investire in soluzioni di apprendimento automatico pertinenti che sfruttino l’automazione per la rilevazione e la verifica della vivacità. Questo perché ciò che l’occhio umano potrebbe non vedere, i sistemi basati sull’apprendimento automatico possono rilevare.</p>
<p>In secondo luogo, le organizzazioni dovrebbero mettere in atto sistemi per gestire le emergenti minacce alla sicurezza informatica legate ai deepfake e all’impersonificazione. Come esempio, dovrebbero includere la consapevolezza dei deepfake come parte dei loro programmi educativi sulla sicurezza informatica. In altre parole, dovrebbero addestrare il loro personale a tutti i livelli dell’organizzazione per identificare i contenuti deepfake e rispondere adeguatamente.</p>
<p>Infine, è essenziale che le organizzazioni che operano nel settore digitale trovino il modo di comunicare tra di loro quando si verificano incidenti deepfake. Dovrebbero anche collaborare con le forze dell’ordine per gestire tali casi.</p>
<h2 id="h2-Conclusion812325"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>I casi di deepfake stanno aumentando nell’industria digitale, in particolare nel settore delle criptovalute. Di recente, alcuni truffatori cripto si sono fatti passare per Elon Musk per ingannare alcuni investitori. <a href="https://www.gate.io/blog_detail/2594/avoiding-crypto-scams-5-red-flags-to-watch-out-for" target="_blank">mettere i loro fondi in una truffa di criptovaluta</a>. Tuttavia, organizzazioni di allarme come Mysk sono riuscite a rilevare quella minaccia alla sicurezza informatica. In futuro, le organizzazioni del settore digitale dovrebbero educare il loro personale su come rilevare e gestire i casi di deepfake.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>