Windows 11 può conservare miniature delle foto cancellate: dove sono e come eliminarle

Aggiungi IlSoftware.it come Fonte preferita su Google

Cancellare una foto su un sistema Windows 11 non significa eliminare nello stesso istante ogni sua traccia: Esplora file utilizza infatti da molti anni una cache delle miniature nella quale conserva versioni ridotte delle immagini e di altri documenti, così da visualizzare rapidamente le anteprime senza doverle generare ogni volta.

Il meccanismo non è una novità introdotta con Windows 11: Microsoft congegnò una cache centralizzata già con Windows Vista, abbandonando il vecchio modello di Windows XP basato sui file Thumbs.db distribuiti nelle singole cartelle e che molti di voi certamente ricorderanno.

La questione è tornata d’attualità dopo la diffusione sui social di messaggi secondo i quali Windows conserverebbe segretamente la miniatura di “ogni foto cancellata“. La realtà tecnica è un po’ diversa.

Dove Windows 11 conserva le miniature delle immagini

La cache usata da Windows si trova nella cartella %localappdata%\Microsoft\Windows\Explorer: per raggiungerla basta premere Windows+R, incollare il percorso indicato e premere Invio.

Al suo interno si trovano diversi database con nomi come thumbcache_32.db, thumbcache_96.db, thumbcache_256.db, thumbcache_1024.db e così via. Il numero identifica la classe dimensionale delle anteprime conservate; l’insieme preciso dei file presenti può cambiare a seconda della versione di Windows.

Sono archivi utilizzati dalla shell per recuperare velocemente rappresentazioni grafiche già elaborate. Microsoft espone perfino una specifica interfaccia COM, IThumbnailCache, attraverso la quale le applicazioni possono interagire con la cache condivisa del sistema.

L’API GetThumbnail accetta, tra gli altri parametri, l’elemento della shell interessato e la dimensione richiesta in pixel, fino a 1024. Se l’immagine richiesta esiste già nella cache, Windows può restituirla senza riesaminare il documento originale. La documentazione Microsoft prevede inoltre il flag WTS_CACHED per indicare che il bitmap restituito proviene dalla cache.

Il motivo di questa architettura è semplice: le prestazioni. Aprire una cartella con centinaia o migliaia di fotografie e rigenerare ogni volta tutte le anteprime comporterebbe letture dal disco, decodifica delle immagini e lavoro aggiuntivo per CPU e storage. Conservare versioni già ridimensionate delle immagini rende molto più fluida la navigazione in Esplora file.

Perché una foto cancellata può lasciare la sua anteprima

Il dettaglio che può sorprendere riguarda la separazione tra file originale e miniatura. Quando Windows genera un’anteprima e la inserisce nel database, quella rappresentazione diventa un elemento distinto dal file sorgente. Cancellare successivamente la fotografia non impone quindi l’immediata eliminazione della corrispondente voce dalla cache.

In pratica, possono esistere due cicli di vita differenti. Da una parte c’è IMG_1234.jpg, che l’utente può spostare nel Cestino o cancellare definitivamente; dall’altra c’è una piccola rappresentazione grafica che Esplora file aveva già prodotto e registrato nella propria cache. Rimuovere la prima non implica necessariamente l’immediata invalidazione fisica della seconda.

Il punto è che ciò non significa affatto che Windows crei una miniatura per qualsiasi immagine salvata sul computer. Raymond Chen di Microsoft aveva già chiarito anni fa che la semplice creazione o copia di un file immagine non comporta automaticamente l’inserimento di una voce nella cache. Deve intervenire Esplora file, oppure un’altra applicazione che utilizzi il servizio di thumbnail caching, richiedendo effettivamente l’anteprima.

Anche la documentazione dell’API conferma questa distinzione. Quando IThumbnailCache estrae una miniatura, normalmente la memorizza; uno sviluppatore può però specificare WTS_EXTRACTDONOTCACHE per ottenere l’immagine senza inserirla nel database. Non si può quindi stabilire, partendo dalla sola esistenza passata di un file, che la sua anteprima sia necessariamente presente.

Non è una copia segreta della foto originale!

Una miniatura non è ovviamente sovrapponibile con la foto di partenza: è una rappresentazione ridotta, pensata per l’interfaccia grafica, e la quantità di informazioni recuperabili dipende dalle dimensioni e dal contenuto dell’immagine. Una preview molto piccola può essere sufficiente a riconoscere grossolanamente un volto, un luogo o una scena, ma non consente di ricostruire magicamente il file originale alla sua risoluzione iniziale.

Ciò non rende irrilevante il problema dal punto di vista della privacy ma va sottolineato che si tratta di informazioni residenti in una cartella di sistema, accessibile esclusivamente in ambito locale.

Windows 11 non conserva una copia integrale di “tutte le foto cancellate“: può mantenere rappresentazioni riconoscibili di alcuni file non più presenti. Per un normale PC si tratta soprattutto di un compromesso tra velocità e persistenza dei dati temporanei.

Su macchine condivise, postazioni pubbliche o sistemi che elaborano materiale riservato, ovviamente la valutazione cambia.

Come vedere cosa contengono davvero i file thumbcache_*.db

La presenza dei database nella cartella locale riportata in precedenza conduce a una domanda piuttosto naturale: è possibile aprirli e vedere le miniature che Windows 11 ha conservato?

I file thumbcache_*.db sono database binari della shell di Windows, non database SQLite o normali raccolte di immagini, quindi occorre interpretarne la struttura oppure estrarre i dati grafici contenuti al loro interno.

Una delle soluzioni più immediate è Thumbcache Viewer, utilità gratuita di Eric Kutcher progettata espressamente per leggere le cache delle miniature di Windows. Il programma permette di aprire un file thumbcache_*.db, esaminare i dati presenti, visualizzare le anteprime disponibili ed esportarle.

Prima dell’analisi conviene comunque lavorare su una copia dei database presenti in %localappdata%\Microsoft\Windows\Explorer, soprattutto perché Esplora file può mantenere alcuni file aperti mentre Windows è in uso.

Chi non vuole scaricare alcun programma può effettuare una prima verifica anche con PowerShell. Uno script può leggere i thumbcache_*.db come sequenze di byte e applicare una tecnica di file carving, cercando firme note come FF D8 FF per l’inizio di un JPEG oppure 89 50 4E 47 0D 0A 1A 0A per un PNG (ne abbiamo parlato nell’articolo sui formati di file). Le sequenze individuate possono poi essere estratte e salvate in una cartella separata, ottenendo una sorta di galleria delle miniature ancora riconoscibili.

Scansione la cache delle miniature con PowerShell ed estrarre le immagini

Il file carving con PowerShell ha però dei limiti: non equivale a un parser del formato, può produrre duplicati e non intercetta necessariamente ogni codifica utilizzata dalla cache.

Per un controllo veloce e senza installazioni è comunque un esperimento interessante; per capire con maggiore precisione quali entry risultano ancora registrate nei database, uno strumento dedicato resta la soluzione più affidabile.

In entrambi i casi vale la stessa avvertenza: ciò che si riesce a estrarre rappresenta ciò che è ancora presente nella cache, non l’elenco completo di tutte le foto che sono transitate sul computer o che l’utente ha cancellato in passato.

Per eseguire lo script, basta aprire PowerShell dal menu Start, incollare l’intero codice nella finestra e premere Invio: non sono necessari privilegi di amministratore. Al termine lo script apre automaticamente con Esplora file la cartella contenente le miniature individuate (%userprofile%\Desktop\Thumbcache_Extracted).

$Source = "$env:LOCALAPPDATA\Microsoft\Windows\Explorer"
$Out = "$env:USERPROFILE\Desktop\Thumbcache_Extracted"
$Work = Join-Path $env:TEMP "Thumbcache_Analysis"

New-Item -ItemType Directory -Force -Path $Out  | Out-Null
New-Item -ItemType Directory -Force -Path $Work | Out-Null

Write-Host "Copio i database Thumbcache..." -ForegroundColor Cyan

$DBs = Get-ChildItem $Source -Filter "thumbcache_*.db" -ErrorAction SilentlyContinue

foreach ($db in $DBs) {
    try {
        Copy-Item $db.FullName $Work -Force -ErrorAction Stop
    }
    catch {
        Write-Host "Impossibile copiare $($db.Name)" -ForegroundColor Yellow
    }
}

$files = Get-ChildItem $Work -Filter "thumbcache_*.db"

Write-Host "Database trovati: $($files.Count)" -ForegroundColor Green

$count = 0

foreach ($file in $files) {

    Write-Host "Analizzo $($file.Name)..." -ForegroundColor Cyan

    $bytes = [System.IO.File]::ReadAllBytes($file.FullName)
    $len = $bytes.Length

    for ($i = 0; $i -lt ($len - 8); $i++) {

        # ----------------------------------------------------
        # JPEG - cerca FF D8 FF e il successivo FF D9
        # ----------------------------------------------------

        if (
            $bytes[$i]   -eq 0xFF -and
            $bytes[$i+1] -eq 0xD8 -and
            $bytes[$i+2] -eq 0xFF
        ) {

            $end = -1

            for ($j = $i + 3; $j -lt ($len - 1); $j++) {
                if (
                    $bytes[$j]   -eq 0xFF -and
                    $bytes[$j+1] -eq 0xD9
                ) {
                    $end = $j + 1
                    break
                }
            }

            if ($end -gt $i) {

                $size = $end - $i + 1

                if ($size -gt 500) {

                    $count++

                    $name = "{0:D5}_{1}_{2}.jpg" -f `
                        $count,
                        $file.BaseName,
                        $i

                    $path = Join-Path $Out $name

                    $img = New-Object byte[] $size

                    [Array]::Copy(
                        $bytes,
                        $i,
                        $img,
                        0,
                        $size
                    )

                    [System.IO.File]::WriteAllBytes($path, $img)

                    Write-Host "  JPEG trovato: $name" -ForegroundColor Green
                }

                $i = $end
                continue
            }
        }

        # ----------------------------------------------------
        # PNG
        # firma: 89 50 4E 47 0D 0A 1A 0A
        # termina dopo chunk IEND
        # ----------------------------------------------------

        if (
            $bytes[$i]   -eq 0x89 -and
            $bytes[$i+1] -eq 0x50 -and
            $bytes[$i+2] -eq 0x4E -and
            $bytes[$i+3] -eq 0x47 -and
            $bytes[$i+4] -eq 0x0D -and
            $bytes[$i+5] -eq 0x0A -and
            $bytes[$i+6] -eq 0x1A -and
            $bytes[$i+7] -eq 0x0A
        ) {

            $end = -1

            for ($j = $i + 8; $j -lt ($len - 8); $j++) {

                # IEND
                if (
                    $bytes[$j]   -eq 0x49 -and
                    $bytes[$j+1] -eq 0x45 -and
                    $bytes[$j+2] -eq 0x4E -and
                    $bytes[$j+3] -eq 0x44
                ) {

                    # IEND + CRC
                    $end = $j + 7
                    break
                }
            }

            if ($end -gt $i) {

                $size = $end - $i + 1

                if ($size -gt 100) {

                    $count++

                    $name = "{0:D5}_{1}_{2}.png" -f `
                        $count,
                        $file.BaseName,
                        $i

                    $path = Join-Path $Out $name

                    $img = New-Object byte[] $size

                    [Array]::Copy(
                        $bytes,
                        $i,
                        $img,
                        0,
                        $size
                    )

                    [System.IO.File]::WriteAllBytes($path, $img)

                    Write-Host "  PNG trovato: $name" -ForegroundColor Green
                }

                $i = $end
                continue
            }
        }
    }
}

Write-Host ""
Write-Host "Estrazione terminata." -ForegroundColor Cyan
Write-Host "Immagini estratte: $count" -ForegroundColor Green
Write-Host "Cartella: $Out"
Write-Host ""

Start-Process explorer.exe $Out

Come cancellare la cache delle miniature in Windows 11

Microsoft mette a disposizione un metodo molto semplice per svuotare questi database senza installare programmi esterni. Premendo Windows+R si può digitare cleanmgr e avviare Pulizia disco. Dopo aver selezionato l’unità sulla quale risiede Windows, generalmente C:, basta scegliere la voce Anteprima e confermare la cancellazione.

Rimozione miniature foto immagini Windows 11

Non è necessario selezionare genericamente tutti i file temporanei: Microsoft documenta le miniature come categoria specifica di Pulizia disco; chi vuole intervenire esclusivamente sulla cache delle miniature può quindi lasciare deselezionate le altre categorie.

L’operazione elimina soltanto dati che Windows considera ricostruibili: alla successiva apertura delle cartelle, Esplora file inizia infatti a generare nuovamente le anteprime necessarie. Subito dopo la pulizia, si può quindi notare per qualche istante una comparsa progressiva delle anteprime: è il comportamento previsto. Ma, allo stesso tempo, l’attività su disco può aumentare temporaneamente, perché Esplora file deve leggere nuovamente le immagini originali, generarne le miniature e ricostruire i database thumbcache_*.db.