Come rilevare la reale capacità dei dispositivi di archiviazione con AIDA64?

Non importa quanto siate esperti di tecnologia, è quasi impossibile riconoscere un dispositivo di archiviazione falso. Non si può giudicare una chiave USB dall'aspetto, durante la nostra indagine abbiamo trovato unità false di vari design e capacità. L'aspetto allarmante è che non ci si può fidare nemmeno dei loghi dei grandi marchi: tra le chiavette false che abbiamo trovato ce n'erano molte etichettate Samsung, Kingston, Toshiba ecc.

Ma possiamo sempre utilizzare AIDA64 in quanto, dalla versione 2.60, è in grado di rilevare falsi dispositivi di archiviazione. Dopo un rapido controllo dell'unità, ci dirà con una precisione del 100% se siamo stati ingannati da un dispositivo con solo una frazione della capacità pubblicizzata o se siamo stati davvero fortunati ad avere un'unità economica e funzionale.

AIDA64 vs. unità flash contraffatte

In AIDA64 v2.60 e successivi, è presente una funzione dedicata, sulla quale possiamo fare affidamento nel caso in cui sospettiamo di aver acquistato un'unità falsa. I produttori loschi di solito usano lo stesso trucco: sovrascrivono la capacità reale con una capacità maggiore nel software del chip controller. Di conseguenza, il chip controller segnalerà questa capacità falsa al sistema operativo che all'inizio non vedrà alcun problema: sarà in grado di eseguire operazioni di scrittura, lettura e persino formattazione rapida con qualsiasi file di sistema.

Il problema è che i chip di memoria nella chiave USB non hanno la capacità che il chip controller vorrebbe indirizzare. Invece, la capacità di memoria reale è solo una frazione di quella conosciuta dal chip controller. Quando scriviamo sulla chiavetta USB, il controller riempie le celle di memoria in sequenza sin dal primo settore, quindi il problema non diventerà visibile finché non avremo raggiunto la capacità massima dei chip di memoria. Una volta superata la capacità reale, inizierai a visualizzare messaggi di errore quando il controller inizia a indirizzare le celle di memoria inesistenti in cui salvare i dati.

Rilevare il problema

Per testare la nostra chiavetta USB, lanciamo AIDA64 e selezioniamo Strumenti | Benchmark disco nel menu principale. Quindi nella finestra Benchmark disco, andiamo a Opzioni/Scrivi test.

Attenzione! Durante l'esecuzione dei test di scrittura, tutti i dati sulla chiave USB andranno persi e AIDA64 ci avverte tre volte all'avvio del processo. Quindi è meglio eseguire il backup di tutti i nostri dati archiviati sul dispositivo prima di iniziare il test.

Il metodo Linear Test + Verifica è il più completo, ma richiede anche molto tempo. Per accelerare il processo, seleziona Scrittura casuale + Verifica, che proverà a scrivere dati su celle di memoria casuali. In questo modo vedremo in pochi secondi se ci sono problemi con il nostro dispositivo. Se digitiamo una dimensione del blocco maggiore del valore predefinito in Opzioni / Dimensione del blocco, possiamo aumentare ulteriormente la velocità.

Rilevare la capacità reale

Se la chiave USB ha fallito nel test di scrittura casuale, dovremo scoprire la capacità reale dell'unità e riformattarla alla sua capacità reale.

Qui useremo di nuovo AIDA64 Disk Benchmark. Selezioniamo la chiave USB falsa nel menu a discesa e selezioniamo l'opzione Linear Write + Verifica questa volta. Poi avviamo il test e lo lasciamo eseguire finché non viene visualizzato il primo messaggio di errore. La capacità che vedremo nel messaggio di errore è la capacità reale dei chip di memoria installati sulla chiave USB. Nel nostro esempio, sono 6032 MB che equivalgono a circa 6 GB di spazio di archiviazione utilizzabile. Ora conosciamo le dimensioni della partizione che dovremo utilizzare per rendere la chiave USB più affidabile.

Riformattazione del dispositivo di archiviazione

La nostra scelta naturale sarebbe Gestione disco in Windows, ma non possiamo selezionare una capacità inferiore alla capacità totale dell'unità. Quindi dovremo affidarci al programma da riga di comando Diskpart, incluso in Windows, che può essere lanciato premendo WIN+R e digitando "diskpart" nella finestra "Esegui" che si apre. Avremo bisogno dei privilegi amministrativi per eseguire questo programma, quindi se non abbiamo effettuato l'accesso come amministratore dovremo eseguire diskpart.exe come amministratore facendo clic con il pulsante destro del mouse sull'icona nella barra delle applicazioni e selezionando questa opzione.

Una volta che diskpart.exe è in esecuzione, digita il comando seguente. (Nel nostro esempio, formattiamo una falsa chiave USB da 8 GB alla sua capacità reale, che è di 6 GB.

Attenzione! Tutti i dati verranno cancellati dalla chiavetta USB. Nel comando, "X:" è la lettera di unità associata al dispositivo.

list disk
:: qui la chiavetta USB è il Disco 2

select disk 2
list disk
:: digitando nuovamente il disco dell'elenco dei comandi, possiamo verificare se è selezionato il disco appropriato. Il disco selezionato è contrassegnato con a *.

clean
:: questo comando elimina tutte le partizioni esistenti

create partition primary size=6032
:: impostiamo la dimensione della partizione sul valore che abbiamo visto nel messaggio di errore AIDA64

list partition
:: ora elenchiamo le partizioni. Nell'elenco, la partizione selezionata è contrassegnata da a *. Nel caso non sia selezionato, possiamo selezionarlo digitando: select partition 1

assign letter x
:: ora assegniamo una lettera alla partizione in modo da potervi accedere
:: se Windows offre la possibilità di formattare l'unità, possiamo terminare il processo immediatamente

format fs=fat32 label=AIDA64
:: in caso contrario, possiamo eseguire questo comando, aggiungendo sia il file system che desideriamo che il titolo del disco

:: una volta completata la formattazione, possiamo chiudere la finestra di diskpart
exit

Usando questi comandi, abbiamo eliminato la partizione falsa originale da 8 GB e creato una partizione da 6 GB al suo posto, assegnandole la stessa lettera e formattata utilizzando FAT32. Possiamo anche selezionare la formattazione rapida aggiungendo QUICK alla fine del comando.