Repository 32bit  Forum
Repository 64bit  Wiki

Slackware chrooting bind installazione e configurazione

Da Slacky.eu.

Indice

Introduzione e Licenza

Questo documento vuole essere una guida per facilitare chiunque voglia installare il bind 8 in ambiente chrootato sotto Linux/Slackware, si tratta solamente di un insieme di conoscenze reperite in rete e del frutto di una serie di esperienze personali. Non è coperto da licenza di nessun genere, usatelo come preferite, tagliatelo, miglioratelo, commentatelo, fatene quello che volete; Se citate il mio nome in qualche documento che ha preso spunto da questo mi fa? ovviamente piacere. Chiunque voglia segnalare errori, o correzioni è il benvenuto. Tutti i software menzionati sono marchi o marchi registrati dei legittimi proprietari se non diversamente specificato. Consiglio di leggervi sempre le licenze abbinate ai pacchetti che potrebbero essere soggette a cambiamenti o vincoli di svariato genere.

Software Necessario

Bind 8.3.x (named) ftp://ftp.isc.org/isc/bind/src/8.3.x/bind-src.tar.gz

Installazione

  • -chroot-

Comunemente, all'avvio della macchina l'ordine di tutto ciò che è memorizzato nel sistema si trova nella directory radice (root appunto) ovvero "/". L'ambiente chroot come lascia trasparire la parola stessa cambia quest?ordine. Per capirci meglio, chrootare un servizio significa ricreare l?ambiente root "/" sotto un'altra directory (es. /home/myservices ). Insomma facciamo credere al servizio in questione di trovarsi in "/" ma in realtà lo prendiamo in giro.

  • pre-install

Dato per scontato che siamo davanti alla nostra nuova o seminuova postazione, la prima cosa da fare è procurarci i sorgenti necessari. Per comodità creiamoci una directory di installazione:

[root at blah:~#] cd /tmp
[root at blah:~#] mkdir chinstall
[root at blah:~#] cd chinstall

Scarichiamo qui il pacchetto sorgente del bind 8.

  • Creare l?ambiente chroot

Per cominciare dobbiamo crearci la directory che camufferemo da "/"

[root at blah:~#] mkdir /chservices

Ora dobbiamo creare sotto /chservices tutte le directory necessarie al corretto funzionamento del servizio che chrootiamo, proprio come se fosse un nuovo file system (il nostro servizio è convinto di essere in "/") Per il Bind quindi faremo così:

[root at blah:~#] mkdir /chservices/named
[root at blah:~#] mkdir /chservices/named/bin
[root at blah:~#] mkdir /chservices/named/data
[root at blah:~#] mkdir /chservices/named/dev
[root at blah:~#] mkdir /chservices/named/etc
[root at blah:~#] mkdir /chservices/named/lib
[root at blah:~#] mkdir /chservices/named/usr
[root at blah:~#] mkdir /chservices/named/usr/bin
[root at blah:~#] mkdir /chservices/named/usr/sbin
[root at blah:~#] mkdir /chservices/named/usr/share
[root at blah:~#] mkdir /chservices/named/var
[root at blah:~#] mkdir /chservices/named/var/log
[root at blah:~#] mkdir /chservices/named/var/run

Per capire l'ambiente provate a vedere le directory escludendo il prefisso /chservices/named. A questo punto installiamo il bind come fosse un installazione normale fino in fondo. Già che ci siamo tentiamo di utilizzare CFLAGS particolari. Le CFLAGS sono caratteristiche del compilatore che hanno diverse utilità, Noi le usiamo per ottimizzare gli eseguibili e perché no, per cercare di rendere più difficoltosa qualche eventuale intrusione. Per fare questo dobbiamo modificare il Makefile relativo all'installazione su piattaforme Linux:

[root at blah:~#] pwd
/tmp/chinstall
[root at blah:~#] tar zxvf bind-src.tar.gz

-> Directory sorgente del bind estratta

[root at blah:~#] cd src/

Editiamo il Makefile

[root at blah:~#] vi port/linux/Makefile.set

Modifichiamo questa riga da così:

'CDEBUG=-O2 -g'

a così:

'CDEBUG=-O3 -fomit-frame-pointer -fstrength-reduce -fexpensive-optimizations -g'

Salviamo ed usciamo dall?editor.

N.B. Non farò riferimento qui alle flags di ottimizzazione di compilazione, tenete presente che ne esistono molte, documentate e non. L?utilizzo di queste flags è facoltativo potete scegliere di non utilizzarle non modificando il Makefile.set. Siamo pronti per compilare:

[root at blah:~#] make ; make all
[root at blah:~#] make install

Questa operazione ci è servita per (in seguito) poter copiare gli eseguibili necessari nelle directory dell?ambiente chrootato. Adesso dobbiamo pianificare la nostra installazione: Il Logging: Dando per scontato che tutti conoscano la metodologia di Logging di Slackware, dei sistemi *nix in generale e l'importanza di questo ci troviamo davanti ad una scelta:

1. Utilizzare il syslogd classico (opzione -a per ambienti chroot in "release" recenti), oppure

derivati del syslogd quali syslog-ng, ssyslog etc.. (il metodo di logging si basa sugli stessi principi, quindi non ci cambia nulla).

2. Far loggare direttamente al bind.

La differenza sta nel fatto che nel primo caso dobbiamo modificare il syslog.conf, (o copiarlo nell'ambiente chroot per versioni meno recenti) nel secondo caso andiamo a modificare il named.conf con una serie di parametri non troppo intuitivi, e noi che sappiamo complicarci la vita da soli così bene optiamo per la seconda che ho detto®. Vediamo con il comando ldd a quali librerie si appoggia il servizio che dobbiamo ?chrootare?: (man ldd per informazioni dettagliate)

[root at blah:~#] ldd /usr/sbin/named
libc.so.6 => /lib/libc.so.6 (0x40020000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
[root at blah:~#] ldd /usr/sbin/named-xfer
libc.so.6 => /lib/libc.so.6 (0x40020000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)

Vediamo anche la bash ed ls con lo stesso procedimento (in modo da poter fare almeno una ristretta prova con l?ambiente chrootato):

[root at blah:~#] ldd /bin/bash
libtermcap.so.2 => /lib/libtermcap.so.2 (0x40020000)
libdl.so.2 => /lib/libdl.so.2 (0x40024000)
libc.so.6 => /lib/libc.so.6 (0x40028000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
[root at blah:~#] ldd /bin/ls
librt.so.1 => /lib/librt.so.1 (0x40020000)
libc.so.6 => /lib/libc.so.6 (0x40032000)
libpthread.so.0 => /lib/libpthread.so.0 (0x40144000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)

Ora copiamo librerie e files necessari:

[root  at blah:~#] cp -p /etc/{localtime,named*,nsswitch.conf,resolv.conf} /chservices/named/etc
[root  at blah:~#] cp -p /usr/bin/{dig,dnsquery,host,nslookup,nsupdate} /chservices/named/usr/bin/
[root  at blah:~#] cp -p /usr/sbin/{ndc,named*,irpd,dnskeygen} /chservices/named/usr/sbin/
[root  at blah:~#] cp -p /lib/{ld-linux.so.2,libc.so.6} /chservices/named/lib
[root  at blah:~#] cp -p /lib/{libnss_compat*,libnss_dns*,libnss_files*} /chservices/named/lib/
[root  at blah:~#] cp -p /lib/{libdl.so.2,libpthread.so.0,librt.so.1,libtermcap.so.*}
/chservices/named/lib/
[root at blah:~#] cp -p -R /usr/share/zoneinfo /chservices/usr/share/
[root at blah:~#] cp -p /bin/bash /bin/ls /chservices/named/bin

Chiaramente il nostro ambito chroot avrà bisogno di utente e gruppo per essere eseguito, creiamo quindi i file passwd group e shadow in questo modo:

[root at blah:~#] echo "named:x:54637:54637::/chservices/named:/bin/false" >
/chservices/named/etc/passwd
[root at blah:~#] echo "named:x:54637:" > /chservices/named/etc/group
[root at blah:~#] echo "named:9797:0:99999::::::" > /chservices/named/etc/shadow
[root at blah:~#] groupadd -g 54637 named

Mknod viene usato qui per creare files speciali (device) per comunicare con il sistema operativo (logging e quant?altro). Normalmente vengono creati durante l'installazione e quindi sono già presenti, ma stiamo per far ?girare? un servizio in chroot, quindi il servizio in questione non vedrebbe questi devices e non avrebbe i permessi per utilizzarli. Andiamo quindi a creare questi devices:

[root at blah:~#] cd /chservices/named/dev
[root at blah:~#] mknod tcp c 11 42
[root at blah:~#] mknod udp c 11 41
[root at blah:~#] mknod log c 21 5
[root at blah:~#] mknod null c 13 2
[root at blah:~#] mknod zero c 13 12
[root at blah:~#] chgrp sys null zero
[root at blah:~#] chmod 666 null
[root at blah:~#] mknod conslog c 21 0
[root at blah:~#] mknod syscon c 0 0
[root at blah:~#] chmod 620 syscon
[root at blah:~#] chgrp tty syscon
[root at blah:~#] chgrp sys conslog

Creiamo/copiamo I nostri files di zona in /chservices/data e andiamo a settarci i permessi:

[root  at blah:~#]  cd /chservices/named
[root  at blah:~#]  chmod -R g-w var
[root  at blah:~#]  chmod -R a-w var
[root  at blah:~#]  touch var/run/named.pid
[root  at blah:~#]  chmod 750 data
[root  at blah:~#]  chmod 640 data/*
[root  at blah:~#]  cd ..
[root  at blah:~#]  chmod 750 named
[root  at blah:~#]  chown -R 54637:named named

N.B. Utilizzando un filesystem che supporta il chattr (ext2, ext3) potete usare questo comando nel caso vogliate una maggiore sicurezza (anche contro voi stessi se sbadatamente tentate di cancellare il file di zona sbagliato.) Ed ora rechiamoci nelle directory dove abbiamo eseguito l?installazione del bind (quella iniziale in ambito NON chroot) e deletiamo o cambiamo permessi ai vari files che riguardano il named:

[root at blah:~#] cd /usr/sbin
[root at blah:~#] chmod -x named* dnskeygen dnssec-*

Bene, ora possiamo provare l'ambiente chroot così:

[root at blah:~#] chroot /chservices/named

Avendo installato la bash ed ls possiamo "vedere" l'ambiente: un semplice ls ci restituirà le directory create sotto /chservices/named, ed anche con un "cd .." scopriamo che non possiamo "uscire" dalla directory chrootata che vediamo come fosse "/". Per uscire dall'ambito chroot un exit è sufficiente.

N.B.

Sia la bash che ls li abbiamo chrootati solo come prova di funzionamento, dal momento che installiamo i servizi chroot per fare in modo che un eventuale intrusione non conceda un ambiente interattivo ad un ipotetico aggressore sarebbe proprio il caso, di cancellare sia gli eseguibili che le librerie dalle directory chrootate. Ora che abbiamo fatto le nostre prove e cancellato i files che potevano crearci problemi possiamo eseguire il named in chroot:

[root at blah:~#] chroot /chservices/named /usr/sbin/named -g 54637 -u 54637

Con ps aux vediamo il nostro named in chroot che gira come utente 54637. Qualcosa è andato storto. In questo caso ci tocca editare il file di configurazione del bind di cui facciamo un esame di base nel prossimo paragrafo.

Configurazione

Note sulla Sicurezza

Risorse e FAQ

Ringraziamenti

Strumenti personali
Namespace

Varianti