Attenzione! Pulisci il tuo disco in modo sicuro (ma sei sicuro?)

#!/bin/bash

# Nome del file temporaneo che verrà creato per riempire il disco
TEMP_FILE="/tmp/fill_disk.tmp"

# Funzione per ottenere lo spazio libero sul disco in byte
get_free_space() {
    df --output=avail --block-size=1 / | tail -n 1
}

# Funzione per convertire il tempo in un formato leggibile
format_time() {
    local T=$1
    local D=$((T/60/60/24))
    local H=$((T/60/60%24))
    local M=$((T/60%60))
    local S=$((T%60))
    (( $D > 0 )) && printf '%d days ' $D
    (( $H > 0 )) && printf '%d hours ' $H
    (( $M > 0 )) && printf '%d minutes ' $M
    (( $D > 0 || $H > 0 || $M > 0 )) && printf 'and '
    printf '%d seconds\n' $S
}

# Ottiene lo spazio libero iniziale
initial_free_space=$(get_free_space)
echo "Spazio libero iniziale: $initial_free_space byte"

# Crea un file temporaneo di 1 byte
echo -n "" > $TEMP_FILE

# Riempie il disco fino a 1 byte prima della fine
block_size=$((100 * 1024 * 1024))  # Dimensione del blocco in byte (100 MB)
start_time=$(date +%s)
last_update_time=$start_time
total_bytes_written=0

while : ; do
    free_space=$(get_free_space)
    bytes_to_fill=$((free_space - 1))

    if (( bytes_to_fill < block_size )); then
        break
    else
        # Aggiunge blocchi da 100 MB al file
        dd if=/dev/zero bs=$block_size count=1 >> $TEMP_FILE 2>/dev/null
        total_bytes_written=$((total_bytes_written + block_size))
    fi

    # Calcola il tempo trascorso e stima il tempo rimanente
    current_time=$(date +%s)
    elapsed_time=$((current_time - start_time))
    bytes_filled=$((initial_free_space - free_space))
    
    # Stampa la stima del tempo rimanente ogni 5 secondi
    if (( current_time - last_update_time >= 5 )); then
        if (( bytes_filled > 0 && elapsed_time > 0 )); then
            bytes_per_second=$((bytes_filled / elapsed_time))
            estimated_total_time=$((initial_free_space / bytes_per_second))
            estimated_remaining_time=$((estimated_total_time - elapsed_time))

            echo "Byte scritti finora: $total_bytes_written"
            echo "Tempo stimato rimanente: $(format_time $estimated_remaining_time)"
        fi
        last_update_time=$current_time
    fi
done

# Scrive gli ultimi blocchi in modo più preciso
if (( bytes_to_fill > 0 )); then
    if (( bytes_to_fill > 99 * 1024 * 1024 )); then
        dd if=/dev/zero bs=$((99 * 1024 * 1024)) count=1 >> $TEMP_FILE 2>/dev/null
        total_bytes_written=$((total_bytes_written + 99 * 1024 * 1024))
        bytes_to_fill=$((bytes_to_fill - 99 * 1024 * 1024))
    fi

    if (( bytes_to_fill > 1024 * 1024 )); then
        dd if=/dev/zero bs=1M count=$((bytes_to_fill / 1024 / 1024)) >> $TEMP_FILE 2>/dev/null
        total_bytes_written=$((total_bytes_written + (bytes_to_fill / 1024 / 1024) * 1024 * 1024))
        bytes_to_fill=$((bytes_to_fill % (1024 * 1024)))
    fi

    if (( bytes_to_fill > 512 )); then
        dd if=/dev/zero bs=512 count=$((bytes_to_fill / 512)) >> $TEMP_FILE 2>/dev/null
        total_bytes_written=$((total_bytes_written + (bytes_to_fill / 512) * 512))
        bytes_to_fill=$((bytes_to_fill % 512))
    fi

    if (( bytes_to_fill > 0 )); then
        dd if=/dev/zero bs=1 count=$bytes_to_fill >> $TEMP_FILE 2>/dev/null
        total_bytes_written=$((total_bytes_written + bytes_to_fill))
    fi
fi

# Rimuove il file temporaneo
rm -f $TEMP_FILE
echo "Il file temporaneo è stato rimosso."
echo "Byte totali scritti: $total_bytes_written"
echo "Processo completato."

Questo script potrebbe sembrare un trucco da hacker, ma ha in realtà un’applicazione pratica! In questo articolo, analizzeremo uno script che può aiutarti a riempire in modo sicuro lo spazio libero sul tuo disco rigido.

Prima di procedere, è fondamentale sottolineare che è un’operazione irreversibile. Se esegui questo script, cancellerai definitivamente tutti i dati presenti sullo spazio libero del tuo disco. Assicurati di avere un backup completo di tutti i tuoi file prima di iniziare.

A cosa serve riempire il disco?

Ci sono alcuni scenari in cui potresti voler riempire il tuo disco in modo sicuro. Vediamone alcuni:

• Cancellazione sicura dei dati: Se stai vendendo o dismettendo un vecchio hard disk, potresti voler cancellare in modo sicuro tutti i dati che contiene. Riempire il disco con dati casuali è un modo per rendere più difficile il recupero dei dati cancellati da parte di software specializzati.
• Benchmarking delle prestazioni: Questo script può essere utilizzato per misurare la velocità di scrittura del tuo disco rigido.
• Test di stress: Riempire il tuo disco può essere un modo per testare la stabilità del tuo sistema operativo e dei tuoi componenti hardware.

Analizzando lo script

Lo script che abbiamo preso in esame è scritto in Bash ed è ben commentato, rendendo facile la comprensione del suo funzionamento. Vediamo i passaggi principali:

1. Preparazione:
   • Viene definito il nome di un file temporaneo che verrà utilizzato per riempire il disco.
   • Due funzioni vengono definite per ottenere lo spazio libero sul disco e formattare il tempo in un formato leggibile.
2. Misurazione iniziale:
   • Lo script misura lo spazio libero iniziale sul disco.
3. Creazione del file temporaneo:
   • Viene creato un file temporaneo vuoto.
4. Ciclo di scrittura:
   • Lo script entra in un ciclo continuo che esegue le seguenti azioni:
     • Controlla lo spazio libero rimanente sul disco.
     • Calcola la quantità di dati da scrivere per riempire lo spazio libero, lasciando però 1 byte vuoto.
     • Se la quantità di dati è maggiore di una dimensione di blocco predefinita (100 MB), lo script scrive un blocco intero utilizzando il comando dd.
     • Aggiorna le statistiche di scrittura e stima il tempo rimanente.
5. Scrittura finale:
   • Una volta che lo spazio libero è quasi esaurito, lo script scrive i rimanenti byte in modo più preciso utilizzando blocchi di dimensioni diverse per evitare di sovrascrivere.
6. Pulizia e messaggio di completamento:
   • Lo script elimina il file temporaneo e visualizza un messaggio di completamento, mostrando anche il totale dei byte scritti.

Alternative più sicure?

Esistono software specifici per la cancellazione sicura dei dati che utilizzano algoritmi di sovrascrittura più sicuri e certificati. Questi programmi sono generalmente più veloci e offrono un livello di sicurezza maggiore rispetto a questo script.

Conclusioni

Questo script può essere uno strumento utile in alcune situazioni, ma è fondamentale utilizzarlo con cautela. Prima di eseguirlo, assicurati di avere un backup completo dei tuoi dati e di comprendere i rischi coinvolti. Ricorda, cancellare i dati è un’operazione irreversibile!