Hardening con Grsecurity e Kernel 2.4.29

L'obiettivo dell'articolo è quello di instradare il lettore nell'apportare una serie di modifiche da applicare ad un PC montante kernel linux 2.4.29 per innalzarne il livello di sicurezza tramite la patch grsecurity.
Ciò che andremo a fare è tecnicamente definito come "Kernel Hardening" che, volendo fornire una volgare traduzione italiana, stà a significare: "Rafforzamento del Kernel".
Grsecurity permette, infatti, di irrobustire il kernel linux mediante complessi schemi logistici che vanno dal Role-Based Access Control (RBAC) al PID randomization passando per l’incrementazione delle restrizioni dei processi chrootati.
La corretta applicazione di questa patch consente di metterci al riparo da un eventuale attacco al sistema da parte di un malintenzionato.
Parlando di hardening si dà per scontato che il lettore sia a conoscenza di come compilare un kernel e che conosca sufficientemente la struttura di un sistema unix-based.

Grsecurity segue una strategia denominata "Detection, Prevention and Conteinment" che permette di “Determinare, prevenire e contenere” i danni che un malintenzionato può recare ad un sistema operativo GNU/Linux.

Detection: Attraverso i logs delle fork() non andate a buon fine, di tentativi d'accesso a risorse protette e l'esecuzione di qualunque software, grsecurity permette, attraverso sistemi di analisi dei logs, appunto, di “determinare” con estrema precisione ciò che avviene nel sistema.

Prevention: La stragrande maggioranza di falle di sistema è causata essenzialmente da errori di programmazione che si traducono generalmente col tempo in buffer overflow (stack/heap overflow). Grsecurity permette, attraverso PaX (pax.grsecurity.org), di evitare in qualche modo che questo possa avvenire attraverso una serie di “tattiche”:

1. Executable space protections:

che permette di prevenire l'iniezione di codice malevolo attraverso il bit NX dei processori (NX == Non-eXecutable). In processori che non hanno il bit NX Pax lo emula.

2. Address space layout randomization:

che permette di eliminare attacchi che cercano in qualche modo di eseguire codice già caricato in memoria e non contemplato dal programmatore attraverso la randomizzazione delle allocazioni di memoria dell'user space.

Contaimnent: A differenza della normale gestione dei processi del kernel vanilla (e comunque dei sistemi Unix-like) basata sulle operazioni di lettura, scrittura ed esecuzione in base al proprietario od al gruppo di appartenenza (sistema DAC, Discretionary Access Control), grsecurity implementa una versione ampliata e sofisticata di Access Control chiamata RBAC (Role-Based Access Control).
Attraverso, quindi, queste “strategie”, grsecurity, consente di rendere più sicuro il sistema.
Procediamo ora al prossimo step riguardante, finalmente, l'installazione della patch grsec su un kernel vanilla 2.4.29.

Innanzitutto colleghiamoci al sito http://www.kernel.org/pub/linux/kernel/v2.4/ e scarichiamo il tarball contentente i sorgenti del kernel 2.4.29.
Fatto ciò puntiamo il nostro browser su http://www.grsecurity.net, una breve lettura della home-page ci permetterà di individuare la sezione downloads: scarichiamo la patch avendo cura di selezionare quella per il ramo 2.4.x.
A questo punto abbiamo tutto l’occorrente per metterci al lavoro: nell’eventualità stessimo lavorando con il server X attivo, stoppiamolo ed entriamo in shell, questo ci permetterà di ultimare il tutto molto più velocemente in quanto non ci saranno sprechi di RAM.

Entrati in shell da superutente (root) copiamo l’archivio tar dei sorgenti del kernel in /usr/src:
# cp /path_dove_abbiamo_scaricato_i_sources/linux-2.4.29.tar.gz /usr/src

Ora dobbiamo estrarre i sorgenti dal tarball:
# cd /usr/src
# tar –zxvf linux-2.4.29.tar.gz

Estratti i sorgenti, copieremo la patch grsecurity in /usr/src:
# cp /path_dove_abbiamo_scaricato_grsec/grsecurity-XXX.patch /usr/src

Ed infine applicheremo la stessa:
# patch –p0 < grsecurity.patch

E’ giunto il momento della compilazione vera e propria del kernel.
Creiamo un link simbolico a linux-2.4.29 denominato linux:
# ln –s linux-2.4.29/ linux
nota: se esiste già un link simbolico, eliminiamolo con rm linux.

Accediamo al link e prepariamo l’ambiente di lavoro con make mrproper:
# cd linux
# make mrproper

Dopo pochissimo tempo mrproper completerà il suo lavoro consentendoci di passare, de facto, alla compilazione.
Possiamo iniziare la configurazione/compilazione scegliendo uno dei tre tool offerti: make config, make menuconfig, make oldconfig.
Il primo è il metodo più classico per la compilazione del kernel linux; il secono usa la libreria ncurses ed è il più semplice ed intuitivo; il terzo, infine, si dimostra particolarmente utile nel caso di aggiornamenti frequenti in quanto ci pone delle domande ogni volta che ci sono addons nuove da apportare al kernel.
In questo articolo utilizzeremo il secondo proprio perché è il più facile ed efficiente.
Procediamo, quindi, con la compilazione usando make menuconfig:
# make menuconfig

Scorgeremo diverse opzioni selezionabili che, ripeto, sarete voi ad impostare in base alle vostre esigenze ed alle esperienze (positive o negative) accumulate durante le varie compilazioni.
Di nostro interesse è l’ultimo menu (creato dalla patch grsecurity): Grsecurity.
Clicchiamo enter sul medesimo e spazio su [] Grsecurity (NEW), un altro spazio su Security level ci permetterà di selezionare il livello di protezione: scegliamo Customized.
Ci apparirà una cosa del genere:
[*] Grsecurity (NEW)                                                          
(Customized) Security level                                                  
PaX Control  --->                                                            
Address Space Protection  --->                                                
Role Based Access Control Options  --->                                      
Filesystem Protections  --->                                                
Kernel Auditing  --->                                                      
Executable Protections  --->                                              
Network Protections  --->                                                    
Sysctl support  --->                                                          
Logging options  --->
Non essendo intenzione dell’autore blindare un sistema paranoicamente ci limiteremo ad apportare modifiche sufficienti a garantirci un discreto livello di sicurezza in ambito desktop.
Quello che faremo è: randomizzare i PID, restringere la struttura per la coda dati FIFO, restringere dmesg, impedire il mount in ambiente chrootato, loggare processi al di fuori del chroot nonché indivuare e bloccare exploits che possono fornire privilegi elevati ad un utente.
In PaX Control non selezioniamo nulla ed in MAC system integration impostiamo none.
Per quanto riguarda Address Space Protection selezioniamo solo Deter exploit bruteforcing e, se vogliamo, Disable privileged I/O (in questo modo solo il superutente potrà spegnere e riavviare il PC).
In Role Based Access Control Options selezioniamo Hide kernel processes, per il resto lasciamo invariato o, qualora volessimo, cambiamo il numero di tentativi massimo di password errata.
Arrivati a Filesystem Protections selezioniamo FIFO restrictions.
In Kernel Auditing selezioniamo Exec logging, Signal logging, Fork failure logging.
Per Executable Protections la scelta sarà Dmesg(8) restriction e Randomized PIDs.
Lasciamo completamente invariati Network Protections, Sysctl support e Logging options: la configurazione di Grsecurity è finita, diamo un faticato exit, completiamo la configurazione generale del kernel, un altro exit, alla domanda “Do you wish to save your new kernel configuration?” rispondiamo “Yes” e… compiliamo !

Per prima cosa prepariamo le dipendenze:
# make dep

Rimuoviamo i file temporanei:
# make clean

Prepariamoci una tazza di caffè e creiamo l’immagine del kernel (ci vorrà del tempo):
# make –j5 bzImage

Creata l’immagine del kernel penseremo ai moduli (anche qui ci vorrà del tempo):
# make –j5 modules

Compilati i moduli del kernel dovremo installarli:
# make modules_install

A questo punto la compilazione è finalmente finita, ecco le ultime cose da fare: spostiamo la System map creata in /boot:
# mv System.map /boot/System.map-2.4.29grsec

stesso discorso per il .config:
# mv .config /boot/config-2.4.29grsec

e ora il kernel:
# mv /usr/src/linux/arch/i386/boot/bzImage /boot/vmlinuz-2.4.29grsec

Siamo arrivati al final step: la configurazione di Lilo:
# pico /etc/lilo.conf

Al file lilo.conf aggiungeremo in basso a tutto:
image = /boot/vmlinuz-2.4.29grsec
root = /dev/Partizione_ROOT
label = Linux_grsec
read-only

Accertiamoci che tutto sia apposto con lilo –v e diamo il consueto lilo:
# lilo –v
# lilo
Linux added*
Linux_grsec added

Diamo un bel reboot e godiamoci il nostro nuovo kernel “blindato”.

Privacy Policy