\documentclass[a4paper,10pt]{article}

\usepackage{fullpage}
\usepackage{eso-pic}
\usepackage[latin1]{inputenc}
\usepackage[italian]{babel}
\usepackage[OT1]{fontenc}
\usepackage[dvips]{graphicx}
\usepackage{fancyhdr}
\usepackage{array}
\usepackage{longtable}
\usepackage{graphicx}
\usepackage{listings}

\newcommand{\code}[1]{%
	\begin{small}\texttt{#1}\end{small}%
}%
\newcommand{\var}[1]{%
	\code{\emph{#1}}%
}%
\newcommand{\bslash}{%
	\scriptsize{$\backslash$}%
	\normalsize
}%
\newcommand{\lgraffa}{%
	\code{\scriptsize{$\{$}}%
}%
\newcommand{\rgraffa}{%
	\code{\scriptsize{$\}$}}%
}%

\title{Firewall Embedded}
\author{Vincenzo Laurenziello \code{<vincenx@fastwebnet.it>}}
\date{}
\begin{document}
\thispagestyle{empty}%
\pagenumbering{Roman}
\maketitle
\vskip 10cm
\tableofcontents
\newpage

\pagenumbering{arabic}
\section{Introduzione}
Lo scopo di questo testo consiste nel prendere una distribuzione e farla diventare un firewall su hardware embedded.

Il firewall che verrà costruito consiste nel creare una policy di NAT, mentre l'unico servizio presente è \code{ssh}.

L'hardware a disponizione è un Mini-ITX con le seguenti componenti:
\begin{itemize}
\item \emph{Processore}: AMD Geode 300MHz;
\item \emph{RAM}: 128 MByte;
\item \emph{NIC}: 3 schede Realtek 8139;
\item \emph{Mother Board}: basata sul chipset Cyrix 5530;
\item \emph{USB}: 4 porte;
\item \emph{VGA/Audio}: inclusi nella scheda madre;
\item \emph{Disco}: Compact Flash da 256 MByte.
\end{itemize}

La distribuzione scelta è stata \emph{\textbf{D}amn\textbf{S}mall\textbf{L}inux}. Questa è una versione embedded di \emph{Knoppix}, quest'ultima basata su \emph{Debian}.

Sono state apportate delle modifiche per ottenere un sistema adatto allo scopo, e precisamente:
\begin{itemize}
\item togliere tutti i programmi considerati inutili per l'utilizzo di un firewall;
\item installare nuovi programmi necessari;
\item installazione di \code{shorewall} e configurazione;
\item hardening del sistema.
\end{itemize}
\section{Rimozione dei programmi}
La distribuzione seppur basata su \emph{Debian} non comprende tutte le applicazioni che la contraddistinguono, uno fra tutti \code{apt-get}; pertanto la rimozione dei programmi è stata più difficile del previsto.

L'obiettivo è nel rimuovere tutte le applicazioni riguardanti l'interfaccia grafica inclusa all'interno dell'installazione originale di DamnSmallLinux.

Innanzitutto sono state rimosse le librerie appartenenti al server grafico \code{X} in \code{/usr/X11}.

Successivamente per ogni eseguibile presente sul filesystem è stato controllato con l'applicazione \code{ldd} in modo da poter identificare gli eseguibili che sono linkati direttamente alle librerie appena rimosse.

Praticamente, le directory \code{/bin}, \code{/sbin}, \code{/usr/bin}, \code{/usr/sbin} sono state controllate con un piccolo shell script in figura \ref{fig:ldd-x11}.

\begin{figure}[htb!]
  \centering
  \begin{lstlisting}[frame=single,basicstyle=\footnotesize\ttfamily,
    tabsize=3,numbers=left,xleftmargin=2em]
#!/bin/sh
for i in $1
do
	[ ! "`ldd $i 2>&1 |grep 'not found'`" = "" ] && echo $i
done
\end{lstlisting}
  \caption{Uso di ldd}
  \label{fig:ldd-x11}
\end{figure}

In questa figura, si vede che lo script necessita di un argomento, ossia la directory contenente i file eseguibili. Supponendo che le librerie appartenenti al server \code{X} sono state rimosse (o spostate), allora gli eseguibili, che verranno stampati dallo script, dipendendono da tali librerie.

Ogni applicazione identificata è stata rimossa completamente, ossia eseguibili, librerie, manuali, file di condivisione e di share. Quest'operazione è stata fatta a mano e non tramite script e richiedede molta attenzione da parte di chi interviene.

La distribuzione appena installata occupa circa 130 MByte. Tramite queste operazioni è diventata di 45 MByte.

\section{Installazione dei programmi}
DamnSmallLinux per default non possiede i seguenti pacchetti software: 
\begin{itemize}
\item \code{linux}, per avere un kernel adattato alla tipologia di hardware che utilizziamo.
\item \code{iptables}, il programma che si interfaccia direttamente al kernel per la gestione del firewall;
\item \code{logrotate} e \code{crontab}, per ruotare periodicamente i vari log che possono essere generati;
\end{itemize}

Data la grandezza della distribuzione, non è presente alcun programma per il development, pertanto per ottenere degli eseguibili adatti alla distribuzione in uso si è utilizzato un altro sistema operativo che utilizza le librerie \code{glibc} versione 2.4 (che sono quelle utilizzate da DamnSmallLinux).

Per installare ogni pacchetto è sufficiente estrarlo a partire dalla root del filesystem e, dove è necessario, configurarlo.

Qui di seguito verranno descritti i procedimenti su come sono stati creati i vari pacchetti.

\subsection{Linux}
Il kernel originale fornito da DamnSmallLinux è un 2.4.24. Esso \'e stato sostituito inizialmente con l'ultimo kernel vanilla disponibile, ossia un 2.6.21, ma non funziona. Cioè appena dopo la fase di decompressione dell'immagine del kernel da parte del bootloader, il kernel stesso non riesce ad effettuare il bootstrapping, pertanto tale soluzione è stata scartata.

Si è deciso, quindi, di utilizzare un kernel 2.4.34.5.

Una volta copiata la configurazione del kernel originale è stato lanciato il comando:
\begin{quote}
\code{make oldconfig}
\end{quote}
in questo modo adattiamo la configurazione del kernel di DamnSmallLinux alla nuova release che abbiamo intenzione di installare.

Successivamente utilizzando il comando:
\begin{quote}
\code{make menuconfig}
\end{quote}
dove
\begin{itemize}
\item abbiamo eliminato tutte le caratteristiche che non vengono utilizzate per l'hardware usato,
\item è stato compilato per la famiglia di processori \code{Pentium MMX} dato che il processore è un AMD Geode 300MHz,
\item le periferiche abilitate sono:
	\begin{itemize}
	\item supporto per i chipset \code{Realtek 8139},
	\item supporto per le periferiche USB, porta seriale, ramdisk, framebuffer di tipo VESA,
	\item supporto per bonding, vlan, netfilter, QOS,
	\item supporto per i vari controller e bus basati sul chipset \code{Cyrix Corporation 5530}.
	\end{itemize}
\item è stato configurato per ottenere un kernel monolitico, ossia senza l'utilizzo dei moduli.
\end{itemize}

La compilazione del kernel consta dei seguenti passi:
\begin{quote}
\code{make dep}

\code{make bzImage}

\code{make modules}
\end{quote}

Per generare il pacchetto software sono stati eseguiti i seguenti comandi:
\begin{quote}
\code{mkdir -p /usr/src/monolithic-linux/boot}

\code{cd /usr/src/linux-2.4.34.5}

\code{cp .config /usr/src/monolithic-linux/boot/config-2.4.34.5}

\code{cp System.map /usr/src/monolithic-linux/boot/System.map-2.4.34.5}

\code{cp arch/boot/i386/bzImage /usr/src/monolithic-linux/boot/vmlinuz-2.4.34.5}

\code{make INSTALL\_MOD\_PATH=/usr/src/monolithic-linux modules\_install}

\code{cd /usr/src/monolithic-linux}

\code{tar czvf linux-2.4.35.4.tgz .}
\end{quote}

\subsection{Iptables}
Questo programma permette di lanciare comandi da user mode ed interfacciarsi al netfilter presente nel kernel e fornirne delle regole di comportamento del firewall.

La versione utilizzata è la 1.3.7. Ai sorgenti originali è stata applicata una patch che disabilita l'utilizzo dei programmi \code{modprobe} ed \code{insmod} poichè il kernel utilizzato non necessita l'utilizzo di alcun modulo. La patch è reperibile su questo indirizzo:
\begin{quote}
\code{http://vinx83.altervista.org/kernel/disable\_modprobe.diff}
\end{quote}

Per compilare questo programma è stato utilizzato un solo comando, ossia:
\begin{quote}
\code{make NO\_SHARED\_LIBS=1 KERNEL\_DIR=/usr/src/linux-2.4.34.5}
\end{quote}

Per generare il pacchetto software sono stati eseguiti i seguenti comandi:
\begin{quote}
\code{mkdir -p /usr/src/iptables-static/sbin}

\code{cd /usr/src/iptables-1.3.7}

\code{cp iptables /usr/src/iptables-static/sbin/}

\code{cp iptables-save /usr/src/iptables-static/sbin/}

\code{cp iptables-restore /usr/src/iptables-static/sbin/}

\code{cp iptables-xml /usr/src/iptables-static/sbin/}

\code{cd /usr/src/iptables-static}

\code{tar czvf iptables-1.3.7.tgz .}
\end{quote}

\subsection{Crontab e Logrotate}
L'utilizzo di questi due applicativi è dipeso dal fatto che la distribuzione lavorerà su una flash card. Questo tipo di hardware ha la peculiarità di avere un limite fisico sulle scritture, pertanto bisogna limitare le frequenti operazioni di scrittura, come ad esempio i log di sistema.

\subsubsection{Crontab}
Per quanto riguarda \code{crontab} è stata utilizzata la versione fatta da Paul Vixie, scaricabile su questo indirizzo:
\begin{quote}
\code{ftp://ftp.isc.org/isc/cron/}
\end{quote}

La compilazione del sorgente è stata eseguita in questo modo:
\begin{quote}
\code{mkdir -p /usr/src/cron\lgraffa,static\rgraffa}

\code{cp cron\_4.1.shar /usr/src/cron}

\code{cd /usr/src/cron}

\code{sh < cron\_4.1.shar}

\code{export CC='gcc -static'}

\code{make}

\code{mkdir -p /usr/src/cronstatic/\lgraffa\lgraffa,s\rgraffa bin,etc/init.d,var/cron/temp\rgraffa}

\code{touch /usr/src/cronstatic/etc/crontab}

\code{cp crontab /usr/src/cronstatic/bin/}

\code{chmod 4111 /usr/src/cronstatic/bin/crontab}

\code{cp cron /usr/src/cronstatic/sbin/}

\code{chmod 111 /usr/src/cronstatic/sbin/cron}
\end{quote}

Infine creiamo il daemon \code{crontab} e lo posizioniamo all'interno della directory \code{/usr/src/cronstatic/etc/init.d}, come si vede in figura \ref{fig:daemon-cron}:
\begin{figure}[htb!]
  \centering
  \begin{lstlisting}[frame=single,basicstyle=\footnotesize\ttfamily,
    tabsize=3,numbers=left,xleftmargin=2em]
#!/bin/sh

__estatus() {
	if [ $1 -eq 0 ]
	then
		echo "done."
	else
		echo fail.
		exit 1
	fi
}

start() {
	echo -n "Starting crontab: "
	start-stop-daemon --start --quiet --exec /sbin/cron >/dev/null 2>&1
	__estatus $?
}

stop() {
	echo -n "Stopping crontab: "
	start-stop-daemon --stop --quiet --pidfile /var/run/cron.pid
	__estatus $?
}

case $1 in
start)
	start
	;;
stop)
	stop
	;;
restart)
	stop
	start
	;;
*)
	echo "$0 {start|stop|restart}"
	;;
esac
exit 0
\end{lstlisting}
  \caption{Crontab Daemon}
  \label{fig:daemon-cron}
\end{figure}

Infine, per creare il pacchetto eseguiamo i comandi:
\begin{quote}
\code{cd /usr/src/cronstatic}

\code{tar czf vixie-cron-4.1.tgz .}
\end{quote}

\subsubsection{Logrotate}
Mentre, per quanto riguarda \code{logrotate} la compilazione consiste nei seguenti passi:
\begin{quote}
\code{mkdir -p /usr/src/logrotate-static}

\code{cd /usr/src/logrotate-3.7.2}

\code{export BASEDIR=/usr/src/logrotate-static}

\code{export CC='gcc -static'}

\code{make}

\code{make install}
\end{quote}

Per creare il pacchetto eseguiamo i comandi:
\begin{quote}
\code{cd /usr/src/logrotate-static}

\code{rm -rf man}

\code{tar czf logrotate-3.7.2.tgz .}
\end{quote}
\section{Shorewall}
Il pacchetto \code{shorewall} è uno script shell che, opportunamente configurato, permette di costruire in automatico una serie di comandi basati su \code{iptables}.

La versione che è stata utilizzata è la 3.4.4.

Per installarlo è sufficiente estrarre l'archivio in questo modo:
\begin{quote}
\code{tar xjf shorewall-3.4.4.tar.bz2}
\end{quote}
ed eseguire lo script \code{install.sh} situato all'interno della directory creata.

\subsection{Configurazione}
I file di configurazione si trovano all'interno della directory \code{/etc/shorewall}.

Come già detto nell'introduzione, il firewall deve gestire e filtrare il traffico della rete interna, pertanto \code{shorewall} dovrà essere configurato utilizzando due interfacce di rete.

\begin{figure}[!ht]
\centering
\includegraphics[scale=0.55]{./nat.ps}
\caption{Tipica architettura NAT}
\label{fig:nat}
\end{figure}

Qui di seguito, sono definiti i vari file di configurazione con una breve spiegazione.

\paragraph{interfaces}
\begin{quote}
\begin{small}
\begin{verbatim}
net     eth0            detect          tcpflags,routefilter,nosmurfs,logmartians
loc     eth1            detect
\end{verbatim}
\end{small}
\end{quote}
Questo file viene utilizzato per dire al firewall quali interfacce sono connesse ad esso e a quali zone. Pertanto Internet è collegata all'interfaccia \code{eth0}, mentre la rete interna è collegata all'interfaccia \code{eth1}.

Le opzioni passate sull'interfaccia \code{eth0} significano:
\begin{itemize}
\item \code{tcpflags}, controlla i flag presenti nell'header dei pacchetti TCP che arrivano sull'interfaccia. I controlli includono i flag \code{Null}, \code{SYN+FIN}, \code{SYN+RST} e \code{FIN+URG+PSH}; queste combinazioni di flag sono tipicamente utilizzati dai portscan.
\item \code{routefilter}, abilita l'anti-spoofing sull'interfaccia, ossia il kernel rigetterà ogni pacchetto entrante che ha l'indirizzo sorgente che vogliamo routare tramite un'altra interfaccia presente sul firewall.
\item \code{nosmurfs}, blocca le richieste di connessioni entranti sull'interfaccia se l'indirizzo sorgente è di tipo broadcast o multicast.
\item \code{logmartians}, il contenuto del file:
\begin{quote}
\code{/proc/sys/net/ipv4/conf/}\var{interface}\code{/log\_martians}
\end{quote}
viene impostato ad 1.
\end{itemize}

\paragraph{zones}
\begin{quote}
\begin{small}
\begin{verbatim}
fw      firewall
net     ipv4
loc     ipv4
\end{verbatim}
\end{small}
\end{quote}
In questo file vengono definite le zone. Dove \code{fw} indica il firewall in sè; \code{net} indica Internet ed utilizza l'Internet Protocol versione 4; infine, \code{loc} indica la rete interna con IP versione 4.

\paragraph{policy}
\begin{quote}
\begin{small}
\begin{verbatim}
loc   net   ACCEPT
loc   fw    REJECT   info
loc   all   DROP     info
fw    net   ACCEPT
fw    loc   REJECT   info
fw    all   DROP     info
net   all   DROP     info
all   all   DROP     info
\end{verbatim}
\end{small}
\end{quote}
Il file \code{/etc/shorewall/policy} contiene le regole di default per ogni zona. Dove le uniche connessioni accettate sono solo quelle che vanno dall'interno verso l'esterno, la restante parte delle comunicazioni viene filtrata e loggata.

\paragraph{masq}
\begin{quote}
\begin{small}
\begin{verbatim}
eth0   eth1   192.168.3.50
\end{verbatim}
\end{small}
\end{quote}
Questo file viene usato per definire il mascheramento dell'IP e SNAT\footnote{Source Network Address Translation}. Dove la sottorete gestita dall'interfaccia di rete \code{eth1} viene mascherata utilizzando l'IP \code{192.168.3.50} dell'interfaccia \code{eth0}.

\paragraph{routestopped}
\begin{quote}
\begin{small}
\begin{verbatim}
eth0            -
eth1            10.0.0.0/8
\end{verbatim}
\end{small}
\end{quote}
Questo file definisce gli host che sono accessibili dal firewall quando il firewall viene fermato. Dove per \code{eth0}, l'interfaccia esterna, accetta tutti gli indirizzi IP, mentre \code{eth1}, l'interfaccia per la rete interna, accetta solo gli host provenienti dalla subnet \code{10.0.0.0/8}.

\paragraph{rules}
\begin{quote}
\begin{small}
\begin{verbatim}
DNS/ACCEPT    fw                   net
ACCEPT        loc                  fw             tcp   31000
ACCEPT        net:192.168.3.0/24   fw             tcp   31000
Ping/ACCEPT   loc                  fw
Ping/REJECT   net                  fw
DNAT          net                  loc:10.0.0.2   udp   -       6277
DNAT          net                  loc:10.0.0.2   tcp   24441
\end{verbatim}
\end{small}
\end{quote}
Il file \code{/etc/shorewall/rules} definisce le eccezioni stabilite nel file \code{/etc/shorewall/policy}, dove viene definita una regola per ogni riga file.

In questo caso vengono accettate:
\begin{itemize}
\item le richieste \code{DNS} fatte dal firewall verso Internet,
\item le connessioni di tipo TCP sulla porta sorgente 31000 da parte della subnet \code{192.168.3.0/24} e dalla rete interna,
\item i ping dalla rete interna sul firewall,
\item le connessioni entranti, di tipo TCP sulla porta sorgente 24441 ed UDP sulla porta di destinazione 6277, vengono snattate sull'host \code{10.0.0.2} appartenente alla rete interna,
\end{itemize}
mentre vengono rigettati i ping effettuati da Internet sul firewall.

\paragraph{shorewall.conf}
\begin{quote}
\begin{small}
\begin{verbatim}
STARTUP_ENABLED=Yes
VERBOSITY=0
LOGFILE=/var/log/messages
LOGFORMAT="Shorewall:%s:%s:"
LOGTAGONLY=No
TCP_FLAGS_LOG_LEVEL=info
RFC1918_LOG_LEVEL=info
SMURF_LOG_LEVEL=info
LOG_MARTIANS=Yes
IPTABLES=/sbin/iptables
PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/bin:/usr/local/sbin
SHOREWALL_SHELL=/bin/sh
SUBSYSLOCK=/var/lock/subsys/shorewall
CONFIG_PATH=/etc/shorewall:/usr/share/shorewall
IPSECFILE=zones
DROP_DEFAULT="Drop"
REJECT_DEFAULT="Reject"
ACCEPT_DEFAULT="none"
QUEUE_DEFAULT="none"
IP_FORWARDING=On
ADD_IP_ALIASES=No
ADD_SNAT_ALIASES=Yes
RETAIN_ALIASES=No
TC_ENABLED=Internal
TC_EXPERT=No
CLEAR_TC=Yes
MARK_IN_FORWARD_CHAIN=No
CLAMPMSS=No
ROUTE_FILTER=Yes
DETECT_DNAT_IPADDRS=No
MUTEX_TIMEOUT=60
ADMINISABSENTMINDED=Yes
BLACKLISTNEWONLY=Yes
DELAYBLACKLISTLOAD=No
DISABLE_IPV6=Yes
BRIDGING=No
DYNAMIC_ZONES=No
PKTTYPE=Yes
RFC1918_STRICT=No
MACLIST_TABLE=filter
SAVE_IPSETS=No
MAPOLDACTIONS=No
FASTACCEPT=No
IMPLICIT_CONTINUE=Yes
HIGH_ROUTE_MARKS=No
USE_ACTIONS=Yes
OPTIMIZE=1
EXPORTPARAMS=No
BLACKLIST_DISPOSITION=DROP
MACLIST_DISPOSITION=REJECT
TCP_FLAGS_DISPOSITION=DROP
\end{verbatim}
\end{small}
\end{quote}
In questo file vengono definiti i vari parametri del firewall. Quelli fondamentali sono:
\begin{itemize}
\item \code{LOGFILE}, specifica dove verranno salvati i file di log;
\item \code{TCP\_FLAGS\_DISPOSITION} e \code{TCP\_FLAGS\_LOG\_LEVEL}, servono a configurare l'opzione \code{tcpflags} del file \\  \code{/etc/shorewall/interfaces}, definendone la policy di default e la verbosità nei log;
\item \code{SMURF\_LOG\_LEVEL}, specifica la verbosità nei log dell'opzione \code{nosmurfs} nel file \code{/etc/shorewall/interfaces};
\item \code{LOG\_MARTIANS}, abilita l'utilizzo dell'opzione \code{logmartians} nel file \code{/etc/shorewall/interfaces};
\item \code{SUBSYSLOCK}, definisce il file di lock;
\item \code{IP\_FORWARDING}, abilita o disabilita il forwarding delle interfacce di rete;
\item \code{ADD\_SNAT\_ALIASES}, abilita o disabilita lo SNAT come definito nel file \code{/etc/shorewall/masq}
\item \code{ROUTE\_FILTER}, abilita o disabilita l'anti-spoof come definito nell'opzione \code{routefilter} presente nel file \code{/etc/shorewall/interfaces}.
\end{itemize}

\section{Hardening di sistema}
DSL, come è stato detto nell'introduzione è basata su Knoppix. Per come è stata progettata, Knoppix contiene una serie di daemon script ottimizzati per lavorare come una tipica distribuzione di tipo live-cd.

\subsection{Inizializzazione del sistema}

Lo script \code{knoppix-autoconfig} gestisce tutta la configurazione del sistema che spazia dalla mappatura della tastiera al riconoscimento delle periferiche. Questo script, però, viene lanciato ogni volta quando il sistema effettua la fase di boot.

Seppur essendo altamente configurabile, questo script rende il sistema molto lento nel caricamento iniziale; inoltre, rigenera ogni volta sul filesystem alcuni file di configurazione pre-esistenti. Dato che si sta utilizzando una flash card come disco, è bene limitare il numero di operazioni di scrittura.

Pertanto questo script è stato disabilitato con il comando:
\begin{quote}
\code{update-rc.d -f knoppix-autoconfig remove}
\end{quote}
e sostituito con uno più semplice e veloce ma meno configurabile (vedi figura \ref{fig:daemon-sysbase}).
\begin{figure}[htb!]
  \centering
  \begin{lstlisting}[frame=single,basicstyle=\footnotesize\ttfamily,
    tabsize=3,numbers=left,xleftmargin=2em]
mount -t proc /proc /proc >/dev/null 2>&1
echo "0" > /proc/sys/kernel/printk
hostname firewall
LANGUAGE="it"
COUNTRY="it"
LANG="it_IT@euro"
KEYTABLE="it"
CHARSET="iso8859-15"
TZ="Europe/Rome"
export TZ LANG COUNTRY CHARSET
[ -f /etc/init.d/checkroot.sh ] && /etc/init.d/checkroot.sh
[ -f /etc/init.d/checkfs.sh ]   && /etc/init.d/checkfs.sh
mount -o remount,rw / 2>/dev/null
ifconfig lo 127.0.0.1 up
mke2fs -q /dev/ram0
[ ! -e /mnt/tmp ] && mkdir -p /mnt/tmp
mount /dev/ram0 /mnt/tmp
cp -a /var/* /mnt/tmp
umount /mnt/tmp
mount /dev/ram0 /var
\end{lstlisting}
  \caption{Startup Daemon}
  \label{fig:daemon-sysbase}
\end{figure}

Da questa figura si nota che cosa accade appena il processo \code{init} viene lanciato, ossia:
\begin{itemize}
\item monta lo pseudo filesystem \code{proc},
\item inizializza alcune variabili d'ambiente,
\item controlla eventuali errori sul filesystem del disco,
\item inizializza l'interfaccia loopback di rete,
\item rigenera la directory \code{/var} all'interno di un ramdisk e la monta.
\end{itemize}

L'ultimo punto è giustificato, poichè le operazioni di scrittura che possono essere \emph{volatili} sono i log di sistema e i file che verranno generati da \code{shorewall}. La restante parte del disco, invece, deve essere salvata \emph{permanentemente} sul disco poichè possono essere necessarie eventuali modifiche ai file di configurazione od installazioni di programmi aggiuntivi.

Nella configurazione del kernel, per default, la dimensione di un singolo ramdisk è pari a 4096 KByte. \'E possibile modificare questa dimensione passando la seguente opzione del kernel nel file di configurazione del bootloader:
\begin{quote}
\code{ramdisk\_size=}\var{dim}
\end{quote}
dove \var{dim} equivale alla dimensione di un singolo ramdisk espressa in KByte.

Dato che abbiamo a disposizione 128 MByte di RAM, e l'intero sistema occupa all'incirca 20MByte, si è deciso di lavorare con un solo ramdisk (identificato dal device \code{/dev/ram0}) grande 90MByte.

\'E possibile che i log di sistema se non accuratamente monitorati possano diventare molto grandi, tanto da superare anche i 90 MByte messi a disposizione. Per ovviare a questo eventuale incoveniente si è deciso di utilizzare \code{crontab} abbinato a \code{logrotate}.

Difatti, il file \code{/etc/crontab} è stato configurato in questo modo:
\begin{quote}
\begin{small}
\begin{verbatim}
SHELL=/bin/sh
1  3  * * *     root    /sbin/logrotate /etc/logrotate.conf
\end{verbatim}
\end{small}
\end{quote}
mentre il file \code{/etc/logrotate.conf} è:
\begin{quote}
\begin{small}
\begin{verbatim}
daily
rotate 4
create

/var/log/messages {
    missingok
    sharedscripts
    create 0664 root root
    rotate 1
    postrotate
        /etc/init.d/sysklogd reload > /dev/null 2>&1 || true
    endscript
}

/var/log/wtmp {
    missingok
    monthly
    create 0664 root utmp
    rotate 1
}
\end{verbatim}
\end{small}
\end{quote}

Pertanto, utilizzando queste due applicazioni permettono di salvaguardare un'eventuale riempimento del ramdisk.

\subsection{Configurazione di rete}
Il passo successivo è stato nel configurare il server \code{ssh} in modo da girare su una porta differente rispetto a quella di default, e di abilitare l'accesso remoto utilizzando le chiavi RSA, ossia nel file \code{/etc/ssh/sshd\_config} dobbiamo impostare le seguenti opzioni:
\begin{quote}
\begin{small}
\begin{verbatim}
Port 31000
RSAAuthentication yes
PubkeyAuthentication yes
\end{verbatim}
\end{small}

\end{quote}

Per quanto riguarda la configurazione di rete, sono stati impostati i seguenti file:
\begin{itemize}
\item \code{/etc/network/interfaces}:
\begin{quote}
\begin{small}
\begin{verbatim}
auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
   address 192.168.3.50
   netmask 255.255.255.0
   gateway 192.168.3.1

auto eth1
iface eth1 inet static
   address 10.0.0.1
   netmask 255.0.0.0
\end{verbatim}
\end{small}
\end{quote}
\item \code{/etc/resolv.conf}:
\begin{quote}
\begin{small}
\begin{verbatim}
nameserver 213.156.54.80
nameserver 213.156.54.81
\end{verbatim}
\end{small}
\end{quote}
\end{itemize}

\subsection{Spegnimento e riavvio}
Per quanto riguarda il processo di spegnimento o di riavvio è stato scritto ispirandosi ai file: \code{knoppix-halt} e \code{knoppix-reboot}. Questi due file sono identici dato che si comportano in modo differente a seconda del nome che gli viene dato.

I daemon che sono stati sostituiti alleggeriscono le operazioni effettuate dagli script originali, come descritto in figura \ref{fig:daemon-shutdown}.
\begin{figure}[htb!]
  \centering
  \begin{lstlisting}[frame=single,basicstyle=\footnotesize\ttfamily,
    tabsize=3,numbers=left,xleftmargin=2em]
#!/bin/sh
PATH=/sbin:/bin:/usr/bin:/usr/sbin
export PATH
exec >/dev/console 2>&1 </dev/console
case "$0" in
*halt)
	command="halt"
	options="-p -d -i -f -n"
	;;
*reboot)
	command="reboot"
	options="-r -d -i -f -n"
	;;
*)
	echo "$0: call this script as \"halt\" or \"reboot\" please!"
	exit 1
	;;
esac

echo "0" > /proc/sys/kernel/printk
killall5 -15
echo "Sent all processes the TERM signal..."
sleep 1

killall5 -9
echo -n "Sent all processes the KILL signal..."
sleep 1

NETDEVICES="$(awk -F: '/eth.:/{print $1}' /proc/net/dev 2>/dev/null)"
if [ -n "$NETDEVICES" ]; then
	pidof pump >/dev/null 2>&1 && { pump -k ; sleep 2; }
	echo "Shutting down network devices..."
	for n in $NETDEVICES; do
		ifconfig $n down
	done
fi

FINALCMD="/sbin/$command"

echo "Unmounting file systems."
for dev in /proc/sys/dev/cdrom*/lock; do
	[ -f "$dev" ] && echo 0 > "$dev"
done
if [ -z "$NOEJECT" ]; then
	for dev in /proc/sys/dev/cdrom*/autoeject; do
		[ -f "$dev" ] && echo 1 > "$dev"
	done
fi

cd /

umount -arvf 2>/dev/null
if [ "$?" != "0" ] ; then
	for i in /dev/loop*; do
		losetup -d $i 2>/dev/null;
	done
	umount -arf 2>/dev/null
fi

rmmod -a >/dev/null 2>&1
mount -o remount,ro / 2>/dev/null
exec $FINALCMD $options 2>/dev/null
\end{lstlisting}
  \caption{Halt/Reboot Daemon}
  \label{fig:daemon-shutdown}
\end{figure}
Da quest'ultima figura si notano le operazioni di spegnimento, ossia:
\begin{itemize}
\item chiudere tutte le applicazioni,
\item disabilitare le schede di rete,
\item smontare i vari filesystems,
\item rimontare il root filesystem in modalità read-only,
\item spegnere o riavviare la macchina, a seconda dello script lanciato.
\end{itemize}

\subsection{Gestione Daemon}
Il processo di hardening comprende, infine, l'attivazione dei soli daemon necessari in fase di avvio. Questi daemon sono:
\begin{quote}
\code{crontab}, \code{klogd}, \code{networking}, \code{shorewall}, \code{ssh}, \code{sysklogd}, \code{bootlocal.sh}
\end{quote}

Utilizziamo, pertanto, l'applicazione \code{update-rc.d}. Per disabilitare un daemon la sintassi è:
\begin{quote}
\code{update-rc.d -f} \var{daemon} \code{remove}
\end{quote}

Mentre per abilitarne uno è:
\begin{quote}
\code{update-rc.d} \var{daemon} \code{defaults}
\end{quote}

\end{document}
