Differenze tra le versioni di "Integrit: file verification system"

Da Guide@Debianizzati.Org.
Jump to navigation Jump to search
m
Riga 1: Riga 1:
''Torna all'indice: [[Linux Kernel in a Nutshell]]''
+
[http://integrit.sourceforge.net/ Integrit] è un "file verification system": è assimilabile alla famiglia degli [[intrusion detection system]] o [[IDS]] e ha la funzione di verificare che determinati file non subiscano modifiche.
  
di determinare esattamente quali driver e quali opzioni di configurazione sono richiesti per il corretto funzionamento dalla macchina su cui viene installato.
+
Questo genere di controlli hanno molti vantaggi:
di selezione e scelta dei driver corretti.
+
* non sono pesanti: infatti vengono eseguiti prevalentemente di notte e occupano pochi minuti
 +
* sono utili: un aggressore che vuole nascondere dei file, accessi o servizi potrebbe modificare file come [[netstat]], [[last]], [[w]], ls...
 +
* si affiancano a [[ids]] di rete e software come [[rkhunter]]
  
==Usare un kernel di una distribuzione==
+
Ovviamente non si tratta della soluzione di tutti i mali, in quanto potrebbe essere possibile che l'aggressore abbia modificato anche l'eseguibile di integrit, però un controllo in più non fa mai male!
 
 
 
 
 
 
 
 
===Dove si trova la configurazione del kernel?===
 
 
 
Quasi tutte le distribuzioni forniscono il file di configurazione nello stesso pacchetto del kernel. Si consiglia di leggere la documentazione relativa alla distribuzione stessa per sapere dove viene installato il file di configurazione. Solitamente si trova da qualche parte in una sotto-directory di <tt>/usr/src/linux/</tt>.
 
 
 
{{Box|Nota per Debian (NdT)|In debian il file di configurazione di ogni kernel installato si trova in <tt>/boot/</tt> ed ha come nome <tt>config-''versione''</tt>.}}
 
 
 
 
 
 
<pre>
 
$ ls /proc/config.gz
 
/proc/config.gz
 
</pre>
 
 
 
 
 
 
<pre>
 
$ cp /proc/config.gz -/linux/
 
$ cd -/linux
 
$ gzip -dv config.gz
 
config.gz:      74.9% - - replaced with config
 
</pre>
 
 
 
Copiate questo file di configurazione nella vostra directory del kernel e rinominatelo in ''.config''.
 
 
 
 
Usando questo file di configurazione si dovrebbe ottenere sempre un file immagine del kernel (un ''kernel ricompilato'', NdT) funzionante sulla propria macchina.
 
non
 
 
 
===Determinare quali moduli siano necessari===
 
si
 
 
 
della vostra distribuzione nella directory ''/sys''. ''sysfs'' consente di dare un'occhiata a come le varie parti del kernel sono legate l'una a l'altra, questo lo si deduce grazie ai vari collegamenti simbolici (''symlink'' NdT) che puntano all'interno dell'intero filesystem.
 
 
 
In tutti i
 
 
 
Inoltre, la struttura interna del file di sistema ''sysfs'' subisce modifiche, a causa sia della riorganizzazione dei driver sia del fatto che gli sviluppatori del kernel trovano nuovi modi per meglio presentare in ''user space'' le strutture interne del kernel. A causa di questo, col tempo, alcuni dei ''symlink'', precedentemente menzionati in questo capitolo, possono non essere presenti. Tuttavia, le informazioni sono ancora tutte presenti, al massimo sono state un po' spostate.
 
 
 
====Esempio: Come determinare il driver di rete====
 
 
 
 
 
 
Primo: partendo dalle connessioni di rete si risale al device PCI
 
<pre>$ ls /sys/class/net/
 
eth0  eth1  eth2  lo</pre>
 
 
 
 
 
 
Per determinare di quali dispositivi ci si deve occupare, si utilizza il comando ''ifconfig'':
 
 
 
<pre>$ /sbin/ifconfig -a
 
eth0 Link  encap:Ethernet  HWaddr 00:12:3F:65:7D:C2
 
inet  addr:192.168.0.13  Bcast:192.168.0.255  Mask:255.255.255.0
 
UP BROADCAST NOTRAILERS RUNNING MULTICAST  MTU:1500  Metric:1
 
RX packets:2720792 errors:0 dropped:0 overruns:0 frame:0
 
TX packets:1815488 errors:0 dropped:0 overruns:0 carrier:0
 
collisions:0 txqueuelen:100
 
RX bytes:3103826486 (2960.0 Mb) TX bytes:371424066 (354.2 Mb)
 
Base address:0xdcc0 Memory:dfee0000-dff00000
 
eth1 Link  encap:UNSPEC  HWaddr 80-65-00-12-7D-C2-3F-00-00-00-00-00-00-00-00
 
BROADCAST MULTICAST  MTU:1500  Metric:1
 
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
 
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
 
collisions:0 txqueuelen:1000
 
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)
 
eth2 Link  encap:UNSPEC  HWaddr 00-02-3C-04-11-09-D2-BA-00-00-00-00-00-00-00
 
BROADCAST MULTICAST  MTU:1500  Metric:1
 
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
 
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
 
collisions:0 txqueuelen:1000
 
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)
 
lo Link  encap:Local Lookback
 
        inet addr:127.0.0.1  Mask:255.0.0.0
 
UP  LOOPBACK  RUNNING  MTU:16436  Metric:1
 
RX packets:60 errors:0 dropped:0 overruns:0 frame:0
 
TX packets:60 errors:0 dropped:0 overruns:0 carrier:0
 
collisions:0 txqueuelen:1000
 
RX bytes:13409 (13.0 Kb) TX bytes:13409 (13.0 Kb)</pre>
 
 
 
 
 
 
<pre>eth0 Link  encap:Ethernet  HWaddr 00:12:3F:65:7D:C2
 
inet  addr:192.168.0.13  Bcast:192.168.0.255  Mask:255.255.255.0</pre>
 
 
 
Questo risultato dimostra che il dispositivo Ethernet si vede assegnato un indirizzo IP valido (<tt>inet</tt>).
 
 
 
 
 
 
<pre>$ basename `readlink /sys/class/net/eth0/device/driver/module`
 
e1000</pre>
 
 
 
Il risultato mostra che il modulo <tt>e1000</tt> controlla il dispositivo di rete <tt>eth0</tt>. Il comando ''basename'' racchiude in un'unica linea di comando i seguenti passaggi:
 
 
 
: 1. Individua il symlink ''/sys/class/net/eth0/device'' contenuto all'interno della directory ''/sys/device/'', la quale contiene le informazioni relative al dispositivo che controlla ''eth0''. Fate attenzione al fatto che nelle nuove versioni del kernel la directory ''/sys/class/net/eth0'' potrebbe essere un symlink.
 
 
 
 
 
 
che l'oggetto a cui punta questo symlink, per ottenerlo ci serviamo del comando ''readlink'', il quale produce un risultato simile a questo:
 
:<pre>$ readlink /sys/class/net/eth0/device/driver/module </pre>
 
:<pre> ../../../../module/e1000</pre>
 
 
 
 
: <pre>$ basename ../../../../module/e1000</pre>
 
: <pre>e1000</pre>
 
 
 
 
 
 
 
 
 
<pre>
 
$ cd ~/linux/linux-2.6.17.8
 
$ find -type f -name Makefile | xargs grep e1000
 
./drivers/net/Makefile:obj-$(CONFIG_E1000) += e1000/
 
./drivers/net/e1000/Makefile:obj-$(CONFIG_E1000) += e1000.o
 
./drivers/net/e1000/Makefile:e1000-objs := e1000_main.o e1000_hw.o e1000_ethtool.o e1000_param.o
 
</pre>
 
 
 
Si precisa che "e1000'', usato in questo esempio, deve essere sostituito con il nome del modulo che state analizzando.
 
 
 
 
 
 
Adesso si dispone dell'informazione necessaria per poter configurare il kernel. Si esegue lo strumento menu di configurazione:
 
 
 
<pre>$ make menuconfig</pre>
 
 
 
 
 
 
[[Immagine:Config_search.png|center|frame|''Figura 7-1. Ricerca in menuconfig.'']]
 
 
 
 
 
 
[[Immagine:Config_search_found.png|center|frame|''Figura 7-2. Risultato della ricerca in menuconfig.'']]
 
 
 
Il primo elemento nella schermata mostra l'opzione che stavate cercando. Le informazioni mostrate dalla schermata vi dicono che, per attivare il modulo <tt>E1000</tt> nel kernel,  la seguente opzione di configurazione deve essere abilitata:
 
 
 
  Device Drivers
 
      Network device support
 
      [*] Network device support
 
          Ethernet (1000 Mbit)
 
      [*] Intel(R) PRO/1000 Gigabit Ethernet support
 
 
 
Questo modo di procedere funziona per ogni tipo di dispositivo attivo nel kernel.
 
 
 
====Esempio: Un dispositivo USB====
 
 
 
 
<pre>$ ls /sys/class/tty/ | grep USB
 
ttyUSB0</pre>
 
Potete ora eseguire una ricerca di questo dispositivo nel ''sysfs'' allo scopo di trovare il modulo che lo gestisce, utilizzando la stessa procedura mostrata nella sezione precedente:
 
 
 
<pre>$ basename `readlink /sys/class/tty/ttyUSB0/device/driver/module`
 
pl2303</pre>
 
 
<pre>$ cd ~/linux/linux-2.6.17.8
 
$ find -type f -name Makefile | xargs grep pl2303
 
./drivers/usb/serial/Makefile:obj-$(CONFIG_USB_SERIAL_PL2303) += pl2303.o</pre>
 
 
 
Si utilizzi lo strumento di configurazione del kernel, come indicato in [[:Immagine:Config_search_pl2303.png|figura 7-3]], per trovare l'opzione adeguata da abilitare relativa al settaggio dell'opzione CONFIG_USB_SERIAL_PL2303.
 
 
 
[[Immagine:Config_search_pl2303.png|center|frame|''Figura 7-3. Ricerca di USB_SERIAL_PL2303''.]]
 
 
 
 
 
 
[[Immagine:Config_search_pl2303_found.png|center|frame|''Figura 7-4. Risultato della ricerca di USB_SERIAL_PL2303'']]
 
 
 
 
 
 
====Riassunto: Alla scoperta del dispositivo====
 
 
 
Riassumendo, ecco i vari passaggi che servono per identificare il driver funzionante di un dispositivo ad esso collegato:
 
: 1. Trovate la corretta classe di dispositivi in ''sysfs'' relativa al dispositivo che ci interessa. I dispositivi di rete sono elencati in ''/sys/class/net'', mentre i dispositivi tty sono elencati in ''/sys/class/tty''. Gli altri vari dispositivi si trovano in altre sotto-directory di ''/sys/class'', a seconda del tipo.
 
 
:<pre>$ basename `readlink /sys/class/class_name/device_name/device/driver/module`</pre>
 
: 3. Ricercate nei file Makefile con ''find'' e ''grep'' le opzioni <tt>CONFIG_</tt> che abilitano il modulo
 
:<pre>$ find -type f -name Makefile | xargs grep ''module_name''</pre>
 
: 4. Ricercate l'opzione trovata nel sistema di configurazione del kernel,
 
 
 
 
Dopo esserci infilati nel ''sysfs'' e aver seguito i sui symlinks per ricercare passo passo i nomi dei moduli, presentiamo un
 
 
 
<pre>
 
#!/bin/bash
 
#
 
# find_all_modules.sh
 
#
 
for i in `find /sys/ -name modalias -exec cat {} \;`; do
 
    /sbin/modprobe --config /dev/null --show-depends $i ;
 
done | rev | cut -f1 -d '/' | rev | sort -u
 
</pre>
 
 
 
 
 
 
 
 
 
Lo script prevede l'arresto del programma ''modprobe'' prima di caricare il modulo, e visualizza a schermo solo le azioni che eseguirebbe. Questo ci d&agrave; una lista di tutti i moduli che sono necessari al controllo di tutti i dispositivi del sistema. Eseguendo una piccola pulizia della lista, ordinandola e selezionando i campi adeguati,
 
otteniamo il seguente risultato:
 
 
 
<pre>
 
$ find_all_modules.sh
 
8139cp.ko
 
8139too.koo
 
ehci-hcd.ko
 
fimware_vlass.ko
 
i2c-i801.ko
 
ieee80211.ko
 
ieee80211_crypt.ko
 
ipw2200.ko
 
mii.ko
 
mmc_core.ko
 
pcmcia_core.ko
 
rsrc_nonstatic.ko
 
sdhci.ko
 
snd-hda-codec.ko
 
snd-hda-intel.ko
 
snd-page-alloc.ko
 
snd-pmc.ko
 
snd-timer.ko
 
snd.ko
 
soundcore.ko
 
uhci-hcd.ko
 
usbcore.ko
 
yenta_socket.ko
 
</pre>
 
 
 
 
 
 
 
 
 
<pre>FATAL: Module pci:v00008086d00002592sv000010CFsd000012E0bc03sc00i00 not found.
 
FATAL: Module serio:ty01pr00id00ex00 not found.</pre>
 
 
 
 
 
 
==Determinare il modulo corretto partendo da zero==
 
in
 
 
 
 
 
 
Se invece non
 
 
 
 
 
 
&Egrave; inoltre molto importante per il kernel di essere in grado di trovare tutti i filesystem presenti nel sistema, ed in particolare il filesystem di root. Approfondiremop questo aspetto successivamente in [[LKN: Personalizzare un Kernel#Root filesystem|"Root filesystem"]].
 
 
 
 
 
===Dispositivi PCI===
 
 
 
 
 
 
 
 
  
 +
= Installazione =
 +
L'installazione è molto semplice:
 
<pre>
 
<pre>
$ /usr/sbin/lspci | grep -i ethernet
+
# apt-get install integrit
06:04.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL-8139/
 
8139C/8139C+ (rev 10)
 
 
</pre>
 
</pre>
  
il dispositivo che vorremmo fare funzionare.
+
= Configurazione =
 +
I file di configurazione si trovano in <tt>/etc/integrit</tt>. Dopo l'installazione sono presenti i seguenti file:
 +
; integrit.conf : un template di file di configurazione (infatti è tutto commentato), lo utilizzeremo in seguito come punto di partenza
 +
; integrit.debian.conf : il file di configurazione utilizzato dal [[cron]] di Debian
  
{{Box|Nota:|Potreste anche provare a cercare in tutta la configurazione del kernel un dispositivo che corrisponde alla stringa mostrata sopra (un dispositivo della Realtek Semiconductors con nome prodotto RTL-8139/8139C/8139C+), ma questo non funziona sempre. Per questo motivo useremo la via lunga in questo capitolo.}}
+
== Integrit ==
 +
Il file di configurazione di integrit è semplice ed è composto dalle seguenti sezioni:
 +
; root : la directory di partenza (normalmente <tt>/</tt>)
 +
; know : il [[path]] per il database contenente lo stato ''conosciuto'' del sistema (default <tt>/var/lib/integrit/known.cdb</tt>)
 +
; current : il path del database usato per effettuare il confronto tra lo stato ''conosciuto'' e quello ''attuale'' (default <tt>/var/lib/integrit/current.cdb</tt>)
  
+
seguito da un elenco di file da ignorare.
 
 
::<tt>$ '''which lspci'''</tt>
 
::<tt>/usr/sbin/lspci</tt>
 
 
 
Se state usando una distribuzione che mette ''lspci'' in una altra posizione usate il percorso corretto per il vostro caso negli esempi seguenti.
 
 
 
Le primi bit d'informazione che l'output di .
 
 
 
Andiamo in ''sysfs'' dove tutti i dispositivi PCI sono elencati, e guardiamo i loro nomi:
 
  
 +
La sintassi dell'elenco è la seguente:
 
<pre>
 
<pre>
$ cd /sys/bus/pci/devices/
+
[action]/directory [controlli]
$ ls
 
0000:00:00.0 0000:00:1d.0  0000:00:1e.0 0000:00:1f.3 0000:06:03.3
 
0000:00:02.0 0000:00:1d.1  0000:00:1f.0 0000:06:03.0 0000:06:03.4
 
0000:00:02.1 0000:00:1d.2  0000:00:1f.1 0000:06:03.1 0000:06:04.0
 
0000:00:1b.0 0000:00:1d.7  0000:00:1f.2 0000:06:03.2 0000:06:05.0
 
 
</pre>
 
</pre>
  
Il kernel numera i dispositivi PCI con un <tt>0000:</tt> iniziale che non viene mostrato nell'output di ''lspci''. Dunque, aggiungiamo un <tt>0000:</tt> al numero datoci da ''lspci'' e entriamo in quella directory:
+
dove:
 +
; action : è facoltativa, e rappresenta l'azione da eseguire. L'azione di default è di esplorare la directory e tutto il suo contenuto... Le alternative sono:
 +
: <tt>!</tt> : l'operatore di negazione: <tt>!/etc</tt> indica di non controllare il contenuto della directory <tt>/etc</tt>
 +
: <tt>=</tt> : indica di non esplorare ricorsivamente il contenuto della directory
 +
: <tt>$</tt> : permette di creare una regola che non va ad agire sulle sottodirectory ma solo sulla directory(ed i file contenuti) indicata
 +
; /directory : indica il percorso su cui agire
 +
; [controlli] : permette di specificare i controlli da eseguire
 +
: <tt>s</tt> : [[checksum]]
 +
: <tt>i</tt> : [[inode]]
 +
: <tt>p</tt> : permessi
 +
: <tt>l</tt> : numero di link
 +
: <tt>u</tt> : [[uid]]
 +
: <tt>g</tt> : [[gid]]
 +
: <tt>z</tt> : la dimensione dei file (risulta essere un controllo ridondante se viene effettuato anche il controllo del checksum)
 +
: <tt>a</tt> : la data di accesso
 +
: <tt>m</tt> : la data di modifica
 +
: <tt>r</tt> : reimposta la data di accesso
 +
: le opzioni possono essere scritte in due modi: in minuscolo, il che indica che il controllo deve essere fatto, oppure in maiuscolo, per indicare che il controllo non deve essere effettuato.
  
  $ cd 0000:06:04.0
+
== Debian ==
 +
Il file di configurazione <tt>/etc/integrit/integrit.debian.conf</tt> viene utilizzato dal cron presente in <tt>/etc/cron.daily/integrit</tt>.
  
In questa directory vogliamo conoscere il valori dei file ''vendor'' e ''device''.
+
Il file di configurazione è composto da quattro variabili:
 +
; CONFIGS : contiene l'elenco dei file di configurazione da far processare ad integrit. Dopo l'installazione è vuoto, quindi dovremo aggiungere quello che abbiamo precedentemente creato: <tt>/etc/integrit/integrit.conf</tt>
 +
; EMAIL_RCPT : l'indirizzo del destinatario di posta elettronica a cui inviare la mail di notifica (root va bene se sono stati correttamente modificati gli alias di posta, altrimenti potete tranquillamente inserire il vostro indirizzo)
 +
; EMAIL_SUBJ : l'oggetto della mail che riceverete. Normalmente non è necessario effettuare modifiche
 +
; ALWAYS_EMAIL : ''true'' se si desidera ricevere una mail di notifica anche quando non vengono riscontrate anomalia, ''false'' altrimenti
  
 +
Una volta modificato il file di configurazione non ci resta che testare il tutto con un semplice
 
<pre>
 
<pre>
$ cat vendor
+
# /etc/cron.daily/integrit
0x10ec
 
$ cat device
 
0x8139
 
 
</pre>
 
</pre>
 
+
magari impostando <tt>ALWAYS_EMAIL</tt> a ''true'' per effettuare un po' di [[debug]].
 
Ora che sappiamo il vendor e il product ID per questo dipositivo PCI, abbiamo bisogno di trovare i driver del kernel corretto che dica che supporta questo dispositivo. Tornate indietro alla directory di source del kernel:
 
 
 
      <B>$ cd ~/linux/linux-2.6.17.8/</B>
 
 
 
'
 
 
 
      <B>$ grep -i 0x10ec include/linux/pci_ids.h</B>
 
      #define PCI_VENDOR_ID_REALTEK                  0x10ec
 
 
 
* Alcuni processori 64-bit mostreranno il "leading bus number" per i dispositivi PCI nell'output di
 
 
 
 
 
 
 
      <B>$ grep -i 0x8139 include/linux/pci_ids.h</B>
 
      #define PCI_DEVICE_ID_REALTEK_8139        0x8139
 
  
  
 
Ora cercate nei file sorgenti dei driver relativi a questo produttore:
 
  
      <B>$ grep -Rl PCI_VENDOR_ID_REALTEK *</B>
+
= Funzionamento =
      include/linux/pci_ids.h
+
Il funzionamento è semplice: ogni volta che viene effettuato un update, viene creato il database '''current''' che raccoglie lo stato attuale del sistema. Ogni volta che viene effettuato un check, invece, viene confrontato il database di tipo '''current''' con il '''known''', in caso di discrepanze (ed in base alle regole definite nel file di configurazione) viene generato il report.
      drivers/net/r8169.c
 
      drivers/net/8139too.c
 
      drivers/net/8139cp.c
 
 
 
Non dobbiamo guardare nel primo file riportato qui, pci_ids.h, dato che
 
Aprite uno di questi dile in un editor e cercate PCI_VENDOR_ID_REALTEK. Nel file drivers/net/r8169.c, si vede nella seguente sezione di codice:
 
 
 
      static struct pci_device_id rtl8169_pci_tbl[] = {
 
              { PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x8169), },
 
              { PCI_DEVICE(PCI_VENDOR_ID_REALTEK, 0x8129), },
 
              { PCI_DEVICE(PCI_VENDOR_ID_DLINK,      0x4300), },
 
              { PCI_DEVICE(0x16ec,                  0x0116), },
 
              { PCI_VENDOR_ID_LINKSYS,              0x1032, PCI_ANY_ID, 0x0024, },
 
              {0,},
 
      };
 
 
 
Tutti i driver PCI contengono una lista di dispositivi differenti che supportano. , , il valore di dispositivo. Il nostro dispositivo ha il valore 0x8139, mentre questo driver supporta i valori di dispositivi per 0x8169 e 0x8129 con il vendor ID di il nostro dispositivo.
 
Spostandoci al prossimo file, drivers/net/8139too.c, possiamo trovare la stringa PCI_VENDOR_ID_REALTEK nel seguente pezzo di codice:
 
  
 +
Una volta controllate le discrepanze e verificato che siano corrette (in caso di aggiornamento di un pacchetto, ad esempio) è necessario aggiornare il database '''know''' con un semplice:
 
<pre>
 
<pre>
if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
+
mv /var/lib/integrit/current.cdb /var/lib/integrit/known.cdb
pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pci_rev >= 0x20) {
 
  dev_info(&pdev->dev,"This (id %04x:%04x rev %02x) is an enhanced 8139C+ chip\n",
 
      pdev->vendor, pdev->device, pci_rev);
 
  dev_info(&pdev->dev, "Use the \"8139cp\" driver for improved performance and stability.\n");
 
}}
 
 
</pre>
 
</pre>
  
L'utilizzo del valore di un messaggio che dice: "Use the 8139cp for improved performance and stability." Forse dovremmo guardare a quel driver di seguito.
+
= Controllo manuale =
Infine, guardate nel file drivers/net/8139cp.c. Usa la definizione PCI_VENDOR_ID_REALTEK nel seguente pezzo di codice:
+
In caso di problemi è possibile effettuare un controllo manuale richiamando lo script cron (<tt>/etc/cron.daily/integrit</tt>) oppure con un semplice:
 
 
 
<pre>
 
<pre>
static struct pci_device_id cp_pci_tbl[] = {
+
# integrit -cu -C /etc/integrit/integrit.conf
              { PCI_VENDOR_ID_REALTEK, PCI_DEVICE_ID_REALTEK_8139,
 
                PCI_ANY_ID, PCI_ANY_ID, 0, 0, },
 
              { PCI_VENDOR_ID_TTTECH, PCI_DEVICE_ID_TTTECH_MC322,
 
                PCI_ANY_ID, PCI_ANY_ID, 0, 0, },
 
              { },
 
    };
 
    MODULE_DEVICE_TABLE(pci, cp_pci_tbl);
 
 
</pre>
 
</pre>
  
+
= Link Utili =
Ora che abbiamo il nome del driver, possiamo lavorare a ritroso, come mostrato nella prima sezione del capitolo, per trovare l'appropriato valore di configurazione del kernel che dovrebbe abilitare la compilazione di questo driver.
+
* Home Page del progetto: http://integrit.sourceforge.net/
 
1. Trovate il bus PCI ID del dispositivo pere il quale volete trovare il driver, usate lspci.<br>
 
 
3 Leggete i valori del vendor e dei file dei dispositivi nella directory dei dispositivi PCI.<br>
 
4. Tornate all'albero sorgente del kernel guardate in include/linux/pci_ids.h per il vendor PCI e device ID trovato nel passaggio precedente.<br>
 
5. Cercate nell'albero sorgente del kernel per le referenze a quei valori nei driver. Sia il vendor che il device ID devono essere in una struttura struct pci_device_id.<br>
 
6. Cercate nel Makefile del kernel la regola CONFIG_ che compila questo driver usando find e grep:<br>
 
<B>$ find -type f -name Makefile | xargs grep DRIVER_NAME</B><br>
 
7. Cercate nel sistema di configurazione del kernel quel valore di configurazione e andate nel posto di menu che specifica per abilitare il driver da compilare.<br>
 
 
 
===Dispositivi USB===
 
 
 
 
 
 
 
 
 
    <B>$ /usr/sbin/lsusb</B>
 
    Bus 002 Device 003:  ID 045e:0023 Microsoft Corp. Trackball Optical
 
    Bus 002 Device 001:  ID 0000:0000
 
    Bus 005 Device 003:  ID 0409:0058 NEC Corp. HighSpeed Hub
 
    Bus 005 Device 001:  ID 0000:0000
 
    Bus 004 Device 003:  ID 157e:300d
 
    Bus 004 Device 002:  ID 045e:001c Microsoft Corp.
 
    Bus 004 Device 001:  ID 0000:0000
 
    Bus 003 Device 001:  ID 0000:0000
 
    Bus 001 Device 001:  ID 0000:0000
 
 
 
I dispositivi con un ID di 0000:0000 possono venir ignorati, dal momento che sono USB host controller che guidano il bus stesso. Filtrandoli ci lascia con quattro dispositivi:
 
 
 
      <B>$ /usr/sbin/lsusb |  grep -v 0000:0000</B>
 
      Bus 002 Device 003:  ID 045e:0023 Microsoft Corp. Trackball Optical
 
      Bus 005 Device 003:  ID 0409:0058 NEC Corp. HighSpeed Hub
 
      Bus 004 Device 003:  ID 157e:300d
 
      Bus 004 Device 002:  ID 045e:001c Microsoft Corp.
 
 
 
Dato che i dispositivi USB sono facili da rimuovere, fate l'unplug del dispositivo di cui volete trovare il driver ed eseguite lsusb ancora:
 
 
 
      <B>$ /usr/sbin/lsusb |  grep -v 0000:0000</B>
 
      Bus 002 Device 003:  ID 045e:0023 Microsoft Corp. Trackball Optical
 
      Bus 005 Device 003:  ID 0409:0058 NEC Corp. HighSpeed Hub
 
      Bus 004 Device 002:  ID 045e:001c Microsoft Corp.
 
 
 
Il terzo dispositivo ora manca, che significa il dispositivo mostrato come:
 
 
 
  Bus 004 Device 003: ID 157e:300d
 
 
 
 
 
 
 
 
 
      <B>/usr/sbin/lsusb | grep 157e</B>
 
    Bus 004 Device 004: ID 157e:300d
 
 
 
 
 
 
 
      <B>$ grep -i -R -l 157e drivers/*</B>
 
      drivers/atm/pca200e.data
 
      drivers/atm/pca200e_ecd.data
 
      drivers/atm/sba200e_ecd.data
 
      drivers/net/wireless/zd1211rw/zd_usb.c
 
      drivers/scsi/ql1040_fw.h
 
      drivers/scsi/ql1280_fw.h
 
      drivers/scsi/qlogicpti_asm.c
 
 
 
 
net/wireless/zd1211rw/zd_usb.c da controllare.
 
zd_usb.c mostra la stringa 157e nel seguente pezzo di codice:
 
 
 
      static struct usb_device_id usb_ids[]    ={
 
              /* ZD1211 */
 
              { USB_DEVICE(0x0ace, 0x1211),  .driver_info = DEVICE_ZD1211  },
 
              { USB_DEVICE(0x07b8, 0x6001),  .driver_info = DEVICE_ZD1211  },
 
              { USB_DEVICE(0x126f, 0xa006),  .driver_info =  DEVICE_ZD1211  },
 
              { USB_DEVICE(0x6891, 0xa727),  .driver_info =  DEVICE_ZD1211  },
 
              { USB_DEVICE(0x0df6, 0x9071),  .driver_info =  DEVICE_ZD1211  },
 
              { USB_DEVICE(0x157e, 0x300b),  .driver_info =  DEVICE_ZD1211  },
 
              /* ZD1211B */
 
              { USB_DEVICE(0x0ace, 0x1215),  .driver_info = DEVICE_ZD1211B },
 
              { USB_DEVICE(0x157e, 0x300d),  .driver_info = DEVICE_ZD1211B },
 
              {}
 
      };
 
 
 
 
 
 
      { USB_DEVICE(0x157e, 0x300b), .driver_info = DEVICE_ZD1211 },
 
 
 
mostra che il nostro vendor e product ID sono supportati da questo driver.
 
 
 
 
 
 
2. Cercate l'albero del codice sorgente del kernel per il vendor e il product ID del dispositivo USB. Sia il vendor e il product ID dovrebbero essere in una definizione struct usb_device_id.<br>
 
3. Cercate i Makefile del kernel per la regola CONFIG_ che compila questi driver, usando find e grep:
 
 
 
    <B>$ find -type f -name Makefile | xargs grep DRIVER_NAME</B>
 
 
 
4. Cercate nella configurazione di sistema del kernel il valore di quella configurazione e andate alla locazione ,nel menu, specifica per abilitare il driver da compilare.
 
 
 
===Root filesystem===
 
 
 
del
 
Se il vostro nuovo kernel configurato muore a boot time con un errore del tipo:
 
 
 
VFS: Cannot open root device hda2 (03:02)
 
    Please append a correct "root=" boot option
 
    Kernal panic: VFS: Unable to mount root fs on 03:02
 
 
 
 
 
::[[Immagine:Warning_65x68.jpg|left]]Come potete determinare se state usando un ramdisk a boottime? Nel capitolo 5 abbiamo menzionato l'uso dell'installation script della distribuzione per installare il kernel contro il fare l'installazione per proprio conto. Se state usando l'installation script della distribuzione, state probabilmente usando un ramdisk. se lo state installando per vostro conto, probabilmente non lo state usando.
 
Le seguenti sottosezioni mostrano come lasciare che il kernel trovi il root filesystem durante il boot.
 
 
 
====Tipo del filesystem====
 
 
 
 
 
 
$mount |grep " / "
 
/dev/sda2 on / type ext3 (rw,noatime)
 
 
 
 
 
 
====Controller del disco====
 
 
 
 
Tutti i dispositivi a blocchi mostrati in sysfs sia in /sys/block o in /sys/class/block, dipendono dalla versione del kernel che state usando. In entrambi i posti, i dispositivi a blocchi sono un albero, con le partizioni differenti essendo figli del dispositivo principale:
 
 
 
$ tree -d /sys/block/ | egrep "hd|sd"
 
|-- hdc
 
|-- hdd
 
`-- sda  |-- sda1
 
  |-- sda2  |-- sda3
 
 
 
 
 
 
 
$ ls -l /sys/block/sda
 
...
 
device -> ../../devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0
 
...
 
 
 
Ora avete bisogno di iniziare a scorrere la catena dei sispositivi nel sysfs per trovare quale driver sta controllando questo dispositivo:
 
 
 
$ ls -l /sys/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0
 
...
 
driver -> ../../../../../../bus/scsi/drivers/sd
 
...
 
 
 
 
 
 
$ ls -l /sys/devices/pci0000:00/0000:00:1f.2/host0
 
...
 
 
 
Ancora, nessun driver qui. Continuando di un livello in su:
 
 
 
$ ls -l /sys/devices/pci0000:00/0000:00:1f.2
 
...
 
driver -> ../../../bus/pci/drivers/ata_piix
 
 
 
 
 
 
 
===Un aiuto dallo script===
 
 
 
 
Per esempio, fa un "short work" del precedente esempio, quando dovete prendere tutti i driver appropriati per i dispositivi a blocco sda:
 
 
 
<strong>$ get-driver.sh sda</strong>
 
looking at sysfs device: /sys/devices/pci0000:00/0000:00:1f.2/host0/
 
target0:0:0/0:0:0:0
 
found driver: sd
 
found driver: ata_piix
 
 
 
Posso anche trovare tutto sui driver appropriati necessari per cose complicate come i dispositivi USB-toserial:
 
 
 
<strong>$ get-driver.sh ttyUSB0</strong>
 
looking at sysfs device: /sys/devices/pci0000:00/0000:00:1d.3/usb4/4-2/4-2.
 
3/4-2.3:1.0/ttyUSB0
 
found driver: pl2303 from module: pl2303
 
found driver: pl2303 from module: pl2303
 
found driver: usb from module: usbcore
 
found driver: usb from module: usbcore
 
found driver: usb from module: usbcore
 
found driver: uhci_hcd from module: uhci_hcd
 
 
 
Potete scaricare un file di esempio contenente questo script dal web site del libro, fornito nella sezione "How to Contact Us" in Preface.
 
 
 
#!/bin/sh
 
#
 
# Find all modules and drivers for a given class device.
 
#
 
if [ $# != "1" ] ; then<br>
 
  echo<br>
 
  echo "Script to display the drivers and modules for a specified sysfs
 
  class device"
 
  echo "usage: $0 <CLASS_NAME>"
 
  echo
 
  echo "example usage:"
 
  echo " $0 sda"
 
  echo "Will show all drivers and modules for the sda block device."
 
  echo
 
  exit 1
 
fi
 
DEV=$1
 
if test -e "$1"; then
 
  DEVPATH=$1
 
else
 
  # find sysfs device directory for device
 
  DEVPATH=$(find /sys/class -name "$1" | head -1)
 
  test -z "$DEVPATH" && DEVPATH=$(find /sys/block -name "$1" | head -1)
 
  test -z "$DEVPATH" && DEVPATH=$(find /sys/bus -name "$1" | head -1)
 
  if ! test -e "$DEVPATH"; then
 
  echo "no device found"
 
  exit 1
 
  fi
 
fi
 
echo "looking at sysfs device: $DEVPATH"
 
if test -L "$DEVPATH"; then
 
  # resolve class device link to device directory
 
  DEVPATH=$(readlink -f $DEVPATH)
 
  echo "resolve link to: $DEVPATH"
 
fi
 
if test -d "$DEVPATH"; then
 
  # resolve old-style "device" link to the parent device
 
  PARENT="$DEVPATH";
 
  while test "$PARENT" != "/"; do
 
  if test -L "$PARENT/device"; then
 
    DEVPATH=$(readlink -f $PARENT/device)
 
    echo "follow 'device' link to parent: $DEVPATH"
 
    break
 
  fi
 
  PARENT=$(dirname $PARENT)
 
  done
 
fi
 
while test "$DEVPATH" != "/"; do
 
  DRIVERPATH=
 
  DRIVER=
 
  MODULEPATH=
 
  MODULE=
 
  if test -e $DEVPATH/driver; then
 
  DRIVERPATH=$(readlink -f $DEVPATH/driver)
 
  DRIVER=$(basename $DRIVERPATH)
 
  echo -n "found driver: $DRIVER"
 
  if test -e $DRIVERPATH/module; then
 
    MODULEPATH=$(readlink -f $DRIVERPATH/module)
 
    MODULE=$(basename $MODULEPATH)
 
    echo -n " from module: $MODULE"
 
  fi
 
  echo
 
  fi
 
  DEVPATH=$(dirname $DEVPATH)
 
done
 
 
 
 
 
----
 
This is an indipendent translation of the book [http://www.kroah.com/lkn/ Linux Kernel in a Nutshell] by [http://www.kroah.com/log/ Greg Kroah-Hartman]. This translation (like the original work) is available under the terms of [http://creativecommons.org/licenses/by-sa/2.5/ Creative Commons Attribution-ShareAlike 2.5].
 
----
 
  
[http://www.kernel.org/pub/linux/kernel/people/gregkh/lkn/lkn_pdf/ch07.pdf ''Capitolo originale'']
+
[[Categoria:Server]]
[[Categoria:Linux Kernel in a Nutshell]]
+
[[Categoria:Sicurezza]]

Versione delle 09:36, 23 giu 2008

Integrit è un "file verification system": è assimilabile alla famiglia degli intrusion detection system o IDS e ha la funzione di verificare che determinati file non subiscano modifiche.

Questo genere di controlli hanno molti vantaggi:

  • non sono pesanti: infatti vengono eseguiti prevalentemente di notte e occupano pochi minuti
  • sono utili: un aggressore che vuole nascondere dei file, accessi o servizi potrebbe modificare file come netstat, last, w, ls...
  • si affiancano a ids di rete e software come rkhunter

Ovviamente non si tratta della soluzione di tutti i mali, in quanto potrebbe essere possibile che l'aggressore abbia modificato anche l'eseguibile di integrit, però un controllo in più non fa mai male!

Installazione

L'installazione è molto semplice:

# apt-get install integrit

Configurazione

I file di configurazione si trovano in /etc/integrit. Dopo l'installazione sono presenti i seguenti file:

integrit.conf
un template di file di configurazione (infatti è tutto commentato), lo utilizzeremo in seguito come punto di partenza
integrit.debian.conf
il file di configurazione utilizzato dal cron di Debian

Integrit

Il file di configurazione di integrit è semplice ed è composto dalle seguenti sezioni:

root
la directory di partenza (normalmente /)
know
il path per il database contenente lo stato conosciuto del sistema (default /var/lib/integrit/known.cdb)
current
il path del database usato per effettuare il confronto tra lo stato conosciuto e quello attuale (default /var/lib/integrit/current.cdb)

seguito da un elenco di file da ignorare.

La sintassi dell'elenco è la seguente:

[action]/directory [controlli]

dove:

action
è facoltativa, e rappresenta l'azione da eseguire. L'azione di default è di esplorare la directory e tutto il suo contenuto... Le alternative sono:
! : l'operatore di negazione: !/etc indica di non controllare il contenuto della directory /etc
= : indica di non esplorare ricorsivamente il contenuto della directory
$ : permette di creare una regola che non va ad agire sulle sottodirectory ma solo sulla directory(ed i file contenuti) indicata
/directory
indica il percorso su cui agire
[controlli]
permette di specificare i controlli da eseguire
s : checksum
i : inode
p : permessi
l : numero di link
u : uid
g : gid
z : la dimensione dei file (risulta essere un controllo ridondante se viene effettuato anche il controllo del checksum)
a : la data di accesso
m : la data di modifica
r : reimposta la data di accesso
le opzioni possono essere scritte in due modi: in minuscolo, il che indica che il controllo deve essere fatto, oppure in maiuscolo, per indicare che il controllo non deve essere effettuato.

Debian

Il file di configurazione /etc/integrit/integrit.debian.conf viene utilizzato dal cron presente in /etc/cron.daily/integrit.

Il file di configurazione è composto da quattro variabili:

CONFIGS
contiene l'elenco dei file di configurazione da far processare ad integrit. Dopo l'installazione è vuoto, quindi dovremo aggiungere quello che abbiamo precedentemente creato: /etc/integrit/integrit.conf
EMAIL_RCPT
l'indirizzo del destinatario di posta elettronica a cui inviare la mail di notifica (root va bene se sono stati correttamente modificati gli alias di posta, altrimenti potete tranquillamente inserire il vostro indirizzo)
EMAIL_SUBJ
l'oggetto della mail che riceverete. Normalmente non è necessario effettuare modifiche
ALWAYS_EMAIL
true se si desidera ricevere una mail di notifica anche quando non vengono riscontrate anomalia, false altrimenti

Una volta modificato il file di configurazione non ci resta che testare il tutto con un semplice

# /etc/cron.daily/integrit

magari impostando ALWAYS_EMAIL a true per effettuare un po' di debug.


Funzionamento

Il funzionamento è semplice: ogni volta che viene effettuato un update, viene creato il database current che raccoglie lo stato attuale del sistema. Ogni volta che viene effettuato un check, invece, viene confrontato il database di tipo current con il known, in caso di discrepanze (ed in base alle regole definite nel file di configurazione) viene generato il report.

Una volta controllate le discrepanze e verificato che siano corrette (in caso di aggiornamento di un pacchetto, ad esempio) è necessario aggiornare il database know con un semplice:

mv /var/lib/integrit/current.cdb /var/lib/integrit/known.cdb

Controllo manuale

In caso di problemi è possibile effettuare un controllo manuale richiamando lo script cron (/etc/cron.daily/integrit) oppure con un semplice:

# integrit -cu -C /etc/integrit/integrit.conf

Link Utili