JDQxMiBtaWxqb2VuIHZlcmxvcmVuIGluIGhldCBkZXJkZSBrd2FydGFhbCB2YW4gMjAyNCB0ZSBtaWRkZW4gdmFuIHZlcmJldGVyZGUgdmVpbGlnaGVpZHNtYWF0cmVnZWxlbg==

2024-10-09, 07:36

<p><img src="https://gimg2.gateimg.com/image/article/17284589211690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR931072"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>In het derde kwartaal van 2024 slaan slechte acteurs ongeveer $412 miljoen aan cryptocurrencies op van beurzen.</p>
<p>In juli verloor WazirX $235 aan cryptocurrencies aan hackers, terwijl digitale valuta ter waarde van ongeveer $52 miljoen werd weggehaald van BingX.</p>
<p>Het zelf bewaren van digitale activa kan helpen om verliezen in cryptovaluta te voorkomen.</p>
<h2 id="h2-Introductie629866"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Crypto misdaden blijven een van de grootste uitdagingen voor de adoptie van digitale valuta. Dit komt doordat risicomijdende investeerders bang zijn om hun geld in digitale activa te steken. In plaats daarvan kiezen ze ervoor om zich te richten op traditionele beleggingsactiva zoals vreemde valuta en grondstoffen zoals goud. De lancering van verschillende spot crypto ETF’s kan echter dergelijke investeerders naar de sector lokken. Deze analyse bekijkt crypto-verliezen die zich hebben voorgedaan in het derde kwartaal (Q3) van 2024 als gevolg van kwaadwillige acties zoals hacking.</p>
<h2 id="h2-Q320202420Ziet2041220Miljoen20aan20Verliezen20in20Crypto283103"><a name="Q3 2024 Ziet $412 Miljoen aan Verliezen in Crypto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3 2024 Ziet $412 Miljoen aan Verliezen in Crypto</h2><p>Een <a href="https://downloads.ctfassets.net/t3wqy70tc3bv/4wrLxaFvKa4NQXA43uPWri/80111984054b3b959e4e2a918537f233/Immunefi_Crypto_Losses_in_Q3_2024.pdf" rel="nofollow noopener noreferrer" target="_blank">rapport van Immunefi</a>, een bedrijf voor blockchainbeveiliging, toont aan dat de cryptosector in het derde kwartaal ongeveer $412.994.499 heeft verloren als gevolg van kwaadwillige acties zoals hacken en cryptozwendel. Volgens het rapport was hacken goed voor ongeveer 99,25% van het totale verlies aan crypto. Met andere woorden, ongeveer $409.906.947 ging verloren door hacking. Daarentegen is slechts 0,75% van de cryptoverliezen het gevolg van oplichting.</p>
<p>Lees ook: <a href="https://www.gate.io/blog/1275/why-many-crypto-assets-are-falling" target="_blank">Waarom veel cryptomiddelen dalen</a></p>
<h2 id="h2-Crypto20Security20Rapport20Verliezen20dalen20met204020op20jaarbasis214879"><a name="Crypto Security Rapport: Verliezen dalen met 40% op jaarbasis" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Security Rapport: Verliezen dalen met 40% op jaarbasis</h2><p>Hoewel de verliezen van Q3 in cryptovaluta erg hoog lijken, is er een daling van 40% in de hoeveelheid gestolen digitale activa ten opzichte van Q3 2023. Volgens het Immunefi-rapport is de beveiliging van cryptovaluta aanzienlijk verbeterd tijdens Q3 2024. Dit komt doordat er een daling is geweest in de hoeveelheid gestolen digitale valuta. Als voorbeeld, tijdens Q3 2023 bedroegen de totale verliezen van cryptovaluta $685 miljoen. Aan de andere kant was er tijdens Q2 van dit jaar een totaal verlies van $572 miljoen. Daarom is het aantal glen van cryptovalutafraude in het algemeen met 86% afgenomen.</p>
<p>Het goede nieuws is dat er een significante <a href="https://www.gate.io/learn/course/crypto-security-fraud-safety-and-hack" target="_blank">afname van fraudeglen in crypto</a>. De afname van cryptoverliezen geeft aan dat veel cryptocurrency-projecten hun blockchain-beveiligingsmaatregelen hebben verbeterd. Het is echter belangrijk om op te merken dat <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> hacks en <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> kettingverliezen zijn relatief hoog gebleven. Meer dan de helft van de crypto-hacks zijn in specifieke termen <a href="https://www.gate.io/blog/1008/15-biggest-crypto-hacks-and-heists" target="_blank">gebeurde op Ethereum en BNB ketens</a> <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> heeft 15 succesvolle aanvallen ondergaan en de BNB-keten had 8 incidenten. Ook andere blockchains die werden geschonden zijn onder andere Base, Blast. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, en Arbitrum. Het feit dat de meeste eerder sterk getroffen blockchains niet meer op de lijst staan, toont aan dat ze hun maatregelen voor de bescherming van crypto-activa mogelijk hebben verbeterd.</p>
<h2 id="h2-Decentrale20versus20gecentraliseerde20financin20waar20de20risicos20liggen781456"><a name="Decentrale versus gecentraliseerde financiën: waar de risico’s liggen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Decentrale versus gecentraliseerde financiën: waar de risico’s liggen</h2><p>De huidige trends in crypto-diefstal tonen aan dat gecentraliseerde beurzen meer digitale activa hebben verloren dan gedecentraliseerde beurzen. Bijvoorbeeld vond ongeveer 74,8% van de verliezen van crypto’s die plaatsvonden tijdens Q3 plaats op <a href="https://www.gate.io/learn/articles/whats-cefi/288 &quot;Centralized Finance (CeFi" rel="nofollow noopener noreferrer" target="_blank">Gecentraliseerde Financiën (CeFi) platformen</a> Dit betekent dat DeFi-aanvallen slechts 25,20% van het totale verlies voor het derde kwartaal vertegenwoordigden. Het geeft ook aan dat er een verbetering is geweest in de beveiliging van gedecentraliseerde financiën.</p>
<p>Over het algemeen kwam het grootste deel van de verliezen van CeFi voort uit de crypto-hacks van WazirX, een Indiase cryptobeurs - die in juli $235 miljoen verloor - en BingX, een in Singapore gevestigde beurs - die begin september $52 miljoen verloor. Deze twee incidenten van cryptodiefstal zijn goed voor ongeveer 69,5% van alle verliezen in het derde kwartaal. Dit toont de risico’s van crypto-investeringen die voortkomen uit kwetsbaarheden in gecentraliseerde financiën. Het laat ook zien dat er behoefte is aan verbetering van de cryptobeveiliging van de sector.</p>
<p>Naar aanleiding van het laatste rapport zei Mitchell Amador, CEO van Immunefi: “We zien een hoger aantal incidenten.” <a href="https://www.gate.io/learn/articles/what-is-defi/2815" target="_blank">richt zich op DeFi</a>, terwijl CeFi minder incidenten heeft maar vaak met ernstigere gevolgen, met honderden miljoenen gestolen fondsen in een enkele aanval. In CeFi is het grootste infrastructuurprobleem het beheer van privésleutels, wat essentieel is voor het behoud van de zelfbewaring van crypto-activa, maar doorgaans niet wordt onderworpen aan beveiligingsaudits.”</p>
<h2 id="h2-Overzicht20van20de20grootste20beveiligingshack20van20BingX20in20Q3800295"><a name="Overzicht van de grootste beveiligingshack van BingX in Q3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Overzicht van de grootste beveiligingshack van BingX in Q3</h2><p>Zoals gezegd waren de grootste CeFi-verliezen het gevolg van crypto hacks van BingX en WazirX. In feite werd WazirX gehackt. <a href="https://www.gate.io/learn/articles/gate-research-bitcoin-retraces-to-the-63000-support-level-wazirx-suffers-over-230-million-loss-due-to-attack/3567" target="_blank">op 18 juli en verloor ongeveer $235 miljoen</a>. De beruchte door Noord-Korea gesteunde hackersgroep, Lazarus Group, <a href="https://www.gate.io/blog/3836/un-alleges-north-korea-s-involvement-in-3-billion-crypto-heist" target="_blank">wordt daarvoor beschuldigd</a>. Aan de andere kant, op 20 september werd BingX gehackt en verloor $52 miljoen aan digitale activa. Tijdens de aanval verloor de exchange $13,25 miljoen aan Ether (ETH), $4,4 miljoen aan <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>(USDT) en $2,3 miljoen aan Binance Coin (BNB), onder andere digitale valuta. Deze inbraken maakten deel uit van een reeks aanvallen gericht op gecentraliseerde beurzen in Azië. In september verloor Indodax, een Indonesische beurs, ook $20,58 miljoen aan hackers, terwijl in mei de aanval plaatsvond op Japan’s DMM. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> leidde tot een verlies van digitale activa ter waarde van ongeveer $305 miljoen. Al deze incidenten tonen aan dat crypto-uitwisselingen, zowel gecentraliseerd als gedecentraliseerd, hun moeten verbeteren. <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">web3</a> ecosysteemveiligheid.</p>
<h2 id="h2-De20rol20van20zelfbewaring20bij20het20voorkomen20van20cryptoverliezen561930"><a name="De rol van zelfbewaring bij het voorkomen van cryptoverliezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De rol van zelfbewaring bij het voorkomen van cryptoverliezen</h2><p>Na grote verliezen van crypto op gedecentraliseerde en gecentraliseerde beurzen, zelfbewaring in crypto <a href="https://www.gate.io/learn/articles/blockchain-inion-fraud-schemes-and-how-to-prevent-them/3092" target="_blank">kan helpen bij het verminderen van crypto fraude</a> en bij het beveiligen van crypto-activa. Het zelf bewaren van digitale activa is belangrijk omdat het hebben van digitale activa hun beveiliging vergroot. Gebaseerd op <a href="https://www.gate.io/learn/articles/hidden-dangers-that-cannot-be-ignored-the-security-challenges-and-threats-of-btc-layer-2-technology/3874" target="_blank">huidige cryptobeveiligingstrends om digitale activa in hardware wallets te houden</a> verkleint de kans dat ze door hacking verloren gaan. Over het algemeen richten hackers en fraudeurs zich op grote crypto-projecten die enorme hoeveelheden digitale activa aanhouden. Ze besteden minder tijd aan het targeten van individuele wallets, vooral hard wallets en andere persoonlijke cold storage faciliteiten.</p>
<p>Met zelfbeheer behoud je je privésleutels en zaadzinnen, waardoor er heel weinig ruimte is voor onbevoegde personen om er toegang toe te krijgen. Ten slotte verbetert zelfbeheer je persoonlijke privacy omdat niemand gemakkelijk je digitale bezittingen en transacties kan detecteren. Met zelfbeheer kun je verschillende maatregelen nemen ter verbetering van de beveiliging van crypto, zoals het gebruik van biometrische en tweefactorauthenticatie die essentiële kenmerken zijn voor het beveiligen van cryptoactiva.</p>
<h2 id="h2-Conclusie853047"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Tijdens het derde kwartaal van het jaar verloor de crypto sector crypto activa ter waarde van $412 miljoen aan hackers en fraudeurs. Hoewel de slechte actoren voornamelijk gedecentraliseerde beurzen als doelwit hadden, leden gecentraliseerde beurzen meer crypto verliezen. De gehackte blockchains omvatten Ethereum, <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> chain, Base, Blast, <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> en Arbitrum. Het is ten zeerste aan te raden voor crypto gebruikers om hun digitale activa te beheren met behulp van zelfbeheer.</p>
<div class="blog-details-info"><br><div>Auteur: Mashell C., Gate.io Onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voorbehouden aan dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>