SXJvbmJsb2NrIGdhYXQgZGUgdWl0ZGFnaW5nIGFhbiBvbSBEZUZpLWhhY2tzIGFhbiB0ZSBwYWtrZW4=

2023-03-30, 04:22

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR901528"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Ironblocks staat klaar om end-to-end beveiliging te bieden aan web3-protocollen zoals crosschain-bruggen, market makers en andere DeFi-platforms.</p>
<p>De toename van het aantal glen van digitale diefstal zette Ironblocks ertoe aan een sterk beveiligingssysteem te bedenken voor op slimme contracten gebaseerde financiële protocollen.</p>
<p>Crosschain-bruggen en andere samenstelbare protocollen verloren alleen al in 2022 een groot aantal activa.</p>
<h2 id="h2-Introductie269894"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>2022 heeft veel crypto-diefstallen en misdaden gezien, waaronder Rugpull, DNS-spoofing, Frontend-aanval, Codebug, Protocollogica en Reentrancy, onder andere. De toename van deze aanvallen heeft geleid tot nieuwe uitvindingen die tot doel hebben ze te voorkomen. Vandaag bespreken we hoe Ironblocks tokenbeveiliging biedt voor blockchainprojecten, waardoor het aantal glen van crypto-criminaliteit wordt verminderd.</p>
<h2 id="h2-Probleem20van20gedecentraliseerde20financile20protocollen215815"><a name="Probleem van gedecentraliseerde financiële protocollen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Probleem van gedecentraliseerde financiële protocollen</h2><p>Zoals hierboven vermeld, staat de gedecentraliseerde financiële sector voor een groot risico op beveiligingsinbreuken, waaronder hacken. Vorig jaar werd er voor meer dan $3,8 miljard aan cryptocurrencies gestolen door hacking, ongeveer 50% meer dan het bedrag dat in 2021 werd gestolen. Helaas hebben veel gedecentraliseerde financiële (DeFi) protocollen geen waterdichte beveiligingsen om enkele van deze kwaadaardige aanvallen te voorkomen.</p>
<p>Hoewel code-audit belangrijk is, kan het niet voorkomen dat slechte actoren digitale activa stelen die verschillende DeFi-protocollen vasthouden. De volgende grafiek toont de toename van incidenten van beveiligingsinbreuken tussen 2016 en 2022.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680149975431680149569_.pic.jpg" alt=""><br>De waarde van gestolen digitale activa tussen 2016 en 2022 - Medium</p>
<p>Zoals je kunt observeren vanaf <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">De grafiek</a> is er tussen 2016 en 2022 een toename van het aantal glen van hacking. De waarde van gestolen cryptocurrencies in 2021 en 2022, die meer dan $ 3 miljard per jaar bedraagt, is beangstigend. Al met al laten deze statistieken zien dat DeFi vatbaar is voor digitale diefstal.</p>
<p>De andere trieste realiteit is dat crypto diefstallen zich niet beperken tot één gebied, zoals leningplatforms. Het is wijdverbreid in verschillende gebieden zoals portefeuilles, DeFi-protocollen en gecentraliseerde diensten, zoals blijkt uit de volgende grafiek.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680150005441680149580_.pic.jpg" alt=""><br>Glen van hacken tussen 2016 en 2022 - Medium</p>
<p>Deze diagram geeft aan dat er hacking heeft plaatsgevonden op verschillende platforms of protocollen. Bijvoorbeeld, tussen 2016 en 2020 richtten de hackers zich op gecentraliseerde diensten. Echter, in 2021 en 2022 was hun belangrijkste doelwit DeFi-protocollen. Het onderliggende probleem is echter dat hackers elk digitaal protocol kunnen aanvallen.</p>
<h2 id="h2-Ironblock20pakt20DeFihacks20aan990601"><a name="Ironblock pakt DeFi-hacks aan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ironblock pakt DeFi-hacks aan</h2><p>We hebben de trend van DeFi-beveiligingsinbreuken gezien, wat wijst op de noodzaak van dringende aandacht. Er zijn al bedrijven die eersteklas beveiligingsproducten bieden die geschikt zijn voor de cryptosector. Ironblocks is zo’n blockchain-beveiligingsbedrijf.</p>
<p>Ironblocks heeft in feite beveiligingsproducten die slimme contractgebaseerde financiële programma’s helpen om bedreigingen te detecteren voordat ze veel schade aan het systeem veroorzaken. Als zodanig helpen ze DeFi-protocollen om verdachte opnames van digitale activa te signaleren. Opmerkelijk is dat Ironblocks een ‘aanpasbaar, gemakkelijk te implementeren, real-time transactiemonitoringsysteem’ biedt, zoals het staat op zijn blog.</p>
<p>In feite detecteert het beveiligingssysteem van Ironblocks verdachte activiteiten in real-time en meldt ze binnen milliseconden, waardoor de slimme contracten tijdig passende maatregelen kunnen nemen.</p>
<p>Tot nu toe heeft Ironblocks, om een sterk beveiligingssysteem te bieden, samengewerkt met Hats.Finance, een beloningsprogramma, om zijn beveiligingssysteem te versterken. Het doel van Ironblocks bij het aangaan van partnerschappen is om een reeks producten aan te bieden die de gegevens en digitale activa van elk smart contract-gebaseerd programma beschermen.</p>
<h2 id="h2-Een20g20van20Euler761755"><a name="Een g van Euler" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een g van Euler</h2><p>Onlangs hebben kwaadwillende actoren Euler, een uitleen- en leenprotocol, misbruikt door de manier waarop het onderpand en de schulden worden gespoofd. De hackers hadden de tijd om meerdere transacties uit te voeren om meer dan $200 miljoen dollar te stelen.</p>
<p>Dit is een goed voorbeeld van een diefstalzaak die Ironblocks had kunnen voorkomen, aangezien het in enkele seconden verdachte activiteiten kan signaleren. Helaas sturen dergelijke glen van cyberdiefstal een slechte boodschap naar de hele sector, waardoor meer instellingen en particulieren ervan worden weerhouden hun geld te investeren in de gedecentraliseerde economie.</p>
<p>Opvallend is dat hackers zich tegenwoordig voornamelijk richten op samenstelbare protocollen zoals Euler die grote hoeveelheden digitale activa beheren. In het g van Euler verloren meer dan 10 DeFi-protocollen die allemaal met elkaar verbonden waren hun digitale activa. Er zijn veel samenstelbare DeFi-protocollen zoals <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Samenstellen</a> en <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> die ten prooi kunnen vallen aan hacken en grote hoeveelheden digitale activa kunnen verliezen.</p>
<p>Dit is niet de eerste soortgelijke aanval, aangezien er meer dan $100 miljoen aan activa verloren ging toen kwaadwillende actoren Mango Markets exploiteerden, een crypto-handelsplatform dat flashleningen aanbiedt, in oktober 2022.</p>
<h2 id="h2-Andere20diensten20die20beveiligingsbewakingssoftware20vereisen414185"><a name="Andere diensten die beveiligingsbewakingssoftware vereisen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Andere diensten die beveiligingsbewakingssoftware vereisen</h2><p>Zoals hierboven vermeld, richten kwaadwillende actoren zich op verschillende sectoren van de blockchain-economie, waaronder gedecentraliseerde diensten en tokenprotocollen. Daarom vereisen al deze verschillende op slimme contracten gebaseerde programma’s beveiligingsen die activiteiten op hun platforms monitoren.</p>
<p>Cross-chain bruggen vereisen ook deze beveiligingssysteemmonitoringdiensten die Ironblocks aanbiedt. Een rapport van Token Terminal, een cryptogegevens aggregator, zegt dat in 2022 vijftig procent (50%) van de slachtoffers van cyberaanvallen bruggen tussen ketens waren.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1680150138451680149593_.pic.jpg" alt=""><br>50% van de DeFi exploits zijn gerelateerd aan cross chain bruggen - Twitter</p>
<p>Nomad en Harmon Bridge zijn voorbeelden van crosschain-bruggen die in 2022 respectievelijk $200 miljoen en $100 miljoen hebben verloren. In hetzelfde jaar verloren Wormhole en Ronin Network ook respectievelijk $300 miljoen en $600 miljoen. Deze paar voorbeelden laten zien hoe kwetsbaar crosschain-bruggen zijn voor cyberaanvallen en sterke bedreigingsdetectieen vereisen, zoals degene die Ironblocks biedt.</p>
<p>Het is echter belangrijk op te merken dat er andere aanbieders van beveiligingsmonitoringsdiensten zijn, zoals Hypernative, een programma dat cyberdreigingen onthult voordat ze zich voordoen. Hypernative controleert in feite off-chain en on-chain activiteiten van een gedecentraliseerd project. Interessanter nog, het maakt gebruik van kunstmatige intelligentiemodellen en heuristieken om dreigingsmeldingen te genereren voor potentiële cyberaanvallen voordat ze zich voordoen.</p>
<h2 id="h2-Wat20is20Ironblock743312"><a name="Wat is Ironblock?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Ironblock?</h2><p>Ironblocks is een Israëlisch cyberbeveiligingsbedrijf dat slimme contractgebaseerde end-to-end beveiligingsoplossingen biedt voor web3-projecten. Het beveiligingssysteem detecteert bedreigingen onmiddellijk en communiceert in realtime met de getroffen DeFi-protocollen, marktmakers, crosschain-bruggen en andere web3-platforms om verlies van digitale activa of essentiële gegevens te voorkomen.</p>
<p>In een persbericht zei Yorai Fainmesser, een algemene partner bij Disruptive AI: “Ironblocks maakt gebruik van kunstmatige intelligentie en jarenlange diepgaande native blockchain-ervaring om de manier waarop on-chain producten worden gedaan te verstoren.”</p>
<h2 id="h2-Conclusie756781"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Ironblocks, een web3-beveiligingsaanbieder, biedt geautomatiseerde bedreigingsdetectiebeveiligingsen voor diverse op <a href="/web3" target="_blank" class="blog_inner_link">web3</a> gebaseerde projecten zoals cross-chain bruggen en DeFi-protocollen. Het richt zich voornamelijk op het voorkomen van DeFi-hacks en het verminderen van financiële verliezen die DeFi-finance kan oplopen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen investeringssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herposten van het artikel wordt toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>