SWwgZGlmZXR0byBuZWkgY2hpcCBkZWxsYSBzZXJpZSBNIGRpIEFwcGxlOiB1bmEgbnVvdmEgc2ZpZGEgcGVyIGxhIHNpY3VyZXp6YSBkZWxsYSBjcml0dG9ncmFmaWE=

2024-04-02, 02:54

<p><img src="https://gimg2.gateimg.com/image/article/1712026191sdfx.jpeg" alt=""></p>
<h2 id="h2-TL20DR864467"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Alcune versioni di MacOS di Apple e tablet iPad presentano difetti nei loro chip della serie M.</p>
<p>Apple ha affermato che MacOS e i tablet iPad hanno robuste misure di sicurezza per prevenire eventuali attacchi malevoli.</p>
<p>È nell’interesse migliore degli utenti di criptovalute con MacOS di Apple e tablet iPad con i difetti citati rimuovere i loro asset digitali da essi.</p>
<p><strong>Parole chiave</strong>: Vulnerabilità del chip Apple M-series, Crittografia delle falle non riparabili, Sfrutta Apple, Vulnerabilità di sicurezza del chip M1 e M2, Crittografia del software dei chip Apple, Estrazione delle chiavi di crittografia Apple, Sfrutta il canale laterale della serie M, Vulnerabilità di sicurezza del chip Apple, Minacce digitali macOS, Mitigazione delle falle di crittografia Apple, truffa crittografica, truffatori crittografici, sfrutta la crittografia</p>
<h2 id="h2-Introduzione37203"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Gli utenti di criptovalute che hanno computer e iPad che utilizzano i chip M1 e M2 di Apple stanno affrontando una minaccia alla sicurezza che potrebbe portare a furti delle loro criptovalute. Pertanto, tali utenti di criptovalute dovrebbero fare attenzione extra per proteggere i loro asset digitali.</p>
<p>Questo articolo esplora il difetto nei chip della serie M di Apple e come gli utenti possono mitigare i rischi che essi comportano. Discuteremo anche come gli utenti di computer e tablet Apple possono proteggere i loro asset digitali.</p>
<h2 id="h2-Scoperta20della20vulnerabilit569813"><a name="Scoperta della vulnerabilità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Scoperta della vulnerabilità</h2><p>Un gruppo di ricercatori ha scoperto una grave vulnerabilità all’interno dei chip M di Apple che potrebbe influire sulla sicurezza di asset digitali come le criptovalute memorizzate al loro interno. In un recente rapporto gli studiosi delle principali università degli Stati Uniti spiegano come i truffatori delle criptovalute possono accedere… <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Segreto</a> chiavi e altri dati crittografati dai dispositivi MacBook attraverso mezzi crittografici.</p>
<p>La vulnerabilità esiste all’interno della microarchitettura dei chip M1 e M2 di Apple, rendendo impossibile utilizzare patch dirette per risolvere il problema. Secondo il <a href="https://arstechnica.com/security/2024/03/hackers-can-extract-secret-encryption-keys-from-apples-mac-chips/" rel="nofollow noopener noreferrer" target="_blank">rapporto, pubblicato il 21 marzo</a>, la vulnerabilità è un attacco a catena laterale che consente agli hacker di ottenere le chiavi di crittografia end-to-end di MAC quando i chip Apple eseguono protocolli crittografici comuni.</p>
<h2 id="h2-Comprendere20la20natura20non20riparabile194151"><a name="Comprendere la natura non riparabile" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprendere la natura non riparabile</h2><p>Come accennato in precedenza, la vulnerabilità del chip Apple è irrimediabile poiché è incisa direttamente nel silicio microarchitetturale stesso. Fondamentalmente, il sistema utilizza il prefetcher dipendente dalla memoria dei dati (DMP) in questi chip per prevedere e precaricare i dati, nonché per ridurre al minimo la latenza della CPU e della memoria.</p>
<p>Tuttavia, per design, il DMP interpreta spesso erroneamente il contenuto della memoria come indirizzi dei puntatori, il che porta a perdite di dati attraverso le catene laterali. Pertanto, gli attaccanti possono sfruttare questi errori del prefetcher attraverso la creazione di input che il DMP riconosce come indirizzi che portano alla perdita delle chiavi di cifratura. Questo processo è un <a href="https://www.gate.io/blog_detail/3946/week-in-ethereum-news-the-latest-ethereum-news-and-upcoming-events-this-week" target="_blank">aspetto dell’attacco GoFetch</a>.</p>
<p>Spiegando questo processo, <a href="https://twitter.com/OwenGregorian/status/1771148025802493965" rel="nofollow noopener noreferrer" target="_blank">i ricercatori hanno detto</a>, “La nostra intuizione chiave è che mentre il DMP dereferenzia solo puntatori, un attaccante può creare input di programma in modo che quando questi input si mescolano con segreti crittografici, lo stato intermedio risultante può essere progettato per assomigliare a un puntatore solo se il segreto soddisfa un predicato scelto dall’attaccante.”</p>
<p>La ragione per cui la vulnerabilità non può essere corretta è che essa esiste nei chip di Apple, non nel suo software. Pertanto, i ricercatori hanno consigliato che la migliore soluzione sia quella di produrre nuovi chip Apple con software crittografico. In alternativa, c’è bisogno di un software crittografico di terze parti che controlli le prestazioni dei chip Apple della serie M per prevenire i difetti di sicurezza dei chip M1 e M2.</p>
<h2 id="h2-Spiegazione20dellexploit20GoFetch402744"><a name="Spiegazione dell’exploit GoFetch" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Spiegazione dell’exploit GoFetch</h2><p>L’exploit GoFetch si riferisce alla vulnerabilità del chip Apple M-series che consente agli hacker di sfruttare i modelli di accesso alla memoria per ottenere dati sensibili come le chiavi di crittografia utilizzate dalle applicazioni crittografiche. In questo caso, l’hack richiede solo i privilegi utente standard simili a quelli richiesti dalle applicazioni regolari.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1156/apple-s-venture-into-the-metaverse" target="_blank">L’avventura di Apple nel Metaverso</a></p>
<p>Per chiarire, con un exploit GoFetch gli hacker approfittano delle debolezze che esistono nei prefetcher (DMP) dipendenti dalla memoria dei dati. Fondamentalmente, il sistema consente la fuoriuscita dei dati DMP dalla cache del core. È importante capire che un exploit di canale laterale M-series si verifica quando informazioni essenziali fuoriescono a causa del design di un protocollo o algoritmo informatico.</p>
<p>Inoltre, l’app di estrazione chiave di crittografia di Apple può estrarre le chiavi segrete fintanto che viene eseguita sullo stesso cluster di prestazioni dell’app di crittografia mirata, anche se sono su core separati.</p>
<p>Ancora, l’applicazione Apple GoFetch può estrarre una chiave RSA a 2048 bit in un’ora e una chiave Diffie-Hellman a 2048 bit in due ore. D’altra parte, richiede circa 54 minuti per estrarre i dati necessari per assemblare una chiave Kyber-512 e circa 10 ore per generare una chiave Dilithium-2.</p>
<h2 id="h2-Compromesso20tra20mitigazione20e20performance525373"><a name="Compromesso tra mitigazione e performance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Compromesso tra mitigazione e performance</h2><p>Innanzitutto, questa vulnerabilità di Apple Chip non è così minacciosa come sembra indicare la spiegazione sopra. L’attacco di solito richiede molto tempo in quanto è abbastanza difficile da portare a termine. Pertanto, l’exploit GoFetch di Apple non rappresenta una grande minaccia per gli utenti di criptovalute.</p>
<p>In secondo luogo, affinché l’attaccante possa sfruttare la debolezza della sicurezza della crittografia non riparabile, dovrebbe prima installare un’applicazione dannosa sul computer o sull’iPhone. Inoltre, per impostazione predefinita, Apple è progettata per bloccare le applicazioni dannose non assegnate che potrebbero cercare di accedere al sistema informatico.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1691/apple-s-metaverse-ambition" target="_blank">L’ambizione di Apple nel Metaverso</a></p>
<p>L’altro motivo per cui la minaccia digitale macOS ha pochissime possibilità di successo è che ci vogliono oltre 10 ore per completare l’hack. È importante notare che durante questo lungo periodo il computer deve funzionare ininterrottamente. Ciò significa che un individuo che riavvia il suo computer dopo circa 5 ore potrebbe sventare un tale attacco.</p>
<p>Poiché non è molto possibile disabilitare le DMP sui processori M1 e M2 senza influire pesantemente sul funzionamento del sistema, gli sviluppatori potrebbero dover aggiornare il software in modo che possa disabilitare automaticamente le DMP o impedire l’attivazione delle DMP dipendenti dalla chiave.</p>
<p>Un individuo può anche scegliere di eseguire tutto il codice crittografico sui core “Icestorm” poiché non hanno DMP. Tuttavia, ciò potrebbe influire in modo significativo sulle prestazioni del computer. È anche possibile che future aggiornamenti da parte di Apple possano abilitarli senza preavviso.</p>
<p>Tuttavia, Apple sembra sottovalutare la minaccia scoperta dagli studiosi. Crede che ci sia poco possibilità di successo nell’attacco crittografico su uno qualsiasi dei suoi dispositivi poiché hanno misure di sicurezza sufficienti incorporate nel sistema.</p>
<p>In <a href="https://discussions.apple.com/thread/253961435?sortBy=best" rel="nofollow noopener noreferrer" target="_blank">Nel suo forum comunitario Apple ha detto</a>“Vogliamo ringraziare i ricercatori per la loro collaborazione poiché questa prova concettuale avanza la nostra comprensione di queste tecniche.”</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2524/bitcoin-whitepaper-apple" target="_blank">Bitcoin Whitepaper in ogni computer Apple</a></p>
<p>Successivamente ha aggiunto: “Sulla base della nostra analisi e dei dettagli condivisi con noi dai ricercatori, abbiamo concluso che questo problema non rappresenta un rischio immediato per i nostri utenti e non è sufficiente per aggirare le protezioni di sicurezza del sistema operativo da solo.”</p>
<h2 id="h2-Implicazioni20pi20ampie20per20la20sicurezza20digitale742797"><a name="Implicazioni più ampie per la sicurezza digitale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Implicazioni più ampie per la sicurezza digitale</h2><p>I risultati della ricerca discussi sopra hanno evidenziato la necessità per gli utenti di asset digitali di essere estremamente vigili quando utilizzano computer Mac e tablet iPad, che sono suscettibili a perdite di dati essenziali come chiavi crittografiche e password che proteggono anche i portafogli digitali. Il motivo è che una volta che un hacker accede a tali informazioni, può svuotare i tuoi asset digitali. Anche se il rischio di hacking attraverso tale processo è basso, gli utenti di criptovalute che gestiscono i loro asset digitali utilizzando questi dispositivi non dovrebbero ignorare l’avvertimento.</p>
<h2 id="h2-Recenti20lacune20di20sicurezza20in20iOS20e20MacOS20che20aumentano20la20possibilit20di20violazione20della20sicurezza388394"><a name="Recenti lacune di sicurezza in iOS e MacOS che aumentano la possibilità di violazione della sicurezza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Recenti lacune di sicurezza in iOS e MacOS che aumentano la possibilità di violazione della sicurezza</h2><p>L’exploit GoFetch Apple non è l’unico problema digitale che i computer MacOS e i tablet iPad devono affrontare. Recentemente <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 ha riferito che di recente Apple ha rilasciato diversi aggiornamenti</a> a causa delle vulnerabilità dei suoi dispositivi iOS e macOS che potrebbero consentire a soggetti malintenzionati di rubare dati sensibili e asset digitali. A causa di tali vulnerabilità, Apple ha invitato gli utenti ad aggiornare i propri dispositivi a iOS 16.4.1 e macOS 13.3.1.</p>
<p>In realtà, questi dispositivi avevano due minacce, cioè CVE-2023-28205 e CVE-2023-28206, che potrebbero consentire agli hacker di sfruttare senza clic. Con questo, le vittime potrebbero essere indirizzate a siti web di phishing in cui gli attori malintenzionati li avrebbero presi di mira utilizzando trucchi diversi di truffa criptata al fine di rubare i loro asset digitali.<br>Inoltre, consentirebbe l’installazione automatica di malware all’interno dei dispositivi. Una volta installato il malware, gli attaccanti eseguirebbero determinati codici e controllerebbero i dispositivi.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1115/metamask-notifies-apple-users-over-icloud-phishing-attack" target="_blank">Metamask avvisa gli utenti Apple sull’attacco di phishing di iCloud</a></p>
<h2 id="h2-Come20mantenere20al20sicuro20la20tua20criptovaluta730005"><a name="Come mantenere al sicuro la tua criptovaluta?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come mantenere al sicuro la tua criptovaluta?</h2><p>Se conservi asset digitali nei Mac o iPad di Apple, la cosa migliore è trasferirli su un altro dispositivo. Puoi conservarli su portafogli hardware o su dispositivi digitali adatti come PC Windows, telefoni Android o iPhone.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/2460/security-measures-at-gateio-protecting-your-digital-assets-in-the-crypto-landscape" target="_blank">Proteggere i tuoi asset digitali nel panorama criptato</a></p>
<p>L’altra cosa importante da fare è evitare di installare applicazioni da sviluppatori non identificati e da fonti non attendibili. Se hai già tali app sul tuo dispositivo, rimuovile immediatamente per evitare eventuali exploit crittografici.</p>
<p>Suggerimenti recenti: <a href="https://www.gate.io/learn/articles/10-steps-to-keep-your-crypto-assets-safe/2162" target="_blank">10 passaggi per mantenere al sicuro i tuoi asset criptografici</a></p>
<p>Infine, gli utenti Apple con i dispositivi citati dovrebbero sempre tenere conto di qualsiasi avviso di malware che ricevono. La mitigazione delle falle di crittografia di Apple discussa sopra e queste misure di sicurezza potrebbero salvarti dalla perdita dei tuoi asset digitali.</p>
<h2 id="h2-Conclusione142830"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Un recente rapporto accademico dei ricercatori di diverse importanti università degli Stati Uniti ha avvertito che le versioni precedenti di MacOS di Apple e i tablet iPad presentano vulnerabilità nei loro chip della serie M che potrebbero consentire agli hacker di accedere alle chiavi di crittografia e alle password. Tuttavia, solo i chip M1, M2 e M3 hanno tali falle di sicurezza. La cosa migliore che gli utenti di criptovalute possono fare è rimuovere i propri asset digitali da tali dispositivi.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il repostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>