Installare Debian su chiavetta USB

Lo scopo di questa guida è installare un sistema debian funzionante da portare in giro sulla nostra chiavetta USB e poterla utilizzare in qualsiasi frangente.

 

Per prima cosa abbiamo bisogno di fornirci del software per creare la nostra installazione su chiavetta, quindi digitiamo:

apt-get install debootstrap

 

Inoltre dovremo preparare la chiavetta (d'ora in poi indicata come /dev/sda): innanzitutto cancelliamo tutte le partizioni e quindi gli eventuali dati presenti sul supporto. Per fare questo usiamo il programma fdisk:

fdisk /dev/sda

e poi

p

con questo comando visualizziamo le partizioni presenti sulla chiavetta, nel mio caso:

Disk /dev/sdc: 1040 MB, 1040187392 bytes

1 heads, 32 sectors/track, 63488 cylinders

Units = cilindri of 32 * 512 = 16384 bytes

 

Dispositivo Boot      Start         End      Blocks   Id  System

/dev/sdc1   *           2       63488     1015792    b  W95 FAT32

diamo il comando per cancellare ciò che è presente sul device

d

se è presente una sola partizione questa verrà cancellata immediatamente, dopodichè crearne una nuova: diamo

n

e selezioniamo una partizione primaria con p

ovviamente essendo la nostra unica partizione dovremo dare 1 e alla richiesta del primo cilindro della partizione e delle dimensioni premere semplicemente invio per utilizzare le impostazioni di default. Finito il partizionamento daremo

w

e avremo la nuova tabella delle partizioni scritta su disco. Ora avremo creato una nuova partizione delle dimensioni di tutta la chiavetta, ma questa va ancora formattata. La scelta migliore è il filesystem ext2, quindi basterà dare

mkfs.ext2 /dev/sda1

Formattata la chiavetta, dovremo montarla:

mkdir /mnt/key

mount /dev/sda1 /mnt/key/

 

Finalmente abbiamo finito la preparazione del supporto e possiamo passare all'installazione vera e propria: utilizziamo quindi debootstrap con il comando

debootstrap --arch i386 etch /mnt/key/

che installerà il sistema di base. questo è un processo che prenderà un po' di tempo, a seconda della vostra connessione e della CPU.

 

Quando debootstrap avrà finito le sue operazioni, dovremo poter configurare il sistema e renderci in grado di effettuare il boot da esso. il modo più semplice è utilizzare chroot, prima montiamo proc

mount -t proc proc /mnt/key/proc

e poi diamo

chroot /mnt/key

ora sarà come usare il sistema installato sulla chiavetta, quindi se fate pasticci state tranquilli, non state distruggendo il vostro sistema.

Impostiamo i sorgente in /etc/apt/sources.list come indicato nelle F.A.Q.

per vedere se abbiamo fatto tutto bene diamo

apt-get update

e

apt-get clean

da dare dopo ogni comando apt per mantenere pulita la chiavetta

Inoltre è necessario modificare il file /etc/fstab in modo opportuno per evitare che ci siano numerosi quanto inutili accessi al disco che a lungo andare degradano la chiavetta. Per ovviare a questo usiamo tmpfs nel file

/dev/sda1 /             ext2    defaults,errors=remount-ro,noatime 0    0

proc    /proc           proc    defaults                        0       0

tmpfs   /etc/network/run tmpfs  defaults,noatime                0       0

tmpfs   /tmp            tmpfs   defaults,noatime                0       0

tmpfs   /var/lock       tmpfs   defaults,noatime                0       0

tmpfs   /var/log        tmpfs   defaults,noatime                0       0

tmpfs   /var/run        tmpfs   defaults,noatime                0       0

tmpfs   /var/tmp        tmpfs   defaults,noatime                0       0

tmpfs   /home           tmpfs   defaults,noatime                0       0

Eliminiamo anche /etc/mtab e sostituiamolo con un link simbolico a /proc/mounts per ridurre ulteriormente gli accessi

rm /etc/mtab

ln -s /proc/mounts /etc/mtab

 

Ora installiamo il kernel.

Dapprima utilizziamo lo script presente in /dev per creare i diversi file di dispositivo

cd /dev

./MAKEDEV generic

Anche questo prenderà un po' di tempo.

Quindi installiamo il kernel; personalmente ritengo sia inutile compilarlo poichè se il sistema su chiavetta deve essere in grado di girare su più computer possibili, per evitare errori di compatibilità dovremmo usare tutte le opzioni a nostra disposizione, quindi installiamo una versione precompilata con:

apt-get install linux-image-2.6.18-4-686

sostituire la parte finale con l'ultima versione di kernel uscita e l'ottimizzazione per la vostra architettura

apt-get clean

e poi per generare il nuovo initramfs

update-initramfs -u

 

Quindi installiamo il boot loader

apt-get install grub

apt-get clean

e quindi diamo il comando

grub

questo ci aprirà una simil-linea di comando, nella quale digiteremo

root (hd0,0)

 

/media/disk/usr/share/zoneinfo/*/posix/America/Boise

 

 

se infine vogliamo creare una copia di sicurezza della cartella possiamo usare dd

dd if=/dev/sda of=/home/Backup.img

crea un'immagine che può essere scritta su una chiavetta delle stesse dimensioni con

dd if=/home/Backup.img of=/dev/sda

oppure un metodo più convenzionale (e flessibile) con tar:

tar -cjvf /home/Backup /mnt/key

e per estrarlo in qualunque posto, posizionarsi nella cartella desiderata con cd

cd /dovevuoiscompattare

tar -xvjf /home/Backup

 

 

 

 

 

 

 

 

 

 

GPG how-to

questo tutorial è finalizzato ad insegnare l'utilizzo di GnuPrivacyGuard, un programma volto alla cifratura largamente usato nel mondo linux. L'obbiettivo è rendere più sicure le comunicazioni ed evitare l'intercettazione di dati sensibili o meno da parte di terzi

 

Qualche chiarimento sui concetti di gpg

Per il funzionamento generale si può consultare http://it.wikipedia.org/wiki/GNU_Privacy_Guard

Più particolare è il firmare i documenti: questo processo comporta che il programma faccia un hashing del documento: l'hashing non può essere lo stesso per due documenti, per quanto simili possano essere (in teoria); questo calcolo hashing viene inoltre criptato attraverso la chiave privata (operazione che può essere fatta solo da chi possiede la chiave e la password). Il programma del ricevente utilizza la chiave pubblica per decriptare il calcolo e lo verifica. Questo comporta che il documento può essere stato firmato solo dal mittente (siccome viene criptato con la chiave privata) ed è necessariamente quello che si ha davanti (a causa del calcolo hashing)

La firma delle chiavi invece è una cosa diversa: il più grosso buco di sicurezza in un sistema di crittografia asimmetrica è la certificazione dell'autenticità della chiave. Ovvero: come faccio io a sapere che quella che ho io è la vera chiave di quella persona e non un falso creato da qualcun'altro? La soluzione è la web of trust, ovvero la ragnatela della fiducia; il concetto non è semplice, e rimando a quest'altro link per approfondire l'argomento http://www.gnupg.org/howtos/it/gpg-party.html

 

Per prima cosa dobbiamo scaricare il programma, quindi diamo il comando

apt-get install gnupg

a questo punto abbiamo il programma installato sul nostro computer, facciamo il login con l'utente che utilizziamo di solito e digitiamo

gpg --gen-key

che darà inizio alla creazione della coppia di chiavi pubblica privata attraverso una serie di domande:

alla prima verrà chiesto il tipo di chiave da utilizzare, selezionare la prima scelta, ossia

   (1) DSA and Elgamal (default)

alla domanda successiva basterà la risposta di default, quindi basterà premere invio per impostare una chiave a 2048 bit, dopodichè andrà indicata la durata della validità della chiave, scegliendo tra le varie opzioni

         0 = la chiave non scadrà

      <n>  = la chiave scadrà dopo n giorni

      <n>w = la chiave scadrà dopo n settimane

      <n>m = la chiave scadrà dopo n mesi

      <n>y = la chiave scadrà dopo n anni

se avete intenzione di utilizzare questa chiave come definitiva, allora scegliete pure 0; dopo è indicate l'ID, ovvero nome, cognome, email e un eventuale commento per identificare la chiave.

l'ultimo passo è scegliere una passphrase le regole per la scelta di una buona passphrase sono sempre quelle, basta che poi siate in grado di ricordarvela ;)

infine verrà generata la coppia di chiavi, e il programma avrà bisogno di entropia per effettuare questo passaggio, quindi continuate ad usare il computer come al solito. Finita la creazione, la chiave sarà aggiunta al database

 

per visualizzare la propria chiave si può dare il comando

gpg -a --export [ID]

per ID si intende il nome/cognome o l'indirizzo email presente nell'ID

l'opzione -a equivale a --armor e serve a stampare l'output in formato ASCII, utile per evitare problemi legati al charset

per salvare la chiave in un file utilizzare il comando -o (--output) seguito dal nome del file

gpg -ao public.asc --export [ID]

è bene inoltre creare un certificato di revoca e salvarlo in un luogo (molto) sicuro, nel caso la chiave privata cada in mani sbagliate o ci si dimentichi la passphrase

gpg -ao /fort_knox/cert_revoca.asc --gen-revoke [ID]

 

ora si possono fare dei test per divertirci e verificare il corretto funzionamento della chiave, diamo

echo 'testodiprovasenzasenso' > prova

e dopo

gpg -aes -r [ID] prova

analizzando gli argomenti vediamo che sono stati introdotti -s (--sign) per firmare il documento, -e (--encrypt) per cifrare, mentre -r (--reciepent) serve ad indicare il destinatario, ovvero la chiave pubblica da usare per cifrare il messaggio

possiamo verificare il risultato dando

cat prova.asc

che apparià ovviamente privo di senso.

si può anche generare una firma non cifrata semplicemente omettendo -e, mentre per generarne una separata dal testo va usata l'opzione -b

ad esempio

gpg -ab prova

che genererà il file prova.asc

si può notare che qua non serve indicare il destinatario: ovviamente la firma viene fatta utilizzando la propria chiave privata.

 

per decifrare i documenti e verificare le firme basterà utilizzare il comando

gpg -o nomefiledecifrato -d nomefilecifrato

ovviamente -d (--decrypt) serve a decifrare il file, ma anche a verificare la firma, se essa è presente

se il file è firmato ma non decifrato, si userà

gpg --verify nomefilefirmato

mentre se la firma è distaccata basta aggiungere il nome del file contenente la firma prima di quello del file

 

per importare una chiave il comando sarà

gpg --import nomefileconlachiave

Il programma salverà tutte le chiavi pubbliche acquisite in un database, e questo è consultabile con

gpg --list-key

per avere la lista completa, ed è anche possibile modificare le chiavi: date il comando

gpg --edit-key [ID]

al che i comandi possibili sono

1 per cambiare la password      passwd                                          solo per la nostra chiave

2 aggiungere un ID              adduid                                          come sopra

3 cancellare un ID              uid seguito da un numero, quindi deluid         idem

4 visualizzare il fingerprint   fpr

5 firmare la chiave             sign

6 visualizzare le firme         check

6 salvare i cambiamenti         save

7 uscire                        quit

ricordate che ogni cambiamento alla chiave comporterà che questa vada ridistribuita a tutti coloro che ne hanno una copia, quindi effettuate questi cambiamenti con cautela!

 

infine per cancellare una chiave

gpg --delete-keys [ID]

nel caso di una chiave privata invece

gpg --delete-secret-and-public-key [ID]