SW5zaWRlciBFeHBsb2l0cyBTb2xhbmEncyBNZW1lIENvaW4gUGxhdGZvcm0sIFB1bXAuZnVuLCB2b29yICQyIG1pbGpvZW4=

2024-05-29, 06:20

<p><img src="https://gimg2.gateimg.com/image/article/1716963180sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR993662"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Pump.fun verloor crypto-activa ter waarde van ongeveer $2 miljoen bij een beveiligingsinbreuk in DeFi.</p>
<p>Jarret, de voormalige werknemer van Pump.fun, heeft gestolen tokens als airdrop uitgedeeld aan leden van verschillende cryptogemeenschappen.</p>
<p>Slothana, DogWifHat, Bonk, Sealana, Smog ($SMOG) en Lucky Boo (BOO) zijn voorbeelden van toonaangevende memecoins op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> blockchain.</p>
<h2 id="h2-Introductie793644"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Ondanks het aantal jaren dat de DeFi-sector bestaat, is er nog steeds kwaadwillige uitbuiting aan de gang vanwege de slechte beveiligingsmaatregelen van cryptoplatforms. Een van de positieve dingen die we het afgelopen jaar hebben gezien, is echter een toename van de samenwerking tussen wetshandhavers en DeFi-projecten wanneer er een crypto-overval plaatsvindt. Vandaag beoordelen we hoe de crypto-overval in Pump.fun plaatsvond en de implicaties ervan voor de hele DeFi-sector.</p>
<h2 id="h2-Hoe20Pumpfun20slachtoffer20werd20van20een20220miljoen20diefstal486753"><a name="Hoe Pump.fun slachtoffer werd van een $2 miljoen diefstal" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe Pump.fun slachtoffer werd van een $2 miljoen diefstal</h2><p>Pump.fun, <a href="https://www.gate.io/learn/articles/what-s-behind-solana-s-biggest-meme-launch-platform-pump-fun/2671" target="_blank">een op Solana gebaseerd DeFi mememuntprotocol</a>, werd op 16 mei geschonden, wat leidde tot een verlies van cryptocurrencies ter waarde van ongeveer $2 miljoen. De exploitant gebruikte in feite flash-leningen om de binding curve-contracten van het protocol te manipuleren.</p>
<p>Na de aanval gebruikte Pump.fun zijn sociale mediaplatforms om zijn gebruikers te waarschuwen voor de DeFi-beveiligingsinbreuk. Via zijn <a href="https://twitter.com/pumpdotfun/status/1791164438852083807?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Etweet" rel="nofollow noopener noreferrer" target="_blank">Profiel van het X-platform zei het team</a>“We hebben de contracten geüpgraded, zodat de aanvaller geen geld meer kan aftappen. De TVL in het protocol is op dit moment veilig. We hebben de handel gepauzeerd - je kunt op dit moment geen munten kopen en verkopen. Munten die momenteel bezig zijn met migreren naar Raydium kunnen niet worden verhandeld en zullen voor onbepaalde tijd niet migreren.”</p>
<p>Op basis van hoe de aanval plaatsvond, geloofden sommige leiders in de industrie dat de flash-leningexploit van Pump.fun een interne crypto-aanval was. In dit verband zei Igor Igamberdiev, hoofd onderzoek bij Wintermute, <a href="https://twitter.com/FrankResearcher/status/1791164323047293325" rel="nofollow noopener noreferrer" target="_blank">gereageerd</a>: “Het lijkt erop dat pumpdotfun ongeveer 2k SOL ($300k+) en een heleboel memecoins heeft verloren door mogelijke lekkage van privésleutels.”</p>
<p>Echter, na een paar uur beloofde het Pump.fun-team zijn investeerders dat het zijn slimme contract had geüpgraded om soortgelijke toekomstige aanvallen te voorkomen. Het <a href="https://www.bitget.com/news/detail/12560604005265" rel="nofollow noopener noreferrer" target="_blank">schreef</a>“We hebben de contracten geüpgraded zodat de aanvaller geen geld meer kan weghalen. De TVL in het protocol is op dit moment veilig. We hebben de handel gepauzeerd - je kunt op dit moment geen munten kopen en verkopen.”</p>
<p>Het voegde eraan toe: “Alle munten die momenteel bezig zijn met migreren naar Raydium kunnen niet worden verhandeld en zullen voor onbepaalde tijd niet migreren.”</p>
<p>Echter, de handel op het platform werd 5 uur na de <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Pump.fun aanval hervat. Vanwege de ongemakken die voortvloeiden uit de aanval heeft het team de handelskosten voor de komende zeven dagen geschrapt. Ook beloofde het de liquiditeitspools (LP’s) voor getroffen tokens te zaaien om de handelsfunctionaliteit te herstellen.</p>
<p><a href="https://twitter.com/pumpdotfun/status/1791235050643636303" rel="nofollow noopener noreferrer" target="_blank">Het team heeft het probleem opgehelderd</a>“Je kunt nieuwe munten lanceren en elke munt verhandelen die niet 100% heeft bereikt tussen 15:21-17:00 UTC. Om gebruikers volledig te compenseren, zal elke munt die tussen 15:21-17:00 UTC 100% heeft bereikt, live gaan op Raydium met &gt;= 100% van de liquiditeit die het eerder had.”</p>
<p>Het ging verder: “We zijn toegewijd om de veiligheid van onze gebruikers te waarborgen en werken samen met relevante partijen, inclusief wetshandhavingsinstanties, om de schade te minimaliseren.”</p>
<h2 id="h2-Flashleningen20en20slimme20contracten20Het20uitpakken20van20de20Pumpfun20Exploitatie712731"><a name="Flashleningen en slimme contracten: Het uitpakken van de Pump.fun Exploitatie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Flashleningen en slimme contracten: Het uitpakken van de Pump.fun Exploitatie</h2><p>Zoals hierboven aangegeven, was de memecoin-platform exploit het resultaat van de manipulatie van de Margin.fi flash-lening faciliteit. In de eerste plaats had de slechte acteur toegang tot tokens van de Margin.fi en verwierf SOL. Van daaruit gebruikte hij SOL om de Pump.fun-tokens te kopen. In het proces gebruikte hij zelfs geen eigen geld.</p>
<p>Opmerkelijk genoeg duwde de transactie de bonding curve tot zijn limiet. Voor achtergrondinformatie is de bonding curve een smart contract voor het creëren van een markt voor tokens zonder gebruik te maken van crypto exchanges. Hierdoor werd voorkomen dat de tokens werden genoteerd aan de Raydium gedecentraliseerde exchange gebaseerd op het Solana blockchain.</p>
<h2 id="h2-De20identiteit20en20motieven20van20de20aanvaller371050"><a name="De identiteit en motieven van de aanvaller" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De identiteit en motieven van de aanvaller</h2><p>In eerste instantie werd de aanvaller geïdentificeerd aan de hand van zijn wallet-adres, 7ihN8QaTfNoDTRTQGULCzbUT3PHwPDTu5Brcu4iT2paP. Later werd hij geïdentificeerd als Jarrett, ook bekend onder zijn X-gebruikersnaam, STACCOverflow. Jarret is de voormalige werknemer van Pump.fun die ontevreden leek over de manier waarop het team het gedecentraliseerde financiële (DeFi) project runt. Het bericht van Jarret op het sociale platform X wijst op zijn met voorbedachten rade gepleegde Solana-aanval Pump.fun, zoals de volgende schermafbeelding laat zien.<br><img src="https://gimg2.gateimg.com/image/article/1716963512a.jpeg" alt=""><br>Bron: <a href="https://twitter.com/STACCoverflow/status/1791134470071865576" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Op basis van de socialmediaberichten van Jarret was zijn voornaamste motief voor de beveiligingsinbreuk in het Solana-ecosysteem om zijn voormalige bazen te straffen voor hun oneerlijke en onprofessionele gedrag tijdens de uitvoering van hun taken. Hij toonde zijn negatieve gevoelens jegens zijn ex-bazen via zijn X-bericht, zoals blijkt uit de volgende afbeelding.<br><img src="https://gimg2.gateimg.com/image/article/1716963546b.jpeg" alt=""><br>Bron: <a href="https://twitter.com/STACCoverflow/status/1791134474387808363" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<h2 id="h2-De20Web320Robinhood20Het20plan20van20de20aanvaller20om20rijkdom20te20herverdelen427317"><a name="De Web3 Robinhood? Het plan van de aanvaller om rijkdom te herverdelen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> Robinhood? Het plan van de aanvaller om rijkdom te herverdelen</h2><p>In een van zijn X-posts verklaarde Jarret dat hij de DeFi-buit zou herverdelen, wat hem de bijnaam Web3 Robin Hood opleverde. Zoals beloofd verdeelde Jarret de gestolen cryptocurrency onder leden van verschillende cryptogemeenschappen, waaronder Slerf, Stacc, Saga en Risklol. Als gevolg hiervan plaatste een van de gemeenschapsleden de volgende opmerking zoals weergegeven in de afbeelding.<br><img src="https://gimg2.gateimg.com/image/article/1716963578c.jpeg" alt=""><br>Bron: <a href="https://twitter.com/ardizor/status/1791186167645303080" rel="nofollow noopener noreferrer" target="_blank">x.com</a></p>
<p>Ondertussen hebben verschillende crypto-gebruikers uit de genoemde cryptogemeenschappen toegegeven dat ze de airdrop hebben ontvangen. Wat echter niet duidelijk is, is de exacte methode die hij heeft gebruikt om ze te distribueren.</p>
<h2 id="h2-Pas20op20voor20oplichters20Risicos20na20het20incident20met20Pumpfun737333"><a name="Pas op voor oplichters: Risico’s na het incident met Pump.fun" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pas op voor oplichters: Risico’s na het incident met Pump.fun</h2><p>De cryptogemeenschap moet waakzaam blijven na de <a href="https://www.gate.io/learn/articles/seek-the-next-crypto-trend-amid-meme-waves/2914" target="_blank">Beveiligingslek in het Pump.fun blockchain platform</a>. Dit komt doordat sommige kwaadwillende actoren zich kunnen voordoen als het Pump.fun-team dat bereid is hun tokens te vergoeden. Ze kunnen kwaadaardige links sturen waarin staat dat gebruikers hun gegevens moeten verstrekken om hun gestolen cryptocurrencies op te eisen. In een poging om te profiteren van het herstel van gestolen cryptocurrencies kunnen sommige investeerders uiteindelijk meer crypto-activa verliezen.</p>
<h2 id="h2-Lijst20van20de20beste20SOL20meme20munten881603"><a name="Lijst van de beste SOL meme munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lijst van de beste SOL meme munten</h2><p>Solana heeft veel memecoins, waarvan sommige mogelijk zijn vermeld op Pump.fun. De populaire Solana-gebaseerde meme-munten zijn onder meer Slothana, <a href="https://www.gate.io/blog_detail/4106" target="_blank">Hond met hoed</a>, Bonk, Sealana, Smog ($SMOG) en Lucky Boo (BOO).</p>
<h2 id="h2-Conclusie736995"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De voormalige werknemer van Pumpfun stal cryptocurrencies ter waarde van ongeveer $2 miljoen in een poging om zijn ex-werkgevers te straffen vanwege onprofessioneel zakelijk gedrag. Jarret verdeelde echter de gestolen tokens onder leden van verschillende cryptogemeenschappen via een airdrop. DogWifHat, <a href="https://www.gate.io/blog_detail/4041/bonk-memecoin-poised-for-a-bullish-breakout-analysis-and-predictions" target="_blank">Bonk</a>, Sealana, Smog ($SMOG) zijn voorbeelden van populaire <a href="https://www.gate.io/price/view/solana-meme-coins" target="_blank">Solana-gebaseerde memecoins</a>.</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 enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen wordt juridische actie ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>