SXJvbmJsb2NrIHNpIHByZXBhcmEgYSBhZmZyb250YXJlIGdsaSBhdHRhY2NoaSBEZUZp

2023-03-30, 04:22

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR414568"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Ironblocks è pronto a fornire sicurezza end-to-end ai protocolli <a href="/web3" target="_blank" class="blog_inner_link">web3</a> come i ponti crosschain, i market maker e altre piattaforme DeFi.</p>
<p>L’aumento dei casi di furto digitale ha spinto Ironblocks a ideare un sistema di sicurezza robusto per i protocolli finanziari basati su contratti intelligenti.</p>
<p>I ponti crosschain e altri protocolli componibili hanno perso un gran numero di asset solo nel 2022.</p>
<h2 id="h2-Introduzione952098"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Nel 2022 si sono verificati numerosi furti e crimini crittografici, tra cui Rugpull, spoofing DNS, attacco Frontend, bug del codice, logica del protocollo e reentrancy, tra gli altri. L’aumento di questi attacchi ha portato a nuove invenzioni volte a prevenirli. Oggi discutiamo di come Ironblocks fornisce sicurezza dei token ai progetti blockchain riducendo così i casi di crimini crittografici.</p>
<h2 id="h2-Problema20dei20protocolli20di20finanza20decentralizzata906089"><a name="Problema dei protocolli di finanza decentralizzata" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Problema dei protocolli di finanza decentralizzata</h2><p>Come già accennato, il settore delle finanze decentralizzate si trova di fronte a un grande rischio di violazioni della sicurezza, tra cui gli attacchi informatici. Lo scorso anno sono stati rubati oltre 3,8 miliardi di dollari di criptovalute attraverso gli attacchi informatici, circa il 50% in più rispetto all’ammontare rubato nel 2021. Purtroppo, molti protocolli di finanza decentralizzata (DeFi) non dispongono di sistemi di sicurezza completamente impermeabili per prevenire alcuni di questi attacchi malevoli.</p>
<p>Sebbene l’audit del codice sia importante, non può impedire ai cattivi attori di rubare asset digitali detenuti da vari protocolli DeFi. Il grafico seguente mostra l’aumento delle violazioni di sicurezza tra il 2016 e il 2022.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680149975431680149569_.pic.jpg" alt=""><br>Il valore degli asset digitali rubati tra il 2016 e il 2022 - Medio</p>
<p>Come osservi da <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> Dal 2016 al 2022 si è registrato un aumento dei casi di hacking. Il valore delle criptovalute rubate nel 2021 e nel 2022, che supera i 3 miliardi di dollari all’anno, è spaventoso. In generale, questi dati mostrano che DeFi è soggetto a furti digitali.</p>
<p>L’altra triste realtà è che i furti di criptovalute non sono limitati a una singola area come le piattaforme di prestito. È diffuso in diverse aree come portafogli, protocolli DeFi e servizi centralizzati come mostra il grafico successivo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680150005441680149580_.pic.jpg" alt=""><br>Incidenti di hacking tra il 2016 e il 2022 - Medio</p>
<p>Questo diagramma indica che sono avvenuti attacchi informatici su diverse piattaforme o protocolli. Ad esempio, tra il 2016 e il 2020 gli hacker hanno preso di mira i servizi centralizzati. Tuttavia, nel 2021 e nel 2022 il loro obiettivo principale sono stati i protocolli DeFi. Tuttavia, il problema sottostante è che gli hacker possono attaccare qualsiasi protocollo digitale.</p>
<h2 id="h2-Ironblock20affronta20gli20attacchi20DeFi17928"><a name="Ironblock affronta gli attacchi DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ironblock affronta gli attacchi DeFi</h2><p>Abbiamo visto la tendenza alla violazione della sicurezza DeFi che ha implicato la necessità di un’attenzione urgente. Già esistono aziende che forniscono prodotti di sicurezza di prim’ordine adatti al settore cripto. Ironblocks è una di queste aziende di sicurezza blockchain.</p>
<p>Fondamentalmente, Ironblocks dispone di prodotti di sicurezza che aiutano i programmi finanziari basati su smart contract a rilevare le minacce prima che causino molti danni al sistema. In quanto tali, aiutano i protocolli DeFi a segnalare il prelievo sospetto di asset digitali. In particolare, Ironblocks fornisce “un sistema di monitoraggio delle transazioni in tempo reale personalizzabile, facile da implementare”, come afferma sul suo blog.</p>
<p>In effetti, il sistema di sicurezza di Ironblocks rileva attività sospette in tempo reale e le segnala entro millisecondi, consentendo ai contratti intelligenti di adottare tempestivamente le azioni appropriate.</p>
<p>Finora, al fine di offrire un sistema di sicurezza forte, Ironblocks si è associato a Hats.Finance, un programma di ricompense, per rafforzare il suo sistema di sicurezza. L’obiettivo di Ironblocks, nel forgiare partnership, è quello di offrire una serie di prodotti che proteggano i dati e gli asset digitali di qualsiasi programma basato su contratti intelligenti.</p>
<h2 id="h2-Un20caso20di20Euler232645"><a name="Un caso di Euler" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un caso di Euler</h2><p>Recentemente, attori malintenzionati hanno sfruttato Euler, un protocollo di prestiti e prestiti, attraverso il falsificare il modo in cui gestisce il collaterale e i debiti. Gli hacker hanno avuto tutto il tempo per effettuare molteplici transazioni al fine di rubare oltre 200 milioni di dollari.</p>
<p>Questo è un buon esempio di un caso di furto che Ironblocks avrebbe potuto prevenire in quanto può segnalare qualsiasi attività sospetta in pochi secondi. Sfortunatamente, tali casi di furti informatici inviano un messaggio negativo all’intero settore, che scoraggia più istituzioni e individui dall’investire i propri fondi nell’economia decentralizzata.</p>
<p>È noto che in questi giorni gli hacker mirano principalmente ai protocolli componibili come Euler che gestiscono grandi quantità di asset digitali. Nel caso di Euler, più di 10 protocolli DeFi tutti interconnessi hanno perso i loro asset digitali. Ci sono molti protocolli DeFi componibili come <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a> e <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> che possono essere preda di attacchi informatici e perdere grandi somme di asset digitali.</p>
<p>Questo non è il primo tipo di attacco del genere, poiché sono stati persi più di $100 milioni di asset quando attori malintenzionati hanno sfruttato Mango Markets, una piattaforma di trading di criptovalute che offre prestiti flash, nell’ottobre 2022.</p>
<h2 id="h2-Altri20servizi20che20richiedono20software20di20monitoraggio20della20sicurezza731036"><a name="Altri servizi che richiedono software di monitoraggio della sicurezza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altri servizi che richiedono software di monitoraggio della sicurezza</h2><p>Come già indicato, attori malintenzionati prendono di mira vari settori dell’economia blockchain, tra cui servizi decentralizzati e protocolli di token. Pertanto, tutti questi vari programmi basati su smart contract richiedono sistemi di sicurezza che monitorino le attività sulle loro piattaforme.</p>
<p>Anche i ponti cross-chain richiedono questo servizio di monitoraggio del sistema di sicurezza che Ironblocks offre. Un rapporto di Token Terminal, un aggregatore di dati crittografici, afferma che nel 2022 il cinquanta per cento (50%) delle vittime di sfruttamento informatico sono stati i ponti cross-chain.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680150138451680149593_.pic.jpg" alt=""><br>Il 50% degli exploit DeFi è legato ai ponti cross-chain - Twitter</p>
<p>Nomad e Harmon Bridge sono esempi di ponti crosschain che sono stati sfruttati nel 2022 perdendo rispettivamente $200 milioni e $100 milioni. Nello stesso anno, anche Wormhole e Ronin Network hanno perso $300 milioni e $600 milioni. Questi pochi esempi mostrano come i ponti crosschain siano vulnerabili agli attacchi informatici e richiedano sistemi di rilevamento delle minacce robusti, come quelli forniti da Ironblocks.</p>
<p>È importante, tuttavia, notare che ci sono altri fornitori di servizi di monitoraggio della sicurezza come Hypernative, un programma che scopre le minacce informatiche prima che si verifichino. Fondamentalmente, Hypernative monitora le attività off-chain e on-chain di un progetto decentralizzato. Ancora più interessante, utilizza modelli di intelligenza artificiale e euristiche per generare avvisi di minaccia per potenziali attacchi informatici prima che si verifichino.</p>
<h2 id="h2-Cos20Ironblock8234"><a name="Cos’è Ironblock?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è Ironblock?</h2><p>Ironblocks è una società israeliana di sicurezza informatica che fornisce soluzioni di sicurezza end-to-end basate su contratti intelligenti per progetti web3. Il suo sistema di sicurezza rileva minacce istantaneamente e comunica in tempo reale con i protocolli DeFi interessati, i market maker, i ponti crosschain e altre piattaforme web3 per evitare qualsiasi perdita di asset digitali o dati essenziali.</p>
<p>In un comunicato stampa, Yorai Fainmesser, un socio generale di Disruptive AI, ha detto: “Ironblocks sta sfruttando l’intelligenza artificiale e anni di profonda esperienza nativa di blockchain per interrompere il modo in cui vengono realizzati i prodotti on-chain.”</p>
<h2 id="h2-Conclusione569817"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Ironblocks, un fornitore di sicurezza web3, offre sistemi di sicurezza per la rilevazione automatica delle minacce per vari progetti basati su web3 come ponti cross-chain e protocolli DeFi. Il suo obiettivo principale è prevenire gli attacchi DeFi riducendo così le perdite finanziarie che possono subire le finanze DeFi.</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 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>