SW5jaWRlbnRpIGNyaXR0b2dyYWZpY2kgZGkgbm92ZW1icmU6IGdsaSB1dGVudGkgc3ViaXNjb25vIHBlc2FudGkgcGVyZGl0ZSBkaSAkMzU2IG1pbGlvbmkgYSBjYXVzYSBkaSBoYWNraW5nLCBwaGlzaGluZyBlIHJ1ZyBwdWxs

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""><br>Attori malevoli hanno rubato criptovalute per un valore superiore a $356 milioni nel novembre 2023.</p>
<p>Gli attacchi informatici ai criptoportafogli hanno causato perdite per un valore complessivo di 335,63 milioni di dollari, le truffe di phishing circa 14,6 milioni di dollari e le truffe dei rugpull circa 6,3 milioni di dollari.</p>
<p>Per prevenire hack e altri crimini crittografici, i progetti DeFi dovrebbero migliorare le loro misure di sicurezza crittografica attraverso l’esecuzione di audit tempestivi.</p>
<p>Parole chiave: crypto rug pulls, crypto hacker, crimine crypto, perdite crypto, suggerimenti di sicurezza crypto, crypto hack, phishing crypto, truffe di phishing, truffatore crypto, truffa crypto, frode crypto</p>
<h2 id="h2-Introduzione700345"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Investire in criptovalute comporta vari rischi, tra cui alta volatilità dei prezzi, hack, <a href="https://www.gate.io/blog_detail/1425/what-is-phishing-and-how-to-protect-ourselves-from-phishing-attacks" target="_blank">phishing</a> e rug pulls, tra gli altri. Gli hack e i rugpulls crittografici non sono diffusi uniformemente durante l’anno. Si verificano durante determinati periodi o stagioni crittografiche</p>
<p>Nel 2023 <a href="https://www.gate.io/blog_detail/1008/15-biggest-crypto-hacks-and-heists" target="_blank">ci sono stati molti hack</a>, truffe sui tappeti e casi di phishing nel mese di novembre. In questo articolo discutiamo di alcuni di questi incidenti. Esploreremo anche modi in cui gli investitori di criptovalute possono proteggersi da tali rischi.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2158/the-biggest-crypto-heist-in-history" target="_blank">Il più grande furto di criptovalute nella storia</a></p>
<h2 id="h2-Aumento20degli20attacchi20informatici20dei20rugpull20e20degli20incidenti20di20phishing20a20novembre256383"><a name="Aumento degli attacchi informatici, dei rugpull e degli incidenti di phishing a novembre" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aumento degli attacchi informatici, dei rugpull e degli incidenti di phishing a novembre</h2><p>Novembre ha avuto molti incidenti di hack, rugpull e phishing che hanno comportato la perdita di criptovalute per un valore superiore a $356 milioni. In realtà, sono stati registrati un totale di 26 incidenti di sicurezza crittografica durante il mese.</p>
<p>In sintesi, gli attacchi informatici hanno portato a una perdita di circa 335,63 milioni di dollari, le truffe di phishing circa 14,6 milioni di dollari e i rugpulls approssimativamente 6,3 milioni di dollari. È importante notare che le perdite derivanti da violazioni e truffe sono aumentate del 6,9% a novembre rispetto a ottobre.</p>
<h2 id="h2-Perdita20da20attacchi20informatici743420"><a name="Perdita da attacchi informatici" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perdita da attacchi informatici</h2><p>Come sopra indicato, gran parte delle perdite derivanti da exploit e altre azioni maligne è stata causata da hack. Ci sono stati due gravi incidenti di hacking in cui sono stati persi criptoasset del valore di oltre 100 milioni di dollari in ciascun caso.</p>
<p>In particolare, Poloniex, un exchange di criptovalute, ha perso 126 milioni di dollari mentre gli hacker hanno rubato criptovalute del valore di 100 milioni di dollari da HTX, precedentemente noto come <a href="/price/huobi-ht" rel="nofollow noopener noreferrer" target="_blank">Huobi</a> Global. Il ponte HECO, un ponte cross-chain affiliato a HTX, ha perso cripto-attività del valore di 110 milioni di dollari. Questi incidenti costituivano circa il 66% delle perdite totali causate da cattivi attori a novembre.</p>
<p>Esempi di progetti DeFi che sono stati hackerati sono KyberSwap e Raft Fi. Il fattore principale che ha contribuito agli attacchi riusciti sono state le scarse misure di sicurezza dei contratti intelligenti.</p>
<h2 id="h2-Truffe20di20phishing969542"><a name="Truffe di phishing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Truffe di phishing</h2><p>In totale, le truffe di phishing hanno portato alla perdita di cripto valute che superano 1 milione di dollari. In parole semplici, le truffe di phishing comportano l’accesso fraudolento a dettagli personali o di piattaforma come le chiavi private. Esempi di piattaforme colpite sono <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a>, KyberSwap, Poloniex, HTX e CoinSpot.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/how-to-protect-yourself-from-seed-phrase-scams/59" target="_blank">Come proteggersi dalle truffe delle frasi di recupero del seme</a></p>
<h2 id="h2-Scambi20centralizzati20e20decentralizzati262621"><a name="Scambi centralizzati e decentralizzati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Scambi centralizzati e decentralizzati</h2><p>Gli attori malintenzionati hanno sfruttato sia gli exchange centralizzati (CEXs) che quelli decentralizzati (DEXs) provocando la perdita di cripto-attività. In breve, questi exchange di criptovalute hanno perso un totale di 215 milioni di dollari solo a novembre. Come evidenziato in precedenza, dYdX, KyberSwap, Poloniex, HTX e CoinSpot sono tra gli exchange interessati. Questi exchange devono migliorare i loro sistemi di sicurezza per prevenire simili sfruttamenti in futuro.</p>
<h2 id="h2-Come20sono20avvenuti20gli20sfruttamenti801359"><a name="Come sono avvenuti gli sfruttamenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come sono avvenuti gli sfruttamenti</h2><p>In precedenza, abbiamo menzionato alcuni incidenti di hacking che hanno portato alla perdita di fondi. Ora, analizziamo alcuni di questi incidenti di hacking e phishing nel dettaglio.</p>
<p><strong>Kronos Ricerca</strong>: Il 19 novembre i cripto hacker hanno sfruttato Kronos Research causando la perdita di criptovalute per un valore di $25,65 milioni. Gli hacker hanno compromesso le chiavi dell’interfaccia di programmazione dell’applicazione (API) di Kronos.</p>
<p>Ha perso vari asset crittografici tra cui USDC, ETH e USDT nel processo. Le chiavi API sono un’alternativa alle password o una forma di autenticazione. Pertanto, chiunque entri in possesso delle API dei progetti basati su blockchain può accedere ai loro asset digitali.</p>
<p><strong>Poloneix</strong> Nello stesso mese, novembre, un hacker di criptovalute ha sfruttato Poloneix, un exchange di criptovalute, rubando monete e token per un valore di 126 milioni di dollari. In effetti, il malintenzionato ha avuto accesso alle chiavi private dell’exchange per i portafogli caldi.</p>
<p>Il fatto è che una volta che un hacker accede alla chiave privata del portafoglio digitale di un individuo o di un’organizzazione, può inviare token dal portafoglio. In base al modo in cui si è sviluppato l’attacco, alcuni analisti ritengono che il gruppo Lazarus, legato al governo nordcoreano, sia responsabile dell’exploitazione.</p>
<p><strong>KyberSwap</strong>: L’hacker ha attaccato il KyberSwap Elastic, consentendogli di accedere a criptovalute del valore di circa 48 milioni di dollari. In questo caso, l’attaccante ha manipolato differenziali di prezzo tra diversi mercati di criptovalute. In altre parole, è stato un attacco diretto alle pool di liquidità dello scambio. Tuttavia, quell’errore avrebbe potuto essere evitato attraverso un’auditing intelligente dei contratti.</p>
<p><strong>Attacco a dYdX</strong>: Con questo crimine crittografico, l’attaccante ha svuotato il 40% del fondo assicurativo utilizzato per proteggere gli utenti dal coprire le operazioni perdenti di altri trader.</p>
<p>In particolare, l’hacker ha manipolato il mercato dei token Yearn che normalmente ha volumi di scambio molto bassi. Egli/ella ha approfittato delle falle nel sistema di gestione del rischio di dYdX.</p>
<p><strong>HTX Exchange</strong> Il 22 novembre, HTX exchange ha perso criptovalute per un valore superiore a 13,6 milioni di dollari a causa di portafogli caldi compromessi. La maggior parte delle criptovalute è stata convertita in ETH e svuotata dai suoi tre portafogli. In totale, l’exchange ha perso 78 milioni di USDC, 1.240 ETH, 62.200 <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> e 7,3 milioni di USDT.</p>
<h2 id="h2-Altre20piattaforme20DeFi20che20hanno20perso20criptovalute150859"><a name="Altre piattaforme DeFi che hanno perso criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altre piattaforme DeFi che hanno perso criptovalute</h2><p>Ci sono molte altre piattaforme DeFi che hanno perso molti asset crittografici. La seguente tabella elenca alcune di esse e le diverse cause degli attacchi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17024392641.png" alt=""><br>Novembre Crypto Hacks e Perdite - Defillama</p>
<p>È importante notare che l’elenco di cui sopra non è esaustivo dei crimini crittografici che si sono verificati nel mese di novembre. Tuttavia, cattura i principali del mese.</p>
<h2 id="h2-Phishing20Scams20e20Rugpulls107833"><a name="Phishing Scams e Rugpulls" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Phishing Scams e Rugpulls</h2><p>Oltre all’elenco degli hack di criptovalute che abbiamo finora elencato e discusso, ci sono stati diversi altri truffe di phishing e rugpulls a novembre. Ad esempio, il 15 novembre un portafoglio ha perso 3,4 milioni di dollari a causa di phishing. Il proprietario è stato indotto a firmare ciò che il truffatore di criptovalute ha definito una transazione “increaseAllowance”.</p>
<p>Il 23 novembre c’è stato un rug pull sul <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> catena in cui un “deployer” ha rimosso liquidità per un valore di 1,7 milioni di dollari. Inoltre, il 27 novembre, Inferno Drainer, un fornitore di servizi fraudolenti, ha annunciato la chiusura. In quell’incidente di truffa crittografica gli utenti hanno perso cripto-attività per un valore superiore a 80 milioni di dollari.</p>
<p>Ancora una volta, un altro rug pull è avvenuto sulla catena <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> il 30 novembre quando il progetto Fuding Token ha chiuso, scomparendo con oltre $520.000. Oltre a ciò, <a href="https://www.gate.io/blog_detail/488/" target="_blank">ci sono altre truffe a tappeto</a> e truffe di phishing che non abbiamo elencato qui.</p>
<p>Dopo aver discusso i suddetti reati crittografici e le perdite crittografiche correlate, è chiaro che sia i progetti DeFi che i loro utenti dovrebbero mettere in atto varie misure per prevenire casi simili in futuro.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/3094/daily-news-a-new-vulnerability-in-ios-16-may-cause-crypto-devices-to-be-hacked-north-korean-hackers-stolen-over-200m-in-crypto-in-2023-7-trending-tokens-are-about-to-be-unlocked" target="_blank">Gli hacker nordcoreani hanno rubato oltre 200 milioni di dollari in criptovalute nel 2023</a></p>
<h2 id="h2-Consigli20sulla20sicurezza20informatica20dagli20esperti20di20Gateio680898"><a name="Consigli sulla sicurezza informatica dagli esperti di Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Consigli sulla sicurezza informatica dagli esperti di Gate.io</h2><p>Non c’è dubbio che alcuni degli incidenti di frode e crimini criptati di cui abbiamo parlato sarebbero stati evitati attraverso misure di sicurezza robuste. Questo perché la maggior parte delle piattaforme DeFi che sono state compromesse avevano difetti nei loro smart contract.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-cryptojacking/871" target="_blank">Cos’è il Cryptojacking?</a></p>
<p>Pertanto, per ridurre gli incidenti di criptocrimine, questi progetti DeFi dovrebbero avere controlli di sicurezza regolari e piani chiari per affrontare le emergenze in caso di hack crittografici e altri crimini crittografici. Dovrebbero anche formare i propri dipendenti su questioni di sicurezza.</p>
<p>Inoltre, è importante effettuare costanti controlli durante l’esecuzione dei loro smart contract. Inoltre, i progetti dovrebbero migliorare i loro sistemi di gestione delle chiavi private. Tali misure potrebbero contribuire a ridurre il numero di incidenti di sicurezza crittografica e le perdite crittografiche sostenute in caso di violazioni di sistema.</p>
<h2 id="h2-Consigli20di20sicurezza20crittografica20per20gli20utenti742508"><a name="Consigli di sicurezza crittografica per gli utenti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Consigli di sicurezza crittografica per gli utenti</h2><p>Gli utenti di criptovalute dovrebbero mantenere la vigilanza quando lavorano online per <a href="https://www.gate.io/learn/course/crypto-security-fraud-safety-and-hack" target="_blank">evitare trappole di sicurezza che includono il phishing</a> Fondamentalmente, gli scammers del phishing mirano ad accedere ai dettagli personali degli utenti che includono gli indirizzi email, le chiavi private e le frasi seed. Utilizzano metodi diversi per ottenere tali dati.</p>
<p>Per prevenire il phishing, gli utenti dovrebbero evitare di aprire <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> inviati da persone sconosciute. È anche importante evitare di rispondere alle email di mittenti sconosciuti. Inoltre, non fornire mai a nessuno i tuoi PIN, codici 2FA e chiavi private, non importa cosa. Questo proteggerà i tuoi asset digitali.</p>
<p>E non fornire mai le tue informazioni importanti a siti web di cui non conosci i proprietari e gli scopi. In passato, ad esempio, molti utenti sono caduti vittima di airdrop falsi, perdendo così i loro asset digitali.</p>
<p>Un’altra cosa importante è evitare di utilizzare Wi-Fi pubbliche quando si effettuano transazioni di criptovaluta o quando si utilizzano dispositivi elettronici che contengono informazioni essenziali come chiavi private e password. Se si utilizza una Wi-Fi pubblica, assicurarsi di utilizzare una VPN e di non aprire mai finestre pop-up.</p>
<p>Si dovrebbe sempre attenersi alle misure di sicurezza comuni come utilizzare password robuste e cambiarle regolarmente. Inoltre, aggiornare sempre le applicazioni e i browser poiché ciò comporta il miglioramento delle misure di sicurezza. Allo stesso modo, è molto saggio conservare la maggior parte dei propri beni digitali in portafogli freddi.</p>
<p>Ogni investitore dovrebbe anche sapere come individuare e rimanere al sicuro dai rugpulls. Ad esempio, è molto importante investire in piattaforme blockchain affidabili come gli scambi di criptovalute. Questo perché la maggior parte degli scambi è diligente nel vagliare le criptovalute che elencano.</p>
<p>Inoltre, se sei nuovo alle criptovalute, la cosa migliore da fare è investire in criptovalute consolidate come <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e ETH. Ancora una volta, alcune borse hanno le loro monete e token come BNB e Gate Coin che sono più sicuri degli altri. Provare a investire in criptovalute appena lanciate può portare a molte perdite.</p>
<h2 id="h2-Conclusion118781"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Nel novembre 2023 è stato il mese peggiore in termini di crimini crittografici come hack, truffe e frodi di phishing. I progetti DeFi e gli investitori di criptovalute hanno subito più di $356 milioni in perdite di criptovalute a causa di violazioni della sicurezza e frodi criptografiche. I progetti DeFi possono prevenire tali crimini migliorando le loro misure di sicurezza criptografica.</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 riutilizzo dell'articolo a patto che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>