VGVuZGVuemUgZGVsIDIwMjM6IGlsIGNyaW1pbmUgY3JpdHRvZ3JhZmljbyBkaW1pbnVpc2NlLCByYXBwb3J0byBDaGFpbmFuYWx5c2lz

2024-01-31, 03:48

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR934059"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>I reati crittografici sono diminuiti di circa il 40% nel 2023.</p>
<p>I pagamenti correlati alle sanzioni hanno costituito la più alta proporzione di attività illecite.</p>
<p>Sebbene le truffe sentimentali siano sottorapportate, causano molto danno emotivo alle vittime.</p>
<h2 id="h2-Introduzione635703"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il 2023 è stato un anno notevole per le criptovalute a causa del recupero del settore dagli effetti debilitanti della crypto invernale che è iniziata nel 2022. Durante quell’anno molti progetti di criptovaluta hanno chiuso o hanno presentato istanza di fallimento del capitolo 11 per facilitare la ristrutturazione. L’altra dura realtà del 2022 è stata l’elevato numero di incidenti legati alla criptovaluta che includono macellazione di maiali, truffe criptografiche, schemi di Ponzi, truffe criptografiche e spostamento di criptovalute.</p>
<p>Tuttavia, a parte l’impressionante ripresa delle criptovalute nel 2023, il numero di attività illecite legate alle criptovalute è diminuito significativamente. In questo articolo, analizziamo il tipo di reati legati alle criptovalute che sono avvenuti nel corso del 2023. Valuteremo anche i motivi per cui i reati legati alle criptovalute sono diminuiti durante quell’anno.</p>
<h2 id="h2-La20criminalit20cripto20diminuisce20nel202023837832"><a name="La criminalità cripto diminuisce nel 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La criminalità cripto diminuisce nel 2023</h2><p>Il valore totale perso attraverso attività illecite nel 2023 è stato di oltre $24 miliardi, una diminuzione del circa il 40% rispetto a quello del 2022. Tuttavia, secondo <a href="https://www.chainalysis.com/blog/2024-crypto-crime-report-introduction/" rel="nofollow noopener noreferrer" target="_blank">Chainanalysis</a>, una società di analisi crittografica, quella cifra è ancora provvisoria poiché altre attività criminali nel settore delle criptovalute che sono avvenute durante il 2023 potrebbero essere scoperte in seguito.</p>
<p>Lo stesso scenario si è verificato nel 2022 quando c’era una cifra provvisoria di $20,6 miliardi al momento della compilazione della relazione sulle criptovalute. Tuttavia, il numero di indirizzi digitali associati a attività illecite è aumentato nel tempo. Di conseguenza, il valore rivisto dei fondi criptati rubati è salito a $39,6 miliardi alla fine del 2023.</p>
<p>In realtà, nel suo rapporto <a href="https://www.chainalysis.com/blog/2024-crypto-crime-report-introduction/" rel="nofollow noopener noreferrer" target="_blank">Chainanalysis ha dichiarato</a>“Un anno da ora, questi totali saranno quasi certamente più alti, poiché identificheremo ulteriori indirizzi illeciti e incorporeremo la loro attività storica nelle nostre stime.”</p>
<p>Inoltre, secondo Chainanalysis, il rapporto potrebbe non mostrare tutte le tendenze dei crimini crittografici in quanto si concentra solo sull’attività on-chain. In relazione a questo aspetto, il rapporto ha affermato: ‘Di solito includiamo solo l’attività misurabile on-chain nelle nostre stime per le attività illecite’.</p>
<h2 id="h2-Aumentano20i20ricavi20del20ransomware20e20delle20criptovalute20del20Darknet941018"><a name="Aumentano i ricavi del ransomware e delle criptovalute del Darknet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Aumentano i ricavi del ransomware e delle criptovalute del Darknet</h2><p>Chainanalysis ha analizzato l’attività illecita di cripto in base a categorie stabilite che includono ransomware, vendite di mercato darknet, transazioni di cripto correlate alle sanzioni e truffe romantiche. L’attività illecita è aumentata in alcune di queste attività ma è diminuita in altre.</p>
<p>Il rapporto mostra che c’è stato un aumento dei ransomware e delle vendite sul mercato darknet rispetto al 2022. Per inciso, l’estorsione dei ransomware e le vendite sul mercato darknet erano precedentemente diffuse sul <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> la blockchain ma questo è cambiato nel 2023.</p>
<p>Tuttavia, c’è stata una diminuzione di alcuni crimini crittografici che erano precedentemente associati a <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> come truffe e pagamenti correlati alle sanzioni. Questi sono ora più diffusi con stablecoin rispetto al passato.</p>
<p>Quando i casi di ransomware diminuirono nel 2022, Chainanalysis concluse che ciò era il risultato di miglioramenti nella sicurezza informatica da parte delle aziende criptovalutarie. Purtroppo, nel 2023 c’è stata una recrudescenza di tali casi.</p>
<p>C’è stato un sviluppo simile con il reddito del mercato darknet. È diminuito nel 2022 ma è aumentato nel 2023. Il rapporto Chainanalysis del 2022 ha concluso che la chiusura di Hydra, una piattaforma associata al mercato darknet, ha portato a una diminuzione dei crimini crittografici. Di fatto, Hydra rappresentava circa il 90% del reddito del darknet.</p>
<p>Ciò che potrebbe aver portato all’aumento dell’estorsione dei ransomware e delle vendite sul mercato oscuro nel 2023 potrebbe essere l’adattamento dei criminali informatici ai recenti miglioramenti della sicurezza nel settore delle criptovalute. Gli attori malintenzionati potrebbero aver scoperto modi per eludere alcune delle nuove misure di sicurezza ideate.</p>
<h2 id="h2-Le20transazioni20criptate20correlate20alle20sanzioni20hanno20dominato20nel202023168161"><a name="Le transazioni criptate correlate alle sanzioni hanno dominato nel 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le transazioni criptate correlate alle sanzioni hanno dominato nel 2023</h2><p>I pagamenti correlati alle sanzioni hanno contribuito in modo significativo all’ammontare dei crimini crittografici. Fondamentalmente, questi crimini hanno costituito il 61,5% di tale importo, stimato in 24,4 miliardi di dollari. I 14,9 miliardi di dollari, attribuiti a tali attività illecite di criptovaluta, provengono dai pagamenti in criptovaluta in giurisdizioni come la Russia che non applicano le sanzioni degli Stati Uniti.</p>
<p>Garantex, un exchange con sede in Russia, sanzionato da OFAC e OFSI nel Regno Unito, è stato citato come una delle principali entità che facilitano il riciclaggio di denaro per conto di criminali informatici. Sembra che non abbia un programma approvato contro il riciclaggio di denaro (AML).</p>
<p>La triste realtà, però, è che alcuni di questi pagamenti sono stati effettuati da persone innocenti che vivono in paesi soggetti a sanzioni come l’Iran. Tuttavia, la maggior parte di queste transazioni sono effettuate da entità e gruppi soggetti a sanzioni come i terroristi che non hanno molto accesso diretto al dollaro statunitense. Va notato che la maggior parte di queste transazioni vengono effettuate utilizzando stablecoin.</p>
<h2 id="h2-Truffe20e20hacking20nel20mondo20delle20criptovalute23480"><a name="Truffe e hacking nel mondo delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Truffe e hacking nel mondo delle criptovalute</h2><p>Il valore totale rubato attraverso truffe e hacking di criptovalute è diminuito del 29,2% e del 54,3% durante il 2023. Molti truffatori di criptovalute hanno utilizzato tattiche romantiche o la macellazione di maiali per rubare criptovalute a vittime inconsapevoli. Spesso, questi truffatori creano una forte relazione con le vittime delle criptovalute.</p>
<p>Una volta che gli scammer creano un forte legame con la vittima, promuovono programmi finti di criptovaluta. Poiché gli scammer e le potenziali vittime hanno creato una forte relazione, le persone ignare spesso investono nei progetti di criptovaluta come consigliato.</p>
<p>Purtroppo uno schema crittografico come il macello di maiali è dannoso per la vittima che avrebbe investito emotivamente nel colpevole. Questa truffa crittografica è più angosciante rispetto ad altri crimini.</p>
<p>A proposito, <a href="https://www.chainalysis.com/blog/2024-crypto-crime-report-introduction/" rel="nofollow noopener noreferrer" target="_blank">Chainanalysis ha commentato</a>, “Naturalmente, l’impatto delle truffe romantiche sulle vittime individuali è devastante e non dovrebbe essere sottovalutato.”</p>
<p>Ha continuato: “E mentre un aumento delle segnalazioni - almeno negli Stati Uniti - è un buon segnale, ancora crediamo che le informazioni sulle truffe romantiche in particolare soffrano di una scarsa segnalazione.”</p>
<h2 id="h2-Definizioni20importanti20di20criptovalute303329"><a name="Definizioni importanti di criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Definizioni importanti di criptovalute</h2><p>Macelleria del maiale: questo è un tipo di truffa crittografica che coinvolge relazioni romantiche online, inviti a investimenti ad alto rendimento e tratta di esseri umani. Di solito, le vittime finiscono per investire in progetti falsi.</p>
<p>Truffa criptata: Si tratta di un piano pianificato per rubare criptovalute a individui inconsapevoli. Esempi di truffe criptate includono macellazione di maiali, phishing cripto e tirare tappeti.</p>
<p>Schema di Ponzi: questa è una forma di frode finanziaria in cui agli investitori vengono promessi rendimenti più elevati per i loro fondi investiti. Di solito, gli schemi pagano alti rendimenti ai primi investitori per attirare più persone a investire i loro fondi in attività false.</p>
<p>Truffa criptata: Una truffa criptata è un’iniziativa per ottenere criptovalute dagli investitori tramite l’inganno. I colpevoli spesso ottengono informazioni dalle vittime che permettono loro di rubare i loro asset digitali.</p>
<h2 id="h2-Conclusione874488"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>I crimini crittografici sono diminuiti del 40% nel 2023, un periodo in cui l’industria si è ripresa dagli effetti dell’inverno crittografico del 2022. I pagamenti correlati alle sanzioni hanno contribuito al 61,5% dei crimini crittografici. I ransomware e le vendite sui mercati darknet sono aumentati durante l’anno. Tuttavia, c’è stata una diminuzione delle truffe crittografiche e degli attacchi informatici durante il periodo.</p>
<h2 id="h2-Domande20frequenti20sui20crimini20informatici20con20criptovalute679345"><a name="Domande frequenti sui crimini informatici con criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sui crimini informatici con criptovalute</h2><h3 id="h3-Cos20il20crimine20delle20criptovalute663114"><a name="Cos’è il crimine delle criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è il crimine delle criptovalute?</h3><p>I crimini crittografici si riferiscono al furto di criptovalute che avviene online. I criminali possono utilizzare phishing, tattiche romantiche, hacking e schemi ponzi, tra gli altri, per rubare criptovalute ad altre persone e organizzazioni.</p>
<h3 id="h3-Quali20attivit20criminali20stanno20utilizzando20le20criptovalute442391"><a name="Quali attività criminali stanno utilizzando le criptovalute?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali attività criminali stanno utilizzando le criptovalute?</h3><p>Ci sono diversi esempi di attività illecite legate alle criptovalute, tra cui ransomware, mercati darknet, truffe, tattiche romantiche, hacking e phishing. Il modo migliore per prevenire alcune di queste attività è evitare di seguire consigli sugli investimenti in criptovalute da parte di persone che non conosci fisicamente.</p>
<h3 id="h3-Come20vengono20commessi20la20maggior20parte20dei20crimini20crittografici183638"><a name="Come vengono commessi la maggior parte dei crimini crittografici?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come vengono commessi la maggior parte dei crimini crittografici?</h3><p>I cattivi attori utilizzano truffe, schemi Ponzi, tattiche romantiche, hacking e phishing per rubare criptovalute dalle persone ignare. Tuttavia, c’è stato un calo dei crimini legati alle criptovalute nel 2023.</p>
<h3 id="h3-Le20criptovalute20vengono20utilizzate20per20il20riciclaggio20di20denaro788659"><a name="Le criptovalute vengono utilizzate per il riciclaggio di denaro?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le criptovalute vengono utilizzate per il riciclaggio di denaro?</h3><p>A volte i criminali informatici utilizzano le criptovalute per il riciclaggio di denaro. Rubano criptovalute utilizzando diversi mezzi come schemi ponzi, hacking, tattiche romantiche, truffe e le utilizzano per attività illegali come il finanziamento del terrorismo e il traffico di droga.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore 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 venga citato Gate.io. In tutti i casi, sarà intrapresa un'azione legale per violazione del copyright.<br></div><p></p><br></div></div></div>