Tm92ZW1iZXIgQ3J5cHRvLWluY2lkZW50ZW46IEdlYnJ1aWtlcnMgbGlqZGVuIHp3YXJlIHZlcmxpZXplbiB2YW4gJDM1NiBtaWxqb2VuIGFscyBnZXZvbGcgdmFuIGhhY2tzLCBwaGlzaGluZyBlbiBydWctcHVsbHM=

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""><br>Kwaadwillende actoren hebben in november 2023 meer dan $356 miljoen aan cryptocurrencies gestolen.</p>
<p>Crypto hacks hebben geleid tot verliezen ter waarde van $335,63 miljoen, phishing scams ongeveer $14,6 miljoen en rugpulls ongeveer $6,3 miljoen.</p>
<p>Om hacks en andere crypto misdaden te voorkomen, moeten DeFi-projecten hun cryptobeveiligingsmaatregelen verbeteren door tijdige audits uit te voeren.</p>
<p>Trefwoorden: crypto-tapijtrekken, crypto-hackers, crypto-criminaliteit, crypto-verliezen, crypto-beveiligingstips, crypto-hacks, crypto-phishing, phishing-scams, crypto-oplichter, crypto-zwendel, crypto-fraude</p>
<h2 id="h2-Introductie535452"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Investeren in cryptocurrencies brengt verschillende risico’s met zich mee, waaronder hoge prijsvolatiliteit, hacks. <a href="https://www.gate.io/blog_detail/1425/what-is-phishing-and-how-to-protect-ourselves-from-phishing-attacks" target="_blank">phishing</a> en rugtrekkingen, onder anderen. Crypto-hacks en rugtrekkingen worden niet gelijkmatig verspreid over het hele jaar. Ze komen voor tijdens bepaalde perioden of crypto-seizoenen.</p>
<p>In 2023 <a href="https://www.gate.io/blog_detail/1008/15-biggest-crypto-hacks-and-heists" target="_blank">er waren veel hacks</a> Er waren verschillende glen van oplichting, rug pulls en phishing incidenten in november. In dit artikel bespreken we enkele van deze incidenten. We zullen ook manieren verkennen waarop crypto-investeerders zich kunnen beschermen tegen dergelijke risico’s.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2158/the-biggest-crypto-heist-in-history" target="_blank">De Grootste Crypto Roof in de Geschiedenis</a></p>
<h2 id="h2-Toename20van20hacks20rugpulls20en20phishingincidenten20in20november878864"><a name="Toename van hacks, rugpulls en phishing-incidenten in november" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Toename van hacks, rugpulls en phishing-incidenten in november</h2><p>November kende veel incidenten van hacks, rugpulls en phishing, wat resulteerde in verlies van cryptocurrencies ter waarde van meer dan $356 miljoen. Sterker nog, er waren in totaal 26 crypto-beveiligingsincidenten gedurende de maand.</p>
<p>Samengevat, hackaanvallen hebben geleid tot een verlies van ongeveer $335,63 miljoen, phishing scams ongeveer $14,6 miljoen en rugpulls ongeveer $6,3 miljoen. Opmerkelijk is dat de verliezen als gevolg van inbreuken en scams in november met 6,9% zijn gestegen ten opzichte van oktober.</p>
<h2 id="h2-Verlies20door20hackaanvallen84433"><a name="Verlies door hackaanvallen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verlies door hackaanvallen</h2><p>Zoals hierboven opgemerkt, was een groot deel van het verlies door exploits en andere kwaadaardige acties te wijten aan hacks. Er waren twee ernstige hackincidenten waarbij in elk g meer dan $100 miljoen aan crypto-activa verloren ging.</p>
<p>Specifiek verloor Poloniex, een crypto-beurs, $126 miljoen terwijl hackers cryptocurrencies ter waarde van $100 miljoen stalen van HTX, voorheen <a href="/price/huobi-ht" rel="nofollow noopener noreferrer" target="_blank">Huobi</a> Global. HECO-brug, een cross-chain brug die verbonden is met HTX, heeft $110 miljoen aan crypto-activa verloren. Deze incidenten vormden ongeveer 66% van de totale verliezen als gevolg van slechte actoren in november.</p>
<p>Voorbeelden van DeFi-projecten die gehackt zijn, zijn KyberSwap en Raft Fi. De belangrijkste factor voor succesvolle hacks waren slechte beveiligingsmaatregelen voor slimme contracten.</p>
<h2 id="h2-Phishing20Scams897094"><a name="Phishing Scams" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Phishing Scams</h2><p>In totaal hebben phishing scams geleid tot het verlies van crypto-activa die meer dan $1 miljoen overschrijden. In eenvoudige bewoordingen omvatten phishing scams het frauduleus verkrijgen van persoonlijke of platformgegevens zoals privésleutels. Voorbeelden van getroffen platforms zijn <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a>, KyberSwap, Poloniex, HTX en CoinSpot.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/how-to-protect-yourself-from-seed-phrase-scams/59" target="_blank">Hoe uzelf te beschermen tegen zaadzin oplichting</a></p>
<h2 id="h2-Gecentraliseerde20en20gedecentraliseerde20beurzen63876"><a name="Gecentraliseerde en gedecentraliseerde beurzen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gecentraliseerde en gedecentraliseerde beurzen</h2><p>De kwaadwillige actoren hebben zowel gecentraliseerde beurzen (CEXs) als gedecentraliseerde (DEXs) beurzen uitgebuit, wat heeft geleid tot verlies van crypto-activa. Kortom, deze crypto-beurzen hebben alleen al in november in totaal $215 miljoen verloren. Zoals hierboven benadrukt, behoren dYdX, KyberSwap, Poloniex, HTX en CoinSpot tot de getroffen beurzen. Deze beurzen moeten hun beveiligingsen verbeteren om soortgelijke uitbuitingen in de toekomst te voorkomen.</p>
<h2 id="h2-Hoe20de20exploits20plaatsvonden774252"><a name="Hoe de exploits plaatsvonden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe de exploits plaatsvonden</h2><p>Eerder hebben we enkele hackincidenten genoemd die hebben geleid tot verlies van geld. Laten we nu een paar van deze hack- en phishingincidenten in detail analyseren.</p>
<p><strong>Kronos Research</strong>: Op 19 november hebben crypto hackers Kronos Research uitgebuit, wat heeft geleid tot verlies van cryptocurrencies ter waarde van $25,65 miljoen. De hackers hebben de API-sleutels van Kronos gecompromitteerd.</p>
<p>Het verloor verschillende crypto-activa, waaronder USDC, ETH en USDT in het proces. API-sleutels zijn een alternatief voor wachtwoorden of een vorm van authenticatie. Daarom kan iedereen die toegang heeft tot de API’s van op blockchain gebaseerde projecten hun digitale activa bereiken.</p>
<p><strong>Kanton Poloneix</strong>: Gedurende dezelfde maand, november, heeft een crypto hacker Poloneix, een cryptocurrency exchange, misbruikt door munten en tokens ter waarde van $126 miljoen te stelen. Sterker nog, de slechte acteur heeft toegang gekregen tot de privésleutels van de exchange voor hot wallets.</p>
<p>Het feit is dat zodra een hacker toegang heeft tot de privésleutel van de digitale portemonnee van een individu of organisatie, hij/zij tokens vanuit de portemonnee kan verzenden. Op basis van de manier waarop de aanval zich ontvouwde, geloven sommige analisten dat de Lazarus Group, verbonden met de Noord-Koreaanse regering, verantwoordelijk was voor de exploitatie.</p>
<p><strong>KyberSwap</strong> De hacker viel KyberSwap Elastic aan, waardoor hij/zij cryptocurrencies ter waarde van ongeveer $48 miljoen kon bemachtigen. In dit g manipuleerde de aanvaller prijsverschillen tussen verschillende crypto-markten. Met andere woorden, het was een directe aanval op de liquiditeitspools van de beurs. Deze fout had echter voorkomen kunnen worden door middel van smart contract auditing.</p>
<p><strong>Aanval op dYdX</strong>: Met deze cryptocriminaliteit heeft de aanvaller 40% van het verzekeringsfonds leeggehaald dat wordt gebruikt om gebruikers te beschermen tegen het ondersteunen van verliezende transacties van andere handelaren.</p>
<p>Specifiek manipuleerde de hacker de Yearn Token-markt, die normaal gesproken zeer lage handelsvolumes heeft. Hij/zij maakte gebruik van de tekortkomingen in het risicobeheersysteem van dYdX.</p>
<p><strong>HTX Exchange</strong>: Op 22 november verloor de HTX-beurs cryptocurrencies ter waarde van meer dan $13,6 miljoen als gevolg van gecompromitteerde hot wallets. De meeste cryptocurrencies werden omgezet in ETH en weggehaald uit zijn drie wallets. In totaal verloor de beurs 78 miljoen USDC, 1.240 ETH, 62.200 <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a> en 7,3 miljoen USDT.</p>
<h2 id="h2-Andere20DeFiplatforms20die20cryptocurrencies20hebben20verloren310623"><a name="Andere DeFi-platforms die cryptocurrencies hebben verloren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Andere DeFi-platforms die cryptocurrencies hebben verloren</h2><p>Er zijn nog veel meer DeFi-platforms die veel crypto-activa hebben verloren. De volgende tabel geeft enkele van hen weer en de verschillende oorzaken van de exploits.</p>
<p><img src="https://gimg2.gateimg.com/image/article/17024392641.png" alt=""><br>November Crypto Hacks en Verliezen - Defillama</p>
<p>Het is belangrijk op te merken dat de bovenstaande lijst niet uitputtend is wat betreft de crypto misdaden die plaatsvonden in november. Het omvat echter de belangrijkste voor die maand.</p>
<h2 id="h2-Phishing20Scams20en20Rugpulls726442"><a name="Phishing Scams en Rugpulls" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Phishing Scams en Rugpulls</h2><p>Afgezien van de lijst met crypto-hacks die we tot nu toe hebben opgesomd en besproken, waren er in november verschillende andere phishing-zwendel en rugpulls. Op 15 november verloor een portemonnee bijvoorbeeld 3,4 miljoen dollar als gevolg van phishing. De eigenaar werd verleid om te ondertekenen wat de crypto-oplichter een “increaseAllowance”-transactie noemde.</p>
<p>Op 23 november vond er een ‘rug pull’ plaats op de <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> keten waar een “deployer” liquiditeit ter waarde van $1,7 miljoen heeft verwijderd. Ook kondigde Inferno Drainer, een frauduleuze dienstverlener, op 27 november aan dat het ging sluiten. Bij dat crypto-zwendelincident verloren gebruikers crypto-activa ter waarde van meer dan $80 miljoen.</p>
<p>Opnieuw vond er een rug pull plaats op het BNB-netwerk op 30 november toen het Fuding Token-project werd gesloten en er meer dan $520.000 verdween. <a href="https://www.gate.io/blog_detail/488/" target="_blank">er zijn andere rug pulls</a> en phishing scams die we hier niet hebben vermeld.</p>
<p>Na het bespreken van de bovengenoemde crypto misdrijven en de gerelateerde crypto verliezen, is het duidelijk dat zowel DeFi-projecten als hun gebruikers verschillende maatregelen moeten nemen om vergelijkbare glen in de toekomst te voorkomen.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/blog_detail/3094/daily-news-a-new-vulnerability-in-ios-16-may-cause-crypto-devices-to-be-hacked-north-korean-hackers-stolen-over-200m-in-crypto-in-2023-7-trending-tokens-are-about-to-be-unlocked" target="_blank">Noord-Koreaanse hackers hebben in 2023 meer dan $200 miljoen aan crypto gestolen</a></p>
<h2 id="h2-Tips20voor20cyberbeveiliging20van20Gateioexperts287632"><a name="Tips voor cyberbeveiliging van Gate.io-experts" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tips voor cyberbeveiliging van Gate.io-experts</h2><p>Er is geen twijfel dat sommige van de cryptozwendel en misdaadglen die we hebben besproken, vermeden hadden kunnen worden door sterke beveiligingsmaatregelen. Dit komt omdat de meeste van de gecompromitteerde DeFi-platforms gebreken hadden in hun slimme contracten.</p>
<p>Lees ook: <a href="https://www.gate.io/learn/articles/what-is-cryptojacking/871" target="_blank">Wat is Cryptojacking?</a></p>
<p>Om incidenten met cryptocriminaliteit te verminderen, moeten deze DeFi-projecten daarom regelmatige beveiligingsaudits en duidelijke plannen hebben om noodsituaties aan te pakken in g van crypto-hacks en andere crypto-misdaden. Ze moeten hun werknemers ook opleiden op het gebied van beveiligingskwesties.</p>
<p>Bovendien is het belangrijk om voortdurend controles uit te voeren wanneer hun slimme contracten actief zijn. Belangrijker nog, de projecten moeten hun private key management en verbeteren. Dergelijke maatregelen kunnen helpen om het aantal crypto-beveiligingsincidenten en de crypto-verliezen die ze lijden bij systeembroaches te verminderen.</p>
<h2 id="h2-Crypto20beveiligingstips20voor20gebruikers986002"><a name="Crypto beveiligingstips voor gebruikers" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto beveiligingstips voor gebruikers</h2><p>Crypto-gebruikers moeten waakzaam blijven bij het online werken om <a href="https://www.gate.io/learn/course/crypto-security-fraud-safety-and-hack" target="_blank">vermijd beveiligingsvallen zoals phishing</a>. In feite hebben phishing-oplichters als doel toegang te krijgen tot de persoonlijke gegevens van gebruikers, waaronder e-mailadressen, privésleutels en seed-zinnen. Ze gebruiken verschillende methoden om dergelijke gegevens te verkrijgen.</p>
<p>Om phishing te voorkomen, moeten gebruikers vermijden om links te openen die zijn verzonden door mensen die ze niet kennen. Het is ook belangrijk om niet te reageren op e-mails van onbekende afzenders. Daarnaast, geef nooit mensen uw pincodes, 2FA-codes en privésleutels, wat er ook gebeurt. Dat zal uw digitale activa beschermen.</p>
<p>En geef nooit uw belangrijke informatie aan websites waarvan u de eigenaars en doeleinden niet kent. In het verleden vielen bijvoorbeeld veel gebruikers ten prooi aan nep-airdrops, waardoor ze hun digitale activa verloren.</p>
<p>Een andere belangrijke zaak is om het gebruik van openbare Wi-Fi te vermijden bij het doen van crypto transacties of bij het gebruik van elektronische apparaten die essentiële informatie bevatten, zoals privésleutels en wachtwoorden. Als u gebruik maakt van een openbare Wi-Fi, zorg er dan voor dat u een VPN gebruikt en nooit pop-upvensters opent.</p>
<p>Men moet altijd vasthouden aan alledaagse beveiligingsmaatregelen zoals het gebruik van sterke wachtwoorden en deze regelmatig wijzigen. Bovendien is het altijd verstandig om uw applicaties en browsers bij te werken, aangezien dit het verbeteren van uw beveiligingsmaatregelen met zich meebrengt. Op dezelfde manier is het zeer verstandig om de meeste van uw digitale activa op te slaan in cold wallets.</p>
<p>Elke belegger moet ook weten hoe hij rugpulls kan identificeren en veilig kan blijven. Het is bijvoorbeeld zeer belangrijk om te investeren in gerenommeerde blockchain-platforms zoals crypto-uitwisselingen. Dit komt doordat de meeste uitwisselingen grondig zijn in het beoordelen van de cryptocurrencies die ze vermelden.</p>
<p>Bovendien, als u nieuw bent in cryptocurrencies, is het beste wat u kunt doen investeren in gevestigde cryptocurrencies zoals <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en ETH. Nogmaals, sommige beurzen hebben hun eigen munten en tokens zoals <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> en Gate Coin die veiliger zijn dan andere. Proberen te investeren in pas gelanceerde cryptocurrencies kan leiden tot veel verlies.</p>
<h2 id="h2-Conclusie356530"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>In november 2023 was de slechtste maand op het gebied van cryptocriminaliteit zoals hacks, rug pulls en phishing scams. DeFi-projecten en crypto-investeerders hebben meer dan $356 miljoen aan cryptoverliezen geleden als gevolg van beveiligingsinbreuken en cryptofraude. DeFi-projecten kunnen dergelijke misdaden voorkomen door hun cryptobeveiligingsmaatregelen te verbeteren.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Onderzoeker bij Gate.io<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 op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>