Q29tZSBwcmV2ZW5pcmUgbGUgdHJ1ZmZlIHN1bGxlIGZyYXNpIHNlZWQgbmVsIDIwMjU=

2022-06-16, 03:21

<p><img src="https://gimg2.gateimg.com/image/sec202506041904565618572612.jpg" alt="">
</p><p>Nel 2025, tecniche complesse di phishing e ingegneria sociale guidate dall’IA prendono sempre più di mira i portafogli crypto, con un aumento degli attacchi del 47%. Le nuove misure protettive includono la verifica biometrica, frasi seed resistenti al quantum e soluzioni di identità decentralizzata che offrono opzioni di recupero senza seed attraverso reti fidate, aiutando gli utenti a proteggere i propri beni digitali in un panorama di minacce in continua evoluzione.</p>
<h2 id="h2-Ultimi20sviluppi20nella20protezione20delle20frasi20seed20nel202025744570"><a name="Ultimi sviluppi nella protezione delle frasi seed nel 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultimi sviluppi nella protezione delle frasi seed nel 2025</h2><p>Nel 2025, le truffe legate alle frasi seed sono notevolmente evolute con tecnologie più sofisticate. I dati mostrano che i tentativi di phishing guidati dall’IA mirati ai portafogli di criptovalute sono aumentati del 47% rispetto all’anno scorso.</p>
<p>Sviluppo principale:</p>
<ul>
<li>La verifica biometrica è diventata lo standard per l’accesso ai portafogli, con il 78% delle principali piattaforme che implementano questa funzione.</li><li>I principali portafogli hardware ora utilizzano frasi seed resistenti al quantum.</li><li>Le piattaforme di social media hanno implementato un sistema di rilevamento automatico in grado di identificare potenziali truffe legate a parole chiave con un tasso di precisione dell’89%.</li></ul>
<p>Tecnologie di protezione emergenti:</p>
<table>
<thead>
<tr>
<th>Tecnologia</th>
<th>Tasso di adozione</th>
<th>validità</th>
</tr>
</thead>
<tbody>
<tr>
<td>Recupero Multisig</td>
<td>63%</td>
<td>Alto</td>
</tr>
<tr>
<td>Sharding della Chiave Distribuita</td>
<td>41%</td>
<td>Molto alto</td>
</tr>
<tr>
<td>Recupero del Blocco Temporale</td>
<td>37%</td>
<td>Medio</td>
</tr>
</tbody>
</table>
<p>L’emergere delle soluzioni di identità decentralizzate offre un’alternativa ai tradizionali sistemi di frase seme, con il 31% dei nuovi portafogli che forniscono opzioni di recupero senza seme attraverso reti di contatti fidati.</p>
<p>Le misure di sicurezza della piattaforma ora includono l’analisi comportamentale per rilevare tentativi di recupero anomali, proteggendo ulteriormente gli utenti da attacchi complessi di ingegneria sociale.</p>
<p>Con l’evoluzione della protezione della frase seme, rimanere consapevoli di questi sviluppi è cruciale per proteggere gli asset digitali nell’ecosistema crittografico sempre più complesso del 2025.</p>
<h2 id="h2-Come20proteggersi20dalle20truffe20sulle20frasi20di20recupero196680"><a name="Come proteggersi dalle truffe sulle frasi di recupero" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come proteggersi dalle truffe sulle frasi di recupero</h2><p>I truffatori stanno utilizzando diverse forme di tecniche di ingegneria sociale per rubare le frasi seed, portando le persone a perdere i loro asset digitali.</p>
<ul>
<li>Le truffe relative alle frasi seed coinvolgono varie tecniche per indurre le vittime a rivelare le proprie frasi seed, compromettendo i portafogli che contengono i loro beni digitali.</li><li>Un comune schema di frode con la frase seme è il phishing, in cui gli attaccanti creano un senso di urgenza, chiedendo all’obiettivo di inviare la propria frase seme su un sito di phishing o tramite un modulo.</li><li>La frase seme è la chiave universale per un portafoglio di criptovalute, e rivelare la frase seme espone il detentore al rischio di perdere fondi, che sono irrevocabili.</li><li>Alcune linee guida per prevenire le truffe sulle frasi seed includono: conservare la frase seed in un luogo sicuro, suddividerla in più parti e conservare ciascuna parte in una posizione diversa, crittografarla quando è memorizzata online e non cercare supporto se non nelle applicazioni in cui è necessario aiuto.</li><li>Devono essere adottate misure per evitare di esporre accidentalmente la frase seme in nome della protezione, poiché ciò comporterebbe la perdita dell’accesso al portafoglio e ai fondi in esso contenuti.</li></ul>
<p>Lo spazio delle password è un corpo d’acqua turbolento che richiede cautela e attenzione. In questo regno, agli individui viene concessa un’immensa potenza per prendere il controllo delle proprie finanze, inclusa la sicurezza dei fondi senza fare affidamento su banche o istituzioni. Più dai a qualcuno, più vorrai da loro!</p>
<p>Il vault per la conservazione dei fondi in criptovaluta è chiamato wallet, che ha una chiave principale che fornisce accesso ad esso e può essere utilizzata per il recupero. Questa chiave principale è chiamata frase seed. Recentemente, c’è stata un’aumento delle truffe mirate alle frasi seed.</p>
<p>Una frase seed è un insieme di 12-24 parole generate da un algoritmo fornite durante la configurazione di un wallet, che funge da meccanismo di backup.</p>
<p>Quando si trasferisce un wallet da un dispositivo a un altro, o dopo che un dispositivo è stato perso, sarà necessaria una frase seme per ripristinare il wallet, e un’unica seme può servire a recuperare l’intera combinazione di token e monete.</p>
<p>Pertanto, per sfruttare le vulnerabilità, hanno ideato diversi trucchi volti a convincere le persone a rivelare le loro frasi seed.</p>
<h2 id="h2-Tattiche20di20truffa20con20frase20seed860784"><a name="Tattiche di truffa con frase seed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tattiche di truffa con frase seed</h2><p>Un poeta classico una volta disse: “So che il male non è per farlo, ma per non cadere nel male.” Un modo per guidare la prevenzione delle truffe sulle frasi seed è comprendere le diverse tattiche che i truffatori usano per ottenere le frasi seed dalle persone.</p>
<p>Nel maggio dello scorso anno, il popolare wallet di criptovalute Metamask ha emesso un avviso su un bot utilizzato per rubare frasi seed su Twitter. Lo schema fraudolento si è manifestato sotto forma di richieste inviate da quello che sembrava essere un account legittimo.</p>
<p>La dichiarazione suggerisce di compilare un modulo di supporto e richiede la fornitura di un <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">segreto</a> frase di recupero. Questo è uno dei diversi modi in cui i truffatori cercano di ottenere e prosciugare i portafogli delle persone acquisendo le loro frasi seed.</p>
<h2 id="h2-Le20attuali20tecniche20di20truffa20popolari20per20rubare20frasi20seed20includono675174"><a name="Le attuali tecniche di truffa popolari per rubare frasi seed includono:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le attuali tecniche di truffa popolari per rubare frasi seed includono:</h2><h3 id="h3-120Phishing20Quando20si20parla20della20sicurezza20e20della20protezione20dello20spazio20cibernetico20il20phishing20non2020un20concetto20nuovo146325"><a name="1. Phishing: Quando si parla della sicurezza e della protezione dello spazio cibernetico, il phishing non è un concetto nuovo." class="reference-link"></a><span class="header-link octicon octicon-link"></span>1. Phishing: Quando si parla della sicurezza e della protezione dello spazio cibernetico, il phishing non è un concetto nuovo.</h3><p>I truffatori attirano le persone a rivelare le loro frasi seed facendole inserire su un sito web sospetto, che è il metodo più importante.</p>
<p>Comporta ingannare le persone per rivelare le proprie password o dettagli identificabili personalmente creando un senso di urgenza, in questo caso, le loro frasi seed, per ottenere accesso ai loro portafogli.</p>
<p>Alcuni scam di phishing appaiono sotto forma di annunci pop-up che <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">collegamento</a> a un sito web di phishing o un’estensione del browser, che imita portafogli popolari come Exodus e Metamask.</p>
<p>In un attacco di truffa informatica, Domenic Iacovone ha perso beni del valore di $65.000. Un truffatore travestito da rappresentante del servizio clienti Apple ha chiamato la vittima dicendo che il suo account Apple era stato hackerato, affermando che avrebbe inviato una password al telefono per verificare che la vittima fosse il proprietario dell’account. Dopo aver ottenuto il telefono con questo trucco, l’hacker ha ulteriormente accesso alla frase seed tramite il backup di iCloud e ha svuotato il portafoglio in pochi secondi.</p>
<p>Un attacco informatico tipico ancora utilizzato dai truffatori è il phishing mirato. In questo caso, l’attaccante utilizza email o messaggi personalizzati per colpire individui, fingendo di essere un mittente fidato, come un fornitore di wallet hardware, e li invita ad aggiornare la loro frase seed. Chiunque cada nel loro inganno avrà il proprio wallet compromesso.</p>
<h3 id="h3-220Baiting20Il20baiting2020unaltra20tecnica20di20truffa20in20cui20gli20aggressori20utilizzano20questo20metodo20per20rubare20le20frasi20seed461701"><a name="2. Baiting. Il baiting è un’altra tecnica di truffa in cui gli aggressori utilizzano questo metodo per rubare le frasi seed." class="reference-link"></a><span class="header-link octicon octicon-link"></span>2. Baiting. Il baiting è un’altra tecnica di truffa in cui gli aggressori utilizzano questo metodo per rubare le frasi seed.</h3><p>Durante il processo di inganno, i truffatori attirano le persone a fornire le proprie credenziali di accesso promettendo di consegnare beni o articoli, come airdrop, omaggi o collezionabili digitali.</p>
<p>Alcune persone chiedono anche ai loro obiettivi di inserire una data frase segreta nei loro portafogli come esca per ottenere accesso ai loro fondi. La distribuzione di ricompense è un incentivo comune per costruire comunità di criptovalute.</p>
<p>I truffatori spesso usano la scusa di distribuire bonus come parte del lancio del progetto per ingannare le persone a cedere le loro frasi seed, compromettendo così i loro portafogli.</p>
<p>Molte persone vedono gli airdrop e altri omaggi come un’opportunità per acquisire alcuni asset digitali, trascurando possibilmente di verificare l’autenticità dell’intero schema.</p>
<p>Una comune truffa di esca che sta diventando popolare coinvolge alcuni individui senza scrupoli che rivelano le loro frasi seed online, fingendo che sia accidentale. Alcune persone ignare verranno attratte a inserire le loro frasi seed nei loro portafogli per ottenere fondi.</p>
<p>Questo permetterà ai truffatori di accedere al portafoglio, con conseguente prelievo di tutti i fondi dal portafoglio, inclusi i fondi precedentemente detenuti e i fondi che il titolare del portafoglio è stato ingannato a fornire.</p>
<h3 id="h3-3320Quid20pro20quo20Lo20scambio20equivalente2020molto20simile20alla20frode20La20condizione20di20scambio20si20basa20su20un20impegno20a20fornire20i20servizi20di20cui20la20vittima20potrebbe20avere20bisogno20in20cambio20delle20informazioni20di20accesso116635"><a name="3.3. Quid pro quo. Lo scambio equivalente è molto simile alla frode. La condizione di scambio si basa su un impegno a fornire i servizi di cui la vittima potrebbe avere bisogno in cambio delle informazioni di accesso." class="reference-link"></a><span class="header-link octicon octicon-link"></span>3.3. Quid pro quo. Lo scambio equivalente è molto simile alla frode. La condizione di scambio si basa su un impegno a fornire i servizi di cui la vittima potrebbe avere bisogno in cambio delle informazioni di accesso.</h3><p>I benefici promessi sotto le condizioni di scambio sono spesso sotto forma di servizi, come l’aggiornamento di un sistema, mentre nel caso di inganno, assumono principalmente la forma di beni. Il caso di Dominic Iacovone rientra in un sottoinsieme di attacchi di phishing legati alle condizioni di scambio.</p>
<h2 id="h2-Come20difendersi20dalle20truffe20sui20seed20phrase153093"><a name="Come difendersi dalle truffe sui seed phrase" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come difendersi dalle truffe sui seed phrase</h2><p>I portafogli possono essere memorizzati online, noti come portafogli caldi, o offline in hardware fisico, noti come portafogli freddi. I portafogli caldi sono più suscettibili agli attacchi informatici.<br>Indipendentemente dalla situazione, dovrebbero essere adottate precauzioni per guidare le persone nella prevenzione delle truffe sulle frasi di recupero. A differenza dei sistemi finanziari tradizionali, le transazioni nello spazio crypto sono guidate dalla blockchain e sono irreversibili.<br>Una volta che qualcuno accede al tuo portafoglio e lo svuota, non ci sarà modo di annullare la transazione, rendendo queste misure molto importanti.
</p><p>Conserva la tua frase seme in un luogo sicuro, preferibilmente scrivendola da qualche parte. Se devi conservarla online, memorizza una versione crittografata.</p>
<ol>
<li>Quando si trattiene le frasi mnemoniche, viene utilizzato un metodo di sharding, che prevede di suddividere le frasi mnemoniche in più segmenti e di conservarli in diverse posizioni.</li><li>Evita di inserire frasi mnemoniche strane nel tuo portafoglio, poiché potrebbe essere un’esca da parte dei truffatori.</li><li>Evita di cercare supporto a caso su applicazioni o social media; se devi chiedere aiuto, fallo solo all’interno dell’applicazione in cui hai bisogno di assistenza.</li><li>Le mnemoniche sono necessarie solo in rari casi; pertanto, non inserire mai la tua frase mnemonica online in alcuna forma per alcuna promessa.</li><li>Se stai utilizzando un dispositivo che scrive automaticamente la frase mnemonica nel backup cloud (come Apple), puoi andare nelle impostazioni “Gestisci spazio di archiviazione” e disattivare la funzione di backup.</li><li>Verifica sempre la legittimità del mittente e fai attenzione quando sei costretto a prendere misure urgenti che comportano la fornitura del tuo mnemonico.</li><li>Abilita l’autenticazione a due fattori ed evita le reti Wi-Fi aperte, specialmente quando interagisci con il tuo portafoglio.</li><li>Le organizzazioni dovrebbero fornire una formazione adeguata ai dipendenti per aumentare la consapevolezza e la segnalazione.</li><li>Quando si gestisce il sito web, si prega di controllare l’URL per assicurarsi che il certificato del sito sia fidato e di prestare attenzione agli avvisi che indicano che la connessione al sito non è sicura.</li></ol>
<p>Una leggera svista con una frase seed può comportare un costo enorme, specialmente se hai un’importante somma di fondi nel tuo portafoglio, puoi solo immaginare.<br>Per la sicurezza dei tuoi asset, è consigliabile tenere solo una piccola somma nel tuo portafoglio caldo mentre trattieni una proporzione più significativa nel tuo portafoglio freddo, mantenendolo offline. In ogni caso, prendere ulteriori precauzioni con la tua frase seed non è mai troppo.
</p><div class="blog-details-info"><br><div>Autore: <strong>Team del Blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso totale o parziale dei Servizi da Luoghi Ristetti. Per ulteriori informazioni, si prega di leggere il Contratto Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="3">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>