====== Amministrazione GNU/Linux ======

===== Documentazione e rif. web =====

  * **[[http://www.pathname.com/fhs/|Filesystem Hierarchy Standard]]**: [[http://www.pathname.com/fhs/pub/fhs-2.3.pdf|fhs-2.3.pdf]]
  * **[[http://www.debian.org/doc/manuals/maint-guide/|Guida per il nuovo Maintainer]]** (come creare pacchetti Debian)
  * **[[http://www.debian.org/doc/manuals/debian-reference/|Debian Reference]]**

===== Comandi Unix =====

=== shell Bash: caratteri speciali, variabili ===
  * Caratteri speciali: asterisco, punto interrogativo, parentesi quadrata.
  * Variabili d'ambiente.
  * Dollaro, apice e doppio apice.
  * Programmazione shell.

=== find ===
Criteri di selezione:
  * Tipo di oggetto **''-type''**
  * Nome **''-name''**
  * Data di modifica **''-mtime''** e **''-mmin''**
  * Proprietario e permessi **''-user''**, **''-group''** e **''-perm''**
  * Parametro **''-print0''**

=== xargs ===
Parametri spciali:
  * Usa un parametro per volta **''-n1''**
  * Non eseguire il comando se l'input è vuoto **''-r''**
  * Gli argomenti sono seprati da caratteri NULL invece che da sapazi **''-0''**
  * Sostituisce l'argomento dentro il comando invece che in coda: **''-I replace-string''**

=== grep, cut e awk ===

Espressioni regolari, vedere man page per **''grep(1)''** e **''regex(7)''**
  * Punto
  * Quantificatori : **%%*%%** e **%%+%%**
  * Lista di caratteri **%%[]%%** e classi
  * Caratteri speciali (backslash character)
  * Gruppo: **%%()%%**

=== sed ===
  * Sostituzione di espressione regolare \\
<code>
echo "tre civette sul como" | sed 's/civette/gufi/'
</code>

<code>
echo "23 civette sul como" | sed 's/\([0-9]\+\) civette/gufi \1/g'
</code>

=== tar ===
  * Creazione e estrazione di un archivio
  * Copia su host remoto

Copia di una directory su server remoto senza creazione di file intermedio:

<code>
tar jcf - directory | ssh niccolo@paros.rigacci.org 'tar jxvf -'
</code>

=== tcpdump e netstat ===
  * Ispezionare traffico per indirizzo IP e porta

Ispezionare il traffico con due clausole:
<code>
tcpdump -i eth0 -n 'not port 22 and host 74.125.43.100'
</code>

Salva il dump in un file:
<code>
tcpdump -w tcpdump.log -s0 -i eth0 -n 'port 80 and dst host 74.125.43.104'
</code>

Per vedere il contenuto di un dump:
<code>
strings tcpdump.log
tcpdump -r tcpdump.log -n
</code>

Per vedere tutte le porte aperte:
<code>
netstat -n -a
</code>

=== ps, kill ===
  * Segnale TERM (15) e KILL (9)

=== ssh, scp ===

Per entrare su un host remoto senza digitare la passowrd: si crea una chiave RSA (coppia di chiavi pubblica e privata) con il comando **''ssh-keygen''**. La chiave pubblica **''.ssh/id_rsa.pub''** deve essere aggiunta al file **''.ssh/authorized_keys''** sull'host remoto.

Trasportare il protocollo X (display grafico) tramite un tunnel ssh e uso della variabile **''$DISPLAY''**.

**Primo caso**: applicativo che gira in **remoto**, **display locale**. Il traffico X passa nel tunnel ssh attivato dall'opzione **''-X''**:

<code>
ssh -X username@host.remoto
echo $DISPLAY
xclock
</code>

**Secondo caso**: applicativo che gira in **locale** (192.168.1.1), **display remoto** (192.168.1.2). Il traffico X transita in chiaro sulla rete locale.

Sul sistema remoto:

<code>
# Abilitare X all'uso del tcp configurando il login manager:
vi /etc/gdm/gdm.conf # DisallowTCP=false
xhost +192.168.1.1
</code>

Sul sitema locale:

<code>
export DISPLAY=192.168.1.2:0.0
xclock
</code>

**Terzo caso**: prendere **possesso del display remoto**. Si accede al display X tramite il protocollo VNC grazie al programma **''x11vnc''**. Il traffico transita blandamente criptato dal protocollo VNC.

Si entra sulla macchina remota come root e si esegue **''x11vnc''** con il parametro **''-auth''**.

<code>
ssh root@192.168.1.2
ps uax | grep auth
# Individuare il file -auth usato da X
x11vnc -auth /var/lib/gdm/:0.Xauth
</code>

In alternativa si chiede all'utente remoto di eseguire ''x11vnc'', senza parametri.

Altra alternativa: si entra sulla macchina remota come utente che ha effettuato il login (che ha il possesso del display) e si esegue:

<code>
export DISPLAY=0:0
x11vnc
</code>

In tutti i casi il programma ''x11vnc'' avvia un server VNC collegato al display X. In locale si esegue:

<code>
vncviewer 192.168.1.2
</code>

**Tunnel di una porta TCP**

Tunnel di una porta locale verso un host remoto:

<code>
ssh -L 8888:192.168.2.22:80 user@remotehost
</code>

Tunnel di una porta remota verso un host locale:

<code>
ssh -R 8888:192.168.1.11:80 user@remotehost
</code>

=== vi ===
  * Modo comandi e modo edit
  * Cancellare un carattere o una linea: x dd
  * Aggiungere del testo: i o
  * Salvare e uscire: ESC : wq
  * Uscire senza salvare: ESC : q!
  * Ricerca, sostituzione

=== dump e restore ===
Il comando **''dump(8)''** fornito dall'omonimo pacchetto, lavora a livello di intero filesystem, è compatibile con fs **ext2** ed **ext3**. È in grado di salvare tutti gli oggetti del filesystem, compresi link, file speciali block e character (/dev/...), mantiene il numero di inode. È possibile fare il restore su un filesystem di dimensione differente.

Dump su file (deve stare su partizione diversa da quella interessata al dump):
<code>
dump -0 -b 64 -f /mnt/hda1.dump /dev/hda1
</code>

Dump su file su host remoto:
<code>
dump -0 -b 64 -f - /dev/hda1 | ssh niccolo@192.168.182.10 'cat > firesmall_hda1.dump'
</code>

Dump con restore contestuale remoto:

Sulla macchina che riceve il restore preparo la partizione (deve essere appena formattata):

<code>
fdisk /dev/sdd
mkfs.ext3 -I 128 /dev/sdd1
mount /dev/sdd1 /mnt
</code>

Sulla macchina che contiene i dati eseguo:
<code>
dump -0 -b 64 -f - /dev/hda1 | ssh root@192.168.182.10 'cd /mnt && restore -r -b 64 -f -'
</code>

Al termine del restore il file **restoresymtable** può essere eliminato.

Come visualizzare interattivamente il contenuto di un dump ed effettuare il restore selettivo ad esempio di una directory:

<code>
restore -i -f /backup/argo/2007-01-26_md3.dump
restore > cd directory
restore > ls
restore > add pippodir
restore > extract
You have not read any volumes yet.
Unless you know which volume your file(s) are on you should start
with the last volume and work towards the first.
Specify next volume # (none if no more volumes): 1
set owner/mode for '.'? [yn] y
restore > quit
</code>

===== Gestione pacchetti Debian =====

  * Lista dei pacchetti installati: **''%%dpkg --list%%''**
  * Lista dei file forniti da un pacchetto: **''dpkg -L <package>''**
  * A quale pacchetto appartiene un file: **''dpkg -S <file>''**
  * Cerca un pacchetto tra quelli disponibili: **''apt-cache search <string>''**
  * File di configurazione con i repository da usare: **''/etc/apt/sources.list''**
  * I file di controllo di un pacchetto **''/var/lib/dpkg/info/<package>.*''**

Installazione da repository:
<code>
apt-get update
apt-get upgrade
apt-get install <pacchetto>
</code>

Installazione singolo file .deb:
<code>
dpkg -i <file.deb>
</code>

Rimozione di un pacchetto:
<code>
dpkg --remove <pacchetto>
dpkg --purge <pacchetto>
</code>

==== Creazione di un pacchetto Debian ====
  * Pacchetto binary
    * File di controllo
      * **''DEBIAN/control''**
      * **''DEBIAN/md5sums''**
    * **''fakeroot dpkg-deb --build <directory>''**
  * Pacchetto source
    * File di controllo
      * **''debian/control''**
      * **''debian/rules''**
    * **''dpkg-buildpackage -rfakeroot''**

Scaricare i sorgenti di un pacchetto (scarica i sorgenti, li scompatta e applica le patch Debian):

<code>
apt-get source <package>
</code>

oppure si scaricano i tre componenti dei sorgenti:

<code>
wget http://....package.orig.tar.gz
wget http://....package.diff
wget http://....package.dsc
</code>

e si scompattano con:

<code>
dpkg-source -x package.dsc
</code>




===== Sicurezza programmazione web =====
  * **''register_globals''**
  * Funzioni **''include()''**
  * Estensione dei file da includere
  * Esecuzione di una **''system()''**
  * Esecuzione di una query SQL
  * Funzione **''mail()''**
  * Output HTML e **''htmlentities()''**
  * PHP e safe mode

===== Virtualizzazione =====

Vedere anche: **[[..:sa:qemu]]**.

  * **Qemu** con e senza modulo kernel kqemu.\\ Emulazione (kernel code) ed esecuzione nativa (per lo user code). L'accelerazione Kqemu è LGPL solo dal 2007-02.
  * **Xen** i386, amd64, powerpc, ia-64, ... licenza GPL2.\\ Virtual machine monitor, cioè si tratta di un hypervisor che controlla l'esecuzione di uno o più sistemi ospite, tali sistemi devono essere compatibili con Xen.
  * **KVM** licenza GPL/LGPL, i386, amd64, s390, powerpc, ia64.\\ Virtualizzazione nativa per CPU Intel-VT e AMD-V

Creare l'immagine di un disco virtuale, creare l'immagine da un cdrom, avviare qemu facendo boot da cdrom:

<code>
qemu-img create -f raw rootfs_img.raw 2048M
dd bs=4096 if=/dev/cdrom of=winxp.img
qemu -hda rootfs_img.raw -cdrom cdrom_xp -boot d
</code>

Opzione utile **''-m megs''** per assegnare la memoria alla macchina virtuale (128 default).

==== Collegare una macchina virtuale direttamente alla LAN ====

Occorre creare uno switch virtuale e collegare ad esso sia la macchina fisica che la macchina virtuale.

Configurare sulla macchina fisica l'interfaccia bridge **br0**:

  * Installare pacchetto **bridge-utils**
  * Verificare che il modulo kernel **''bridge''** sia installato
  * Modificare /etc/network/interfaces
  * /etc/init.d/networking restart

Questo il contenuto di **''/etc/network/interfaces''**

<file>
#interfaccia virtuale da attaccare all'interfaccia fisica, la eth non avrà l'indirizzo
auto br0
iface br0 inet dhcp
        bridge_ports eth0
        #Disable spanning tree protocol
        bridge_stp off
        #max wait for the bridge ports to get to the forwarding status
        bridge_maxwait 10
</file>

Facciamo partire qemu con:

<code>
sudo qemu -hda rootfs_img.raw -m 512 -net nic -net tap
</code>

Colleghiamo il cavetto virtuale allo switch virtuale con:

<code>
sudo brctl addif br0 tap0
</code>

==== Usare KVM invece di QEMU ====

Verificare che la CPU abbia il supporto **vmx** (Intel) oppure **svm** (AMD) guardando **''/prco/cpuinfo''**. Potrebbe essere necessario attivarla anche da BIOS (VT technology).

Caricare il modulo kernel **kvm_intel** oppure **kvm_amd**.

Installare il pacchetto **kvm**.

Si usa il programma **''kvm''** al posto di ''qemu'', con la stessa sintassi.

==== lbvirt ====

Si tratta di una collezione di utility e script per la gestione di macchine virtuali Qemu, KVM e Xen. Consente la creazione, avvio, stop, ecc. di macchine virtuali con comandi e sintassi uniforme nonostante possa usare tecnologie di virtualizzazioni diverse. La configurazione è in **''/etc/libvirt/''**.

La shell di controllo (in modalità testo) è il programma **''virsh''**. Per una console grafica su può installare **[[http://virt-manager.et.redhat.com/|virt-manager]]**.

===== PGP e GPG: crittografia e firma =====

Vedere anche: **[[..:tux:gpg]]**.

  * PGP (Pretty Good Privacy) l'originale scritto da Phil Zimmermann, software non libero.
  * GPG (GNU Privacy Guard) scritto da Free Software Foundation. Compatibile con PGP.

Creazione della nostra coppia di chiavi, elenco delle chiavi pubbliche e private nel nostro portachiavi:

<code>
gpg --gen-key
gpg --list-keys
gpg --list-secret-keys
</code>

Esportare una chiave in formato ASCII

<code>
gpg --armor --export 186F2F56 > keyfile.txt
</code>

Per importare una chiave dal formato ASCII

<code>
gpg -i --import keyfile.txt
</code>

Per importare una chiave da un keyserver:

<code>
gpg --recv-keys 111FA57C
</code>


==== Cifrare/decifrare un file da riga di comando ====

<code>
gpg --encrypt <filename>
gpg --decrypt <filename>.gpg
</code>

Per produrre un file criptato, ma in formato ASCII:

<code>
gpg --armor --encrypt <filename>
gpg --decrypt <filename>.asc
</code>

==== Firmare una chiave ====

Come firmare la chiave di qualcuno: **[[http://www.gnupg.org/howtos/it/gpg-party.html|GnuPG Keysigning Party HOWTO]]**

<code>
gpg --sign-key <Key_ID>
gpg --keyserver <keyserver> --send-key <Key_ID>
</code>