SSBjcmltaW5hbGkgZGVsbGUgY3JpcHRvdmFsdXRlIHNwb3N0YW5vIGxhIGxvcm8gYXR0ZW56aW9uZSB2ZXJzbyBsZSBDRVgsIHNlY29uZG8gaWwgcmFwcG9ydG8gZGkgQ2hhaW5hbHlzaXM=

2024-08-27, 09:21

<p><img src="https://gimg2.gateimg.com/image/article/17247501811692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR569311"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è diventato il bersaglio dei criminali crittografici a causa del potenziale del suo prezzo di salire rapidamente in brevi periodi.</p>
<p>I criminali stanno spostando la loro attenzione sugli scambi centralizzati dove viene scambiato un grande quantitativo di bitcoin.</p>
<p>Le borse centralizzate e altre organizzazioni crittografiche dovrebbero integrare l’intelligenza artificiale e l’apprendimento automatico con i loro sistemi di sicurezza.</p>
<h2 id="h2-Introduzione871292"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>L’approvazione dei fondi negoziati in borsa per lo scambio di criptovalute negli Stati Uniti ha permesso alle criptovalute di ottenere l’adozione mainstream. Tuttavia, con l’aumento del numero di persone che adottano le criptovalute, aumenta anche l’attività illecita di soggetti malintenzionati che prendono di mira sia gli investitori individuali che le organizzazioni criptovalutarie. <a href="https://www.gate.io/learn/articles/top-bitcoin-defi-projects/2726" target="_blank">come piattaforme DeFi</a> e <a href="https://www.gate.io/learn/articles/what-is-a-crypto-exchange/3001" target="_blank">scambi di criptovalute</a> Attualmente, uno dei principali obiettivi dei cattivi attori sono gli scambi centralizzati a causa della loro capacità di detenere grandi quantità di criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog/1783/should-i-use-cex-or-dex" target="_blank">Dovrei usare CEX o DEX?</a></p>
<h2 id="h2-Gli20scambi20centralizzati20diventano20bersagli20di20attori20malintenzionati20ragioni20per20lemergente20tendenza5850"><a name="Gli scambi centralizzati diventano bersagli di attori malintenzionati: ragioni per l’emergente tendenza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli scambi centralizzati diventano bersagli di attori malintenzionati: ragioni per l’emergente tendenza</h2><p>Gli scambi centralizzati sono al centro della maggior parte delle attività crittografiche nel settore digitale. Ci sono vari motivi per questo. Prima di tutto, agiscono come intermediari per diverse parti all’interno del settore delle criptovalute come investitori e istituzioni finanziarie. Gli investitori come i trader comprano e vendono vari asset digitali, motivo per cui sono un bersaglio critico dei cattivi attori come gli hacker. Gli scambi centralizzati funzionano come le banche <a href="https://www.gate.io/learn/articles/centralized-and-decentralized-exchanges/129" target="_blank">mentre coordinano varie attività</a> che includono transazioni finanziarie.</p>
<p>Recentemente <a href="https://www.chainalysis.com/blog/2024-crypto-crime-mid-year-update-part-1/" rel="nofollow noopener noreferrer" target="_blank">report di Chainanalysis indica</a> I cattivi attori che operano nel settore delle criptovalute stanno ora puntando più che prima agli scambi centralizzati. Secondo il rapporto, i malintenzionati hanno rubato più di 1,5 miliardi di dollari di criptovalute dagli scambi centralizzati durante il primo semestre dell’anno. Questo rappresenta un cambiamento rispetto a quello che facevano negli anni passati, quando prendevano di mira principalmente <a href="https://www.gate.io/bitwiki/detail/144/decentralized-exchange" target="_blank">scambi decentralizzati</a> e altre piattaforme DeFi.</p>
<p>Una delle ragioni per cui gli attaccanti prendono di mira gli exchange centralizzati è la sofisticatezza dei loro attacchi. In effetti, gli attaccanti stanno ora utilizzando tecniche di ingegneria sociale altamente avanzate per accedere agli asset digitali. Ad esempio, alcuni attaccanti, tra cui gruppi organizzati nordcoreani, sono arrivati al punto di candidarsi per lavori nell’ambito delle tecnologie dell’informazione (IT) nelle aziende che prendono di mira. Tale strategia ha consentito loro di accedere a dati speciali degli exchange centralizzati che permettono loro di rubare diverse criptovalute.</p>
<p>Esplora <a href="https://www.gate.io/price/view/centralized-exchange-token-cex &quot;Top Centralized Exchange (CEX" rel="nofollow noopener noreferrer" target="_blank">Principali monete crittografiche di scambio centralizzato (CEX)</a> Crypto Coins</p>
<p>Chainalysis ha indicato che le entrate illecite durante il primo semestre sono diminuite dello 0,54%. Con questo, gli asset rubati rappresentavano solo circa lo 0,34% del totale delle transazioni on-chain. Sebbene il numero di incidenti di hacking sia aumentato solo di poco, c’è stato un forte aumento del numero di fondi rubati per incidente. Ciò è particolarmente vero per gli incidenti di riscatto in cui gli attori malintenzionati richiedevano importi elevati. Ora si rivolgono agli exchange centralizzati che hanno grandi quantità di asset digitali dove possono chiedere importi elevati come riscatto. L’analisi a catena <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato crittografico</a> L’analisi del rapporto mostra che durante il primo semestre dell’anno l’importo del riscatto è aumentato a $459,8 milioni rispetto ai $449,1 milioni dello stesso periodo dell’anno scorso.</p>
<p>Le tendenze delle criptovalute mostrano che i ladri di criptovalute stanno prendendo di mira gli exchange centralizzati con l’obiettivo di rubare bitcoin. <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> viene scambiato principalmente su exchange centralizzati piuttosto che su piattaforme DeFi. Ora prendono di mira bitcoin più delle altre criptovalute poiché il suo prezzo può aumentare astronomicamente in brevi periodi. Ad esempio, bitcoin aveva un prezzo medio di $ 26.141 nella prima metà del 2023, ma aveva un prezzo medio di $ 60.091 intorno a luglio 2024. Durante la prima metà del 2024, circa il 40% delle criptovalute rubate erano bitcoin. Ad esempio, nel caso dell’hack del DMM sono stati rubati 4.500 BTC. Negli ultimi anni, il crimine crittografico è stato elevato sugli exchange decentralizzati perché quelli centralizzati hanno migliorato la sicurezza della loro blockchain in modo notevole. Notizie correlate <a href="https://www.gate.io/es/learn/articles/frequent-scams-and-theft-in-the-cryptocurrency-space-how-can-ordinary-people-protect-themselves/3497" target="_blank">su recenti furte di cripto e truffe</a></p>
<h2 id="h2-Sveglia20per20gli20scambi20centralizzati20Misure20di20sicurezza20da20utilizzare19738"><a name="Sveglia per gli scambi centralizzati: Misure di sicurezza da utilizzare" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sveglia per gli scambi centralizzati: Misure di sicurezza da utilizzare</h2><p>Le borse centralizzate utilizzano diverse misure di sicurezza crittografica per migliorare la protezione dei propri asset digitali di fronte all’aumento dei furti di asset digitali. Pertanto, per superare le varie vulnerabilità degli scambi, adottano diverse misure che includono lo stoccaggio a freddo degli asset, la crittografia dei dati, l’autenticazione a due fattori (2FA) e audit regolari. Si conformano anche ai requisiti normativi nella giurisdizione in cui operano.</p>
<p>-Sicurezza fisica: un modo per migliorare la protezione degli asset digitali è avere una forte sicurezza fisica. Questo tipo di sicurezza impedisce a persone non autorizzate di accedere a determinate infrastrutture, come le sale server e i data center. Ad esempio, i data center possono essere dotati di telecamere di sorveglianza e controlli biometrici degli accessi. Gate.io, ad esempio, è nota per avere un’infrastruttura sicura che include server e data center.</p>
<ul>
<li><p>Sicurezza informatica potenziata: anche gli scambi centralizzati hanno diverse misure di sicurezza informatica per prevenire l’ingegneria sociale, attacchi ransomware, attacchi DDoS e phishing. Gli scambi altamente sicuri come Gate.io utilizzano sistemi di rilevamento delle intrusioni (IDS) e firewall per la prevenzione dei furti di criptovalute.</p>
</li><li><p>Crittografia dei dati: la crittografia dei dati viene solitamente utilizzata per proteggere la riservatezza delle informazioni comunicate tra gli utenti e gli scambi. Ad esempio, i dati sensibili come i dettagli personali e le password vengono crittografati.</p>
</li></ul>
<p>-Autenticazione a due fattori: la maggior parte degli exchange centralizzati ha sistemi di autenticazione a due fattori. Ad esempio, su Gate.io un individuo utilizza una password personale e l’autenticazione tramite email, Google Authenticator, SMS in qualsiasi variante. Questo rende molto difficile per gli hacker aggirare tutte queste misure di sicurezza.</p>
<h2 id="h2-Come20potrebbe20evolversi20la20tendenza20alla20sicurezza20in20futuro7823"><a name="Come potrebbe evolversi la tendenza alla sicurezza in futuro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come potrebbe evolversi la tendenza alla sicurezza in futuro</h2><p>Le tendenze attuali delle criptovalute mostrano che in futuro gli scambi centralizzati probabilmente miglioreranno ulteriormente le loro misure di sicurezza in linea con i cambiamenti del settore. Probabilmente integreranno sistemi di sicurezza avanzati, tra cui l’apprendimento automatico (ML) e l’intelligenza artificiale per rilevare attività sospette che si verificano all’interno dei loro sistemi. Tale tecnologia è in grado di analizzare molti dati in tempo reale, permettendo di individuare e prevenire vari tipi di sfruttamento digitale.</p>
<p>Leggi sul più grande <a href="https://www.gate.io/id/blog/2158/the-biggest-crypto-heist-in-history" target="_blank">Il più grande colpo di criptovaluta nella storia</a></p>
<h2 id="h2-Conclusion693525"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Un recente rapporto di Chainanalysis mostra che gli sfruttatori di criptovalute stanno ora spostando il loro focus dagli scambi decentralizzati e dalle piattaforme DeFi agli scambi centralizzati. Stanno puntando agli scambi centralizzati poiché scambiano grandi quantità di bitcoin. Inoltre, possono contrattare per alte somme in termini di riscatto.</p>
<div class="blog-details-info"><br><div>Autore: <em>Mashell C.</em>, 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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>