SGV0IEdlYnJlayBpbiBBcHBsZSdzIE0tU2VyaWVzIENoaXBzOiBFZW4gTmlldXdlIFVpdGRhZ2luZyB2b29yIEVuY3J5cHRpZWJldmVpbGlnaW5n

2024-04-02, 02:54

<p><img src="https://gimg2.gateimg.com/image/article/1712026191sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR772767"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Sommige versies van Apple’s MacOS en iPad-tablets hebben gebreken in hun M-Series chips.</p>
<p>Apple zei dat zijn MacOS en iPad-tablets sterke beveiligingsmaatregelen hebben om kwaadwillige exploits te voorkomen.</p>
<p>Het is in het belang van cryptogebruikers met Apple’s MacOS en iPad-tablets met de genoemde gebreken om hun digitale activa daaruit te verwijderen.</p>
<p><strong>Trefwoorden</strong>: Apple M-serie chip kwetsbaarheid, Niet te patchen fout in encryptiebeveiliging, GoFetch exploit Apple, M1 en M2 chip beveiligingsfout, Cryptografische software Apple chips, Encryptie sleutel extractie Apple, Side-channel exploit M-serie, Apple chip beveiligingskwetsbaarheid, Digitale bedreigingen macOS, Apple encryptie fout mitigatie, crypto scam, crypto oplichters, crypto exploit</p>
<h2 id="h2-Introductie331775"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Crypto-gebruikers die computers en iPads hebben die gebruikmaken van Apple’s M1- en M2-chips, worden geconfronteerd met een beveiligingsdreiging die kan leiden tot diefstal van hun cryptocurrencies. Daarom moeten dergelijke crypto-gebruikers extra voorzichtig zijn om hun digitale activa te beschermen.</p>
<p>Dit artikel onderzoekt het gebrek in Apple’s M-serie chips en hoe gebruikers de risico’s die ze met zich meebrengen kunnen verminderen. We zullen ook bespreken hoe Apple computer- en tabletgebruikers hun digitale activa kunnen beschermen.</p>
<h2 id="h2-Ontdekking20van20de20kwetsbaarheid284140"><a name="Ontdekking van de kwetsbaarheid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ontdekking van de kwetsbaarheid</h2><p>Een groep onderzoekers heeft een ernstige kwetsbaarheid ontdekt in de M-series chips van Apple die de beveiliging van digitale activa zoals cryptocurrency die erin zijn opgeslagen, zou kunnen beïnvloeden. In een recent rapport leggen de wetenschappers van verschillende topuniversiteiten in de Verenigde Staten uit hoe cryptoscammers toegang kunnen krijgen <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Geheim</a> sleutels en andere versleutelde gegevens van MacBook-apparaten via cryptografische middelen.</p>
<p>De kwetsbaarheid bevindt zich binnen de microarchitectuur van de Apple M1- en M2-chips, waardoor het onmogelijk is om directe patches te gebruiken om het probleem op te lossen. Volgens de <a href="https://arstechnica.com/security/2024/03/hackers-can-extract-secret-encryption-keys-from-apples-mac-chips/" rel="nofollow noopener noreferrer" target="_blank">rapport, gepubliceerd op 21 maart</a>, de kwetsbaarheid is een sidechain-aanval waarmee hackers de end-to-end-encryptiesleutels van MAC kunnen verkrijgen wanneer de Apple-chips veelvoorkomende cryptografische protocollen uitvoeren.</p>
<h2 id="h2-Het20begrijpen20van20de20niet20te20patchen20aard769236"><a name="Het begrijpen van de niet te patchen aard" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het begrijpen van de niet te patchen aard</h2><p>Zoals hierboven aangegeven, is de kwetsbaarheid van de Apple-chip onherstelbaar omdat deze is ingebed in het microarchitecturale silicium zelf. In feite gebruikt het systeem de op gegevensgeheugen gebaseerde prefetcher (DMP) in deze chips om gegevens te voorspellen en vooraf te laden, evenals om de CPU- en geheugenlatentie te minimaliseren.</p>
<p>Echter, door het ontwerp interpreteert de DMP vaak ten onrechte de inhoud van het geheugen als pointer-adressen, wat leidt tot gegevenslekken via zijkanalen. Daarom kunnen aanvallers profiteren van deze prefetcher-fouten door inputs te bedenken die de DMP herkent als adressen die leiden tot het lekken van versleutelingskeys. Dit proces is een belangrijk <a href="https://www.gate.io/blog_detail/3946/week-in-ethereum-news-the-latest-ethereum-news-and-upcoming-events-this-week" target="_blank">aspect van de GoFetch-aanval</a>.</p>
<p>Dit proces uitleggen, <a href="https://twitter.com/OwenGregorian/status/1771148025802493965" rel="nofollow noopener noreferrer" target="_blank">de onderzoekers zeiden</a> Ons belangrijkste inzicht is dat terwijl de DMP alleen verwijzingen dereferenceert, een aanvaller programmatoetsen kan maken zodat wanneer die invoer mengt met cryptografische geheimen, de resulterende tussenstaat kan worden geëngineerd om op een verwijzing te lijken alleen als het geheim voldoet aan een door de aanvaller gekozen predicaat.</p>
<p>De reden waarom de kwetsbaarheid niet kan worden gepatcht, is dat deze zich bevindt in de chips van Apple, niet in de software. Daarom hebben de onderzoekers geadviseerd dat de beste oplossing is om nieuwe cryptografische software Apple chips te produceren. Als alternatief is er behoefte aan cryptografische software van derden die de prestaties van de Apple M-serie chips beheert om het beveiligingsprobleem van de M1- en M2-chips te voorkomen.</p>
<h2 id="h2-De20GoFetch20Exploit20Uitgelegd831247"><a name="De GoFetch Exploit Uitgelegd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De GoFetch Exploit Uitgelegd</h2><p>De GoFetch-exploit verwijst naar de kwetsbaarheid van de Apple M-serie chip waarmee hackers kunnen profiteren van de geheugentoegangspatronen om gevoelige gegevens zoals de versleutelingssleutels die cryptografische toepassingen gebruiken, te verkrijgen. In dit g vereist de hack alleen standaard gebruikersprivileges, vergelijkbaar met degene die reguliere toepassingen vereisen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1156/apple-s-venture-into-the-metaverse" target="_blank">Apple’s avontuur in de metaverse</a></p>
<p>Om het duidelijk te maken, met een GoFetch-exploit maken de hackers gebruik van de zwaktes die bestaan in de op datageheugen gebaseerde prefetchers (DMP’s). Kort gezegd zorgt het systeem ervoor dat DMP-gegevens lekken uit de cache van de kern. Het is belangrijk om te begrijpen dat een dergelijke side channel exploit M-series optreedt wanneer essentiële informatie lekt als gevolg van het ontwerp van een computerprotocol of -algoritme.</p>
<p>Bovendien kan de encryptiesleutel-extractie Apple-app de geheime sleutels delven zolang deze draait op dezelfde prestatiecluster als de doelcryptografie-app, zelfs als ze op aparte cores staan.</p>
<p>Opnieuw kan de GoFetch-applicatie van Apple binnen één uur een 2048-bits RSA-sleutel extraheren en binnen twee uur een 2048-bits Diffie-Hellman-sleutel. Aan de andere kant is ongeveer 54 minuten nodig om de benodigde gegevens te extraheren om een Kyber-512 sleutel samen te stellen en ongeveer 10 uur om een Dilithium-2 sleutel te genereren.</p>
<h2 id="h2-Afweging20tussen20mitigatie20en20prestaties726342"><a name="Afweging tussen mitigatie en prestaties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Afweging tussen mitigatie en prestaties</h2><p>Allereerst is deze Apple Chip kwetsbaarheid niet zo bedreigend als de bovenstaande uitleg lijkt aan te geven. De aanval kost meestal veel tijd, omdat het vrij moeilijk is om uit te voeren. Daarom vormt de GoFetch-exploit van Apple niet veel bedreiging voor cryptogebruikers.</p>
<p>Ten tweede moet de aanvaller om te profiteren van de onherstelbare zwakte in de versleutelingsbeveiliging eerst een kwaadaardige app installeren op de computer of iPhone. Ook is Apple standaard ontworpen om niet-toegewezen kwaadaardige apps te blokkeren die mogelijk proberen toegang te krijgen tot het computersysteem.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1691/apple-s-metaverse-ambition" target="_blank">Apple’s Metaverse Ambitie</a></p>
<p>De andere reden waarom de digitale dreiging macOS een zeer kleine kans op succes heeft, is dat het meer dan 10 uur duurt voordat de hack is voltooid. Tijdens die lange periode moet de computer continu draaien. Dit betekent dat een persoon die zijn/haar computer na ongeveer 5 uur opnieuw opstart, zo’n aanval kan dwarsbomen.</p>
<p>Aangezien het niet erg mogelijk is om de DMP’s op M1 en M2 CPU’s uit te schakelen zonder de werking van het systeem zwaar te beïnvloeden, moeten de ontwikkelaars mogelijk de software bijwerken, zodat deze automatisch de DMP’s kan uitschakelen of de activering van de sleutelafhankelijke DMP kan voorkomen.</p>
<p>Een individu kan er ook voor kiezen om alle cryptografische code op ‘Icestorm’-kernen uit te voeren, omdat ze geen DMP’s hebben. Dit kan echter de prestaties van de computer ernstig beïnvloeden. Het is ook mogelijk dat toekomstige updates van Apple dit zonder voorafgaande kennisgeving mogelijk maken.</p>
<p>Desalniettemin lijkt Apple de dreiging die de wetenschappers hebben ontdekt te bagatelliseren. Het gelooft dat er weinig kans is op een succesvolle crypto-aanval op een van zijn apparaten, omdat ze voldoende beveiligingsmaatregelen in het systeem hebben ingebouwd.</p>
<p>In <a href="https://discussions.apple.com/thread/253961435?sortBy=best" rel="nofollow noopener noreferrer" target="_blank">Op zijn communityforum zei Apple</a>, “We willen de onderzoekers bedanken voor hun samenwerking omdat deze proof of concept ons begrip van deze technieken bevordert.”</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2524/bitcoin-whitepaper-apple" target="_blank">Bitcoin Whitepaper in Elk Apple Computer</a></p>
<p>Het voegde vervolgens toe: “Op basis van onze analyse en de details die met ons zijn gedeeld door de onderzoekers, hebben we geconcludeerd dat dit probleem geen onmiddellijk risico vormt voor onze gebruikers en op zichzelf onvoldoende is om de beveiligingsbescherming van het besturingssysteem te omzeilen.”</p>
<h2 id="h2-Bredere20implicatie20voor20digitale20beveiliging198041"><a name="Bredere implicatie voor digitale beveiliging" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bredere implicatie voor digitale beveiliging</h2><p>De onderzoeksresultaten die hierboven zijn besproken, hebben de noodzaak benadrukt voor gebruikers van digitale activa om uiterst waakzaam te zijn bij het gebruik van Mac-computers en iPad-tablets die vatbaar zijn voor lekken van essentiële gegevens zoals cryptografische sleutels en wachtwoorden die ook digitale portefeuilles beveiligen. De reden hiervoor is dat zodra een hacker toegang heeft tot dergelijke informatie, hij/zij uw digitale activa kan leeghalen. Zelfs als het risico op hacken via dat proces laag is, mogen crypto-gebruikers die hun digitale activa beheren met behulp van deze apparaten de waarschuwing niet negeren.</p>
<h2 id="h2-Recente20beveiligingslekken20in20iOS20en20MacOS20die20de20kans20op20een20beveiligingsinbreuk20vergroten620847"><a name="Recente beveiligingslekken in iOS en MacOS die de kans op een beveiligingsinbreuk vergroten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recente beveiligingslekken in iOS en MacOS die de kans op een beveiligingsinbreuk vergroten</h2><p>De GoFetch-exploit is niet de enige digitale bedreiging waarmee MacOS-computers en iPad-tablets worden geconfronteerd. Onlangs <a href="https://www.kaspersky.com/blog/ios-macos-vulnerabilities-april-2023/47938/?reseller=gb_kdaily_acq_ona_smm__all_b2c_some_sma_______&amp;utm_source=twitter&amp;utm_medium=social&amp;utm_campaign=uk_kdaily_db0077&amp;utm_content=sm-post&amp;utm_term=uk_twitter_organic_b3abkzgqh77u3ud" rel="nofollow noopener noreferrer" target="_blank">Kaspersky meldde dat Apple onlangs verschillende updates heeft uitgebracht</a> als gevolg van kwetsbaarheden in zijn iOS- en macOS-apparaten, waardoor kwaadwillende actoren gevoelige gegevens en digitale activa kunnen stelen. Als gevolg van dergelijke kwetsbaarheden drong Apple er bij de gebruikers op aan om hun apparaten bij te werken naar iOS 16.4.1 en macOS 13.3.1.</p>
<p>In feite hadden deze apparaten twee bedreigingen, namelijk CVE-2023-28205 en CVE-2023-28206, die hackers in staat zouden stellen zero-click exploits uit te voeren. Hierdoor zouden de slachtoffers kunnen worden doorgestuurd naar phishing-websites waar kwaadwillende actoren hen zouden kunnen targeten met verschillende crypto-zwendeltrucs om hun digitale activa te stelen.<br>Ook zou het automatisch installeren van malware in de apparaten mogelijk zijn. Zodra er eenmaal malware is geïnstalleerd, zouden de aanvallers bepaalde codes uitvoeren en de apparaten controleren.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/1115/metamask-notifies-apple-users-over-icloud-phishing-attack" target="_blank">Metamask waarschuwt Apple-gebruikers voor iCloud-phishingaanval</a></p>
<h2 id="h2-Hoe20houd20je20jouw20crypto20veilig160843"><a name="Hoe houd je jouw crypto veilig?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe houd je jouw crypto veilig?</h2><p>Als u digitale activa bewaart op Apple’s Macs of iPad-tablet, is het beste om ze over te zetten naar een ander apparaat. U kunt ze opslaan op hardware wallets of geschikte digitale apparaten zoals Windows PC, Android-telefoons of iPhones.</p>
<p>Gerelateerd nieuws: <a href="https://www.gate.io/blog_detail/2460/security-measures-at-gateio-protecting-your-digital-assets-in-the-crypto-landscape" target="_blank">Het beschermen van uw digitale activa in het crypto-landschap</a></p>
<p>Het andere belangrijke is om te vermijden dat u toepassingen van onbekende ontwikkelaars en onbetrouwbare bronnen installeert. Als u al dergelijke apps op uw apparaat heeft, verwijder deze dan onmiddellijk om elk crypto-exploit te voorkomen.</p>
<p>Recente tips: <a href="https://www.gate.io/learn/articles/10-steps-to-keep-your-crypto-assets-safe/2162" target="_blank">10 stappen om uw crypto-activa veilig te houden</a></p>
<p>Ten slotte moeten Apple-gebruikers met de genoemde apparaten altijd aandacht besteden aan eventuele malwarewaarschuwingen die ze ontvangen. De hierboven besproken Apple-coderingsfoutmitigatie en deze beveiligingsmaatregelen kunnen u behoeden voor het verliezen van uw digitale activa.</p>
<h2 id="h2-Conclusie539761"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Een recent wetenschappelijk rapport van onderzoekers van verschillende topuniversiteiten in de Verenigde Staten heeft gewaarschuwd dat de eerdere versies van Apple’s MacOS en iPad-tablets kwetsbaarheden hebben in hun M-series chips, waardoor hackers toegang kunnen krijgen tot versleutelingssleutels en wachtwoorden. Alleen de M1, M2 en M3 chips hebben dergelijke beveiligingslekken. Het beste wat cryptogebruikers kunnen doen is hun digitale activa verwijderen van dergelijke apparaten.</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 enkel de mening 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 vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>