TGEgdmlvbGF6aW9uZSBkZWkgZGF0aSBkaSBGaWRlbGl0eSBlc3BvbmUgbGUgaW5mb3JtYXppb25pIHBlcnNvbmFsaSBkaSA3Ny4wMDAgY2xpZW50aSBkaSBDcnlwdG8gRVRG

2024-10-23, 02:34

<p><img src="https://gimg2.gateimg.com/image/article/17296506691690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TL20DR668062"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Una violazione della sicurezza del database Fidelity avvenuta ad agosto ha provocato il furto di informazioni personali per oltre 77.000 clienti.</p>
<p>Fidelity ha offerto servizi gratuiti di monitoraggio del credito e ripristino dell’identità ai clienti i cui account sono stati violati.</p>
<p>L’autenticazione a due fattori è un modo per prevenire l’hacking dell’account.</p>
<h2 id="h2-Introduzione376099"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Le violazioni dei dati sono una vera minaccia per la sicurezza in quanto i cattivi attori potrebbero utilizzare le informazioni per motivi imprevisti. Con il fascino di arricchirsi attraverso il furto di valute digitali, gli hacker sono più audaci che mai. Purtroppo, ci sono sindacati di hacker che utilizzano tecniche avanzate per rubare dati personali. La cosa migliore per prevenire tali incidenti è utilizzare metodi comprovati come l’autenticazione a due fattori e password robuste. In questo articolo discutiamo della violazione dei dati di Fidelity che ha interessato più di 70.000 individui.</p>
<h2 id="h2-Background20su20Fidelity20e20la20Violazione345447"><a name="Background su Fidelity e la Violazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Background su Fidelity e la Violazione</h2><p><a href="https://www.gate.io/blog/1315/Fidelity-Investments-Proposes-Bitcoin-As-A-401-k-Investment-Option" target="_blank">Fidelity Investments, un emittente di ETF criptovalutari</a>, ha confermato che i malintenzionati hanno violato il suo sistema e hanno avuto accesso ai dati di oltre 77.0000 dei suoi clienti. La società ha divulgato il triste sviluppo quando ha segnalato il caso al procuratore generale del Maine. Tuttavia, solo una piccola parte dei suoi clienti è stata colpita poiché ha più di 515 milioni di clienti nel suo database. La violazione della sicurezza è avvenuta tra il 17 e il 19 agosto, quando l’aggressore ha avuto accesso ai suoi account dei clienti. Tuttavia, l’azienda ha assicurato ai suoi clienti che esperti di sicurezza esterni hanno contribuito a risolvere i problemi.</p>
<p>Sfortunatamente, questa è la quarta volta che Fidelity ha subito violazioni dei dati nel giro di 12 mesi. Le altre violazioni dei dati sono avvenute il 4 marzo, il 18 marzo e il 19 luglio. Nella sua comunicazione, Fidelity ha condiviso con l’avvocato generale del Maine le date delle violazioni e il numero di persone coinvolte. Dopo aver notato che il suo sistema era compromesso, l’azienda ha bloccato gli utenti o qualsiasi altra persona non autorizzata dall’accedere agli account interessati. Da lì, con l’aiuto di esperti esterni, Fidelity ha avviato un’approfondita indagine sulla sicurezza. L’obiettivo è prevenire situazioni simili in futuro. Poiché la violazione dei dati di Fidelity è stata limitata a un solo database, gli attori malevoli non sono riusciti ad accedere ai fondi dei clienti.</p>
<p>Fidelity ha anche presentato un’altra segnalazione di perdita di dati dei clienti al procuratore generale del Massachusetts poiché gli aggressori hanno anche rubato i dettagli delle patenti di guida e i numeri di previdenza sociale delle persone interessate. Nel frattempo, Fidelity ha contattato i clienti interessati tramite e-mail, avvertendoli della violazione dei dati.</p>
<p>Fidelity non è stata l’unica azienda di alto profilo violata dagli attaccanti. <a href="https://www.gate.io/blog/4600/openai-s-funding-milestone-triggers-unexpected-downturn-for-ai-cryptos-tao-and-fet" target="_blank">OpenAi, un’azienda di intelligenza artificiale</a>, e AT&amp; <a href="/price/amp-amp" rel="nofollow noopener noreferrer" target="_blank">Amp</a>, una società di telecomunicazioni, è stata violata anche all’inizio di quest’anno. È importante notare che Fidelity è una delle principali società di gestione patrimoniale che è attivamente coinvolta nelle criptovalute. All’inizio di quest’anno, ha lanciato il suo <a href="https://www.gate.io/learn/articles/bitcoin-spot-etf-vs-bitcoin-futures-etf/973" target="_blank">spot bitcoin ETF</a> e spot <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF. In effetti, sin dal suo lancio, la Fidelity Wise Origin <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il fondo ha ricevuto circa $10 miliardi di afflussi di capitale. D’altra parte, Fidelity <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il fondo ha attirato oltre $ 445 dal suo inizio a luglio.</p>
<h2 id="h2-Come2020avvenuto20lincidente20di20sicurezza693346"><a name="Come è avvenuto l’incidente di sicurezza" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come è avvenuto l’incidente di sicurezza</h2><p>Secondo i rapporti inviati da Fidelity alle autorità competenti, un terzo che ha aperto di recente due account ha violato il suo sistema. Tuttavia, l’azienda non ha specificato esattamente come è successo. Al momento, l’azienda gestisce oltre $14 trilioni di asset, il che indica la sua elevata responsabilità nel garantire la sicurezza delle informazioni dei clienti. Sulla base del registro delle violazioni dei dati che Fidelity ha avuto solo durante quest’anno, dovrebbe investire di più nel suo sistema di sicurezza.</p>
<h2 id="h2-Servizi20di20monitoraggio20del20credito20gratuito20e20ripristino20dellidentit20da20Fidelity502672"><a name="Servizi di monitoraggio del credito gratuito e ripristino dell’identità da Fidelity" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Servizi di monitoraggio del credito gratuito e ripristino dell’identità da Fidelity</h2><p>Fino a questo punto, Fidelity ha dichiarato di non aver ancora notato alcun modo in cui gli attaccanti abbiano utilizzato i dati rubati. Tuttavia, per garantire che i clienti interessati rimangano al sicuro, l’azienda offre servizi gratuiti di monitoraggio del credito e ripristino dell’identità per i prossimi due anni. I clienti devono iscriversi a questi servizi. Con questa struttura, TransUnion Interactive, responsabile del monitoraggio dei rapporti di credito, sarà in grado di avvisare qualsiasi cliente di qualsiasi attività insolita che potrebbe suggerire una possibile frode. Questo è un aspetto importante del processo di gestione degli asset digitali di Fidelity. Attraverso email, l’azienda ha inviato codici speciali ai clienti ETF di Fidelity colpiti dalla violazione per aprire account con TransUnion.</p>
<h2 id="h2-Come20i20clienti20possono20proteggersi20da20possibili20frodi20e20furto20di20identit674200"><a name="Come i clienti possono proteggersi da possibili frodi e furto di identità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come i clienti possono proteggersi da possibili frodi e furto di identità</h2><p>I clienti dell’ETF di Fidelity interessati dovrebbero rimanere vigili nel caso in cui gli aggressori potrebbero prendere di mira loro. Ad esempio, dovrebbero controllare attentamente i loro conti Fidelity e altri conti finanziari per eventuali segni di frode. Se notano attività sospette, dovrebbero segnalarle all’azienda.</p>
<p>Potrebbe essere saggio mettere un avviso di frode sul proprio file di credito. In altre parole, la persona interessata dovrebbe informare i creditori di contattarla prima di apportare qualsiasi modifica al suo conto. Ad esempio, i clienti Fidelity interessati negli Stati Uniti possono inserire l’avviso presso le aziende di cibersicurezza finanziaria come Equifax, Experian e TransUnion, che sono anche le principali agenzie di segnalazione del credito nel paese. Fidelity ha già fornito i dettagli su cosa fare agli individui interessati.</p>
<p>È importante per i clienti interessati cambiare le loro password anche se il furto di informazioni personali potrebbe non aver raccolto tali dati. È importante utilizzare una password forte che gli hacker non possano facilmente violare. Inoltre, dovrebbero anche rimanere vigili nei confronti delle truffe e degli attacchi di phishing. Ciò perché gli attaccanti potrebbero utilizzare le informazioni personali rubate per contattarti. È anche importante evitare di cliccare su <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> da organizzazioni e individui che non si conoscono personalmente. Inoltre, si dovrebbe installare software anti-malware e programmi antivirus sui propri dispositivi di comunicazione come gli smartphone.</p>
<p>Infine, quando possibile, si dovrebbero utilizzare due autenticazioni su tutti i propri account. Questo aiuterà le persone a proteggere i loro dati personali e finanziari dagli attacchi. Utilizzare l’autenticazione a due fattori è un modo per proteggersi dagli hacker in quanto aggiunge un importante livello di sicurezza. Ad esempio, anche se gli hacker rubano la password di qualcuno, non possono accedere ai suoi account se sono protetti da autenticazione a due fattori.</p>
<h2 id="h2-Prestazioni20del20Crypto20ETF20di20Fidelity156038"><a name="Prestazioni del Crypto ETF di Fidelity" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prestazioni del Crypto ETF di Fidelity</h2><p>I prodotti di scambio cripto di Fidelity, come gli ETF spot, hanno avuto buoni risultati dal loro lancio all’inizio di quest’anno. Come esempio, il Fidelity Wise Origin <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il fondo (FBTC) ha accumulato oltre 10 miliardi di dollari di flussi. D’altra parte, Fidelity <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Fund (FETH), lanciato il 23 luglio, ha attirato oltre 445 milioni di dollari di flussi dal suo lancio. La tabella seguente mostra l’andamento dell’ETF spot Ethereum (FETH) di Fidelity<br><img src="https://gimg2.gateimg.com/image/article/17296508101.jpeg" alt=""><br>Prestazioni Fidelity ETH - Farside</p>
<p>Come mostra la tabella, finora Fidelity <a href="https://www.gate.io/learn/articles/the-impact-of-the-ethereum-etf-etf-an-analysis/3473" target="_blank">spot Ethereum ETF</a> ha registrato un afflusso netto di 466,8 milioni di dollari. Ciò dimostra che gli ETF criptati di Fidelity hanno ottenuto buoni risultati quest’anno.</p>
<h2 id="h2-Conclusione375784"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Ad agosto Fidelity ha subito una violazione dei dati in cui sono stati rubati informazioni di oltre 77.000 persone. Dopo quell’incidente, l’azienda ha assicurato ai suoi clienti di aver coinvolto esperti esterni in sicurezza per risolvere le attuali sfide. Ha inoltre offerto alle persone colpite il monitoraggio gratuito del credito e servizi di ripristino dell’identità. Alla luce della recente violazione dei dati, i clienti dovrebbero adottare anche misure di sicurezza responsabili come cambiare le loro password e utilizzare l’autenticazione a due fattori quando possibile.</p>
<h2 id="h2-Domande20frequenti20su20come20la20violazione20dei20dati20di20Fidelity20sta20influenzando20i20clienti20degli20ETF20criptati53262"><a name="Domande frequenti su come la violazione dei dati di Fidelity sta influenzando i clienti degli ETF criptati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su come la violazione dei dati di Fidelity sta influenzando i clienti degli ETF criptati</h2><h3 id="h3-Cosa2020successo20nella20violazione20dei20dati20di20Fidelity172418"><a name="Cosa è successo nella violazione dei dati di Fidelity?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa è successo nella violazione dei dati di Fidelity?</h3><p>Alcuni attori malintenzionati hanno creato due account Fidelity prima di accedere ai dati personali di oltre 77.000 clienti. Tuttavia, non ci sono prove che gli attaccanti abbiano utilizzato alcuna delle informazioni raccolte.</p>
<h3 id="h3-Come20ha20risposto20Fidelity20alla20violazione242130"><a name="Come ha risposto Fidelity alla violazione?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come ha risposto Fidelity alla violazione?</h3><p>Fidelity sta lavorando con personale di sicurezza esterno per risolvere le sue sfide al fine di prevenire futuri violazioni dei dati. Ha inoltre offerto monitoraggio del credito gratuito e servizi di ripristino dell’identità ai clienti interessati.</p>
<h3 id="h3-Come20possono20i20clienti20interessati20iscriversi20al20servizio20di20monitoraggio20del20credito20gratuito571836"><a name="Come possono i clienti interessati iscriversi al servizio di monitoraggio del credito gratuito?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come possono i clienti interessati iscriversi al servizio di monitoraggio del credito gratuito?</h3><p>I clienti interessati sono tenuti ad aprire un conto con TransUnion. Attraverso e-mail, ogni cliente interessato ha ricevuto un codice da utilizzare per aprire il conto, oltre a istruzioni complete su come procedere.</p>
<h3 id="h3-Cosa20devo20fare20se20sospetto20attivit20fraudolente20sul20mio20account908784"><a name="Cosa devo fare se sospetto attività fraudolente sul mio account?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa devo fare se sospetto attività fraudolente sul mio account?</h3><p>Se sei un cliente Fidelity, dovresti segnalare l’attività sospetta all’azienda. Dovresti anche cambiare la tua password e evitare di fare clic su link da persone che non conosci.</p>
<h3 id="h3-Fidelity20ha20avuto20esperienze20simili20di20violazioni20dei20dati20in20passato95029"><a name="Fidelity ha avuto esperienze simili di violazioni dei dati in passato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fidelity ha avuto esperienze simili di violazioni dei dati in passato?</h3><p>Sì, Fidelity ha avuto altre 3 violazioni dei dati che sono avvenute all’inizio di quest’anno. Si sono verificate il 4 e il 18 marzo e il 19 luglio.</p>
<h3 id="h3-Quali20misure20sta20adottando20Fidelity20per20prevenire20future20violazioni448043"><a name="Quali misure sta adottando Fidelity per prevenire future violazioni?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quali misure sta adottando Fidelity per prevenire future violazioni?</h3><p>Fidelity sta collaborando con personale di sicurezza specializzato per scoprire come si sono verificate le violazioni. Dopo un’indagine approfondita, intende introdurre misure per prevenire tali future violazioni dei dati.</p>
<h3 id="h3-Come20stanno20il20Fidelity20Wise20Origin20Fund20FBTC20e20il20Fidelity20Ethereum20Fund20FETH20sul20mercato561939"><a name="Come stanno il Fidelity Wise Origin Fund (FBTC) e il Fidelity Ethereum Fund (FETH) sul mercato?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come stanno il Fidelity Wise Origin Fund (FBTC) e il Fidelity Ethereum Fund (FETH) sul mercato?</h3><p>I due ETF criptovalutari di Fidelity stanno performando bene dopo il lancio all’inizio di quest’anno. Ad esempio, FETH è uno dei pochi ETF Ethereum che ha avuto un flusso netto di capitali positivo dal suo lancio il 23 luglio.</p>
<div class="blog-details-info"><br><div>Autore: Mashell C., Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni oculate.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>