Emanuele Cipolla

Alzi la mano il sysadmin che vuole tutti gli utenti con accesso via SSH1 che vi vagano per il sistema!Vedo qualche mano alzata in fondo… ma probabilmente non sanno nemmeno di che si parla. Andiamo al punto; noi vogliamo creare un sotto sistema in cui gli utenti si possono muovere senza inficiare la sicurezza del sistema vero.

Questo è l’incipit di un post chiaro ed esaustivo pubblicato da Salvatore Barbera sul suo Blog Informatico, che mostra una delle applicazioni “standard” di una chroot, un “sistema dentro il sistema“. In realtà, oltre alle esigenze di sicurezza, o di test di una particolare sistema operativo o di un’applicazione, c’è anche un altro motivo per voler avere una chroot sul proprio sistema. Per capire di cosa si tratta, dovete essere (come lo sono io) utenti di una distribuzione GNU/Linux nativa per architettura x86_64.

Infatti, sebbene il primo processore x86_64 funzionante (un AMD Opteron) sia stato prodotto nel 2003, non si è ancora riusciti a far capire agli sviluppatori, specie quelli di software proprietario, che sarebbe il caso di effettuare il porting sulla nuova architettura. È altamente improbabile, secondo me, che si riesca ad ottenere questo in tempi brevi: basti considerare come vengono lasciati soli gli utenti PowerPC.

Noi utenti x86_64, siamo, oggettivamente, più fortunati di altri: la possibilità di eseguire binari x86 ci permette di porre rimedio al problema, almeno temporaneamente: quando non abbiamo a disposizione un programma nativo a 64 bit, possiamo eseguirne uno a 32. Per fare questo abbiamo due possibilità:

1. Installare un subset di librerie a 32 bit direttamente nel sistema base a 64: il mantainer della distribuzione fornisce dei pacchetti contenenti un subset delle librerie di un sistema completo a 32 bit che costituiscono lo stretto necessario all’esecuzione dei programmi più comuni; se sono necessarie altre librerie extra, l’utente è tenuto ad installarle a mano, pena il mancato funzionamento del programma. Si tratta, certamente, del metodo più semplice da comprendere e da gestire per un newbie. Questo all’inizio, perchè poi, man mano che si vanno installando programmi “esterni”, la situazione si incasina in maniera inverosimile. Risultato: l’utente rinuncia – nei casi migliori, passa ad un sistema solo a 32 bit, in quelli peggiori cancella GNU/Linux.
2. Creare una chroot di un sistema a 32 bit quasi completo, e utilizzare metodi porci, brutti e cattivi per far colloquiare le applicazioni poste dentro la “prigione” con il mondo esterno. È la soluzione che richiede il massimo spazio su disco (assicuratevi di aver fatto un’installazione in cui riservate più spazio possibile alla vostra /usr: ad esempio, il profilo “Sistema multi-utente” del Debian Installer), e anche un po’ di lavoro manuale. Tuttavia, una volta messa a regime, effettuarvi delle operazioni di manutenzione è ridicolmente semplice.

Specie nel mondo delle distribuzioni basate su Debian pullulano guide su guide, che si contraddicono tra di loro, su come creare una chroot a 32 bit. Quel che farò è cercare di scrivere una guida definitiva, che permetta di fare (spero) tutto e da subito, incluso quello in cui altre latitano, come la riproduzione del suono e la stampa dagli applicativi “imprigionati”.

Tutto questo subito dopo il salto.

 Un’avvertenza: io ho scelto di installare la mia chroot in /usr/local/stable32: nel caso voi foste di diverso avviso, siete pregati di modificare appropriatamente la istruzioni da eseguire. Inoltre, si suppone che tutte le operazioni vengano eseguite dall’utente root. Se siete loggati come utenti normali (vedi il caso di Ubuntu), premettete sudo ad ogni comando. Lo schema che seguirò sarà quello di questo articolo, molto semplice e diretto, e da cui mi discosterò solo per alcune minuzie (nei tratti in comune):

1.  Creiamo la directory che ospiterà la chroot:
   mkdir /usr/local/stable32
2. Procuriamoci alcuni programmi fondamentali per l’interazione fra il sistema reale e quello “imprigionato”:
   apt-get install linux32 debootstrap dchroot
3. Installiamo un sistema a 32 bit minimale dentro la directory appena creata:
   debootstrap --arch i386 stable /usr/local/stable32 http://mi.mirror.garr.it/mirrors/debian/debootstrap --arch i386 etch /usr/local/stable32 http://mi.mirror.garr.it/mirrors/debian/¹
4. Aggiungiamo le directory che contengono le librerie a 32 bit nel percorso di ricerca del linker a 64 bit (cioè, questa operazione va effettuata nel vostro sistema vero e proprio, non nella chroot). Creiamo un file nella directory /etc/ld.so.conf.d, così:
   touch /etc/ld.so.conf.d/linux32.conf
   quindi apriamolo con un editor di testo (nano, vi, …) e scriviamo:#Emulazione a 32 bit
/usr/local/stable32/lib
/usr/local/stable32/usr/lib
/usr/local/stable32/usr/X11R6/lib
/usr/local/stable32/usr/local/lib
   Appena abbiamo finito, salviamo ed usciamo dall’editor.
5. Creiamo un collegamento simbolico al linker a 32 bit nella /lib del sistema principale:
   cd /lib; ln -s /usr/local/stable32/lib/ld-linux.so.2 ld-linux.so.2
6. Eseguiamo ldconfig per aggiornare la cache del linker:
   ldconfig
7. Creiamo un po’ di file che al momento non esistono nella chroot:
   for a in /etc/passwd /etc/shadow /etc/group /etc/sudoers /etc/printcap; do touch $a; done
8. Apriamo con un editor di testo il file /etc/fstab del nostro sistema a 64 bit, e aggiungiamo quanto segue in coda allo stesso:
   # chroot
/home /usr/local/stable32/home none bind 0 0
/tmp /usr/local/stable32/tmp none rbind 0 0
/media /usr/local/stable32/media none rbind 0 0
/mnt /usr/local/stable32/mnt none rbind 0 0
/etc/passwd /usr/local/stable32/etc/passwd none bind 0 0
/etc/shadow /usr/local/stable32/etc/shadow none bind 0 0
/etc/group /usr/local/stable32/etc/group none bind 0 0
/etc/sudoers /usr/local/stable32/etc/sudoers none bind 0 0
/etc/printcap /usr/local/stable32/etc/sudoers none bind 0 0
/etc/cups /usr/local/stable32/etc/cups none rbind 0 0
/var/run/cups /usr/local/stable32/var/run/cups none bind 0 0
/usr/share/fonts /usr/local/stable32/usr/share/fonts none bind 0 0
/dev /usr/local/stable32/dev none rbind 0 0
/sys /usr/local/stable32/sys none rbind 0 0
proc /usr/local/stable32/proc proc defaults 0 0quindi salviamo ed usciamo dall’editor.Questo è uno dei punti focali del procedimento: in pratica, stiamo montando delle copie ombra delle nostre principali directory e di alcuni file fondamentali, tramite l’opzione bind (rbind fa la stessa cosa, ma estende il processo anche alle subdirectory del percorso sorgente, se esistono). Questa particolarità fa sì che se cancelliamo il file dentro la chroot, viene cancellato il file originale. Andateci cauti, quindi.
9. Montiamo a mano tutti i percorsi (r)bind aggiunti, o, in alternativa, riavviamo il computer perchè ciò venga effettuato automaticamente (consigliato se siete pigri come me )
10. Editiamo, sempre nel nostro sistema principale, il file /etc/dchroot.conf e aggiungiamo la riga
    stable32 /usr/local/stable32
    quindi salviamo il file ed usciamo dall’editor.
11. Creiamo il file /usr/local/bin/do_dchroot, copiandoci questo testo, quindi salviamo il file, usciamo dall’editor e rendiamo eseguibile il nostro script con un chmod +x /usr/local/bin/do_dchroot.Questo è un altro punto topico. Quando vorremo lanciare un programma che risiede dentro la chroot, non avremo bisogno di altro che creare un collegamento simbolico a questo script nel nostro sistema reale: lo script eseguira dchroot preservando l’integrità di tutti i parametri passati, ed eseguira il programma senza problemi. Come applicazione pratica di questo concetto, creeremo un secondo script, leggermente modificato per le nostre esigenze, che ci permetterà di eseguire direttamente apt-get dentro la chroot, così da poter automatizzare gli aggiornamenti della stessa, se lo vogliamo.
12. Creiamo il file /usr/local/bin/capt, scrivendoci questo testo. Usciamo dall’editor, rendiamo eseguibile lo script con chmod +x /usr/local/bin/capt e creiamo collegamenti simbolici per i più importanti elementi della toolchain apt: for a in apt-cache apt-get; do ln -s /usr/local/bin/capt /usr/local/bin/c$a; done.In questo modo, quando scriveremo capt-get update aggiorneremo il database dei pacchetti della chroot, in modo molto simile a quanto faremmo per il nostro sistema normale (la lettera c ricorda all’utente che l’operazione viene eseguita dentro la chroot, ed evita che si faccia confusione con il vero apt-get al momento dell’esecuzione).
13. Installiamo un server sonoro nel nostro sistema principale. Io utilizzo EsounD, che si adatta appieno alle mie esigenze perchè non è dipendente da nessun desktop manager in particolare (io uso una particolare combinazione di programmi per realizzare il mio desktop: ne parlerò in un altro post). Se usate GNOME, anche voi usate EsounD, e le istruzioni che seguono sono valide anche per voi ma, credo, non avrete bisogno di applicarle. Se usate KDE, non so se un procedimento analogo debba essere svolto anche per ARTS.
    Eseguiamo quindi apt-get install esound, e aggiungiamo al nostro /etc/rc.local la riga esd -nobeeps & – quindi rendiamo eseguibile il file stesso con chmod +x /etc/rc.local, e riavviamo il computer.Accediamo alla chroot scrivendo dchroot, ed eseguiamo apt-get update; apt-get dist-upgrade; apt-get install cupsys-client. Per uscire dalla chroot, digitiamo exit.

Abbiamo finito. Adesso avete a disposizione un sistema a 32 bit completamente funzionante e interfacciato col mondo esterno. Potete espanderlo come volete, aggiungendo il supporto a diversi codec e a riproduttori multimediali, che funzioneranno, a patto che rilevino il server sonoro in esecuzione (nelle mie prove, mplayer -ao esd ha funzionato magnificamente. Rendete possibile l’esecuzione diretti dei programmi dentro chroot modificando intelligentemente l’esempio datovi con capt (ricordandovi, però, che in ogni caso il link simbolico va fatto a do_dchroot). Potete anche far funzionare il plugin Macromedia Flash, con tanto di sonoro, seguendo il procedimento che ho descritto qui. Se ci sono problemi, dubbi, perplessità o mie dimenticanze, fatelo presente con un commento.

Enjoy

---

¹ Grazie al commentatore axo per la segnalazione.

[via Blog Informatico]
[via Debian Administration]