Linux sa generare sempre molta attesa per i suoi prodotti a tutt’oggi di nicchia,
perché sa coccolare ed ascoltare i suoi clienti come nessun altro tipo di sistema operativo è in grado di fare. Continua a leggere… »
Linux sa generare sempre molta attesa per i suoi prodotti a tutt’oggi di nicchia,
perché sa coccolare ed ascoltare i suoi clienti come nessun altro tipo di sistema operativo è in grado di fare. Continua a leggere… »
Monit è una applicazione utile a monitorare lo stato di file, directory, processi e periferiche. È in grado di intraprendere particolari misure di manutenzione nel caso in cui riscontri particolari anomalie.

Il programma è presente nel componente universe dei repository ufficiali. Una volta abilitato tale componente è sufficiente installare il pacchetto monit.
Per configurare l’applicazione è sufficiente modificare con un editor di testo con i privilegi di amministrazione il file di configurazione /etc/monit/monitrc.
Prima di tutto è necessario specificare quali server di posta verranno utilizzati per l’invio dei messaggi di notifica. È possibile aggiungere diversi server di posta con le relative porte. Supponendo di voler utilizzare per l’invio della posta i server mx1.example.com con porta standard 25 e mx2.example.com, con porta 10025, occorre aggiungere al file di configurazione la seguente direttiva:
set mailserver mx1.example.com,
mx2.example.com port 10025
Specificare poi l’indirizzo mittente da cui l’applicazione invierà la posta, ad esempio monit@example.com:
set mail-format { from: monit@example.com }
Specificare l’indirizzo a cui le mail di notifica dovranno essere consegnate (es. sysadmin@example.com)
set alert sysadmin@example.com
Abilitare il server web interno per accedere all’interfaccia di amministrazione. È possibile specificare a quali indirizzi consentire l’accesso (es. localhost) e quali utenti, con le relative password. Nell’esempio che segue verrà configurato un singolo accesso di amministrazione per l’utente «admin» con password «monit»:
set httpd port 2812 and
use address localhost # accetta connessioni solo da localhost
allow localhost # permette la visualizzazione solo se la richiesta proviene da localhost
allow admin:monit # utente admin con password monit
Una configurazione più sicura prevede l’utilizzo di SSL. Per far ciò è necessario generare un certificato x509 valido. Supponendo che questo sia contenuto, insieme alla relativa chiave privata, nel file /var/certs/monit.pem occorre aggiungere una direttiva del seguente tipo:
set httpd port 2812 and
SSL ENABLE
PEMFILE /var/certs/monit.pem
allow admin:monit
Qualora si vogliano monitorare le risorse utilizzate dal sistema, è possibile aggiungere una regola che avvisi l’amministratore nel caso in cui alcune soglie vengano superate. Quello che segue è un esempio generico:
check system server.example.com
if loadavg (1min) > 4 then alert
if loadavg (5min) > 2 then alert
if memory usage > 75% then alert
if cpu usage (user) > 70% then alert
if cpu usage (system) > 30% then alert
if cpu usage (wait) > 20% then alert
Se si desidera invece monitare i permessi e il proprietario di una particolare cartella di sistema è utile aggiungere una regola simile alla seguente:
check directory bin with path /bin
if failed permission 755 then unmonitor
if failed uid 0 then unmonitor
if failed gid 0 then unmonitor
Per monitare un servizio di sismtema è utile aggiungere una direttiva simile alla seguente:
check process slapd with pidfile /var/run/slapd/slapd.pid start program = "/etc/init.d/slapd start" stop program = "/etc/init.d/slapd stop" if failed host 192.168.1.1 port 389 protocol ldap3 then restart if 5 restarts within 5 cycles then timeout
Nella configurazione dell’esempio sopra citato, qualora il server ldap risultasse non disponibile, monit provvederà a riavviarlo.
Per monitare un PC remoto su cui gira una istanza di MySql, è utile aggiungere una direttiva simile alla seguente:
check host myserver with address 192.168.1.1
if failed icmp type echo count 3 with timeout 3 seconds then alert
if failed port 3306 protocol mysql with timeout 15 seconds then alert
Le diciture «myserver» e «192.168.1.1» vanno sostituite con gli indirizzi adatti ai propri scopi.
Aprire il file /etc/defautl/monit con un editor di testo con i privilegi di amministrazione, dunque modificare la variabile «startup» come nell’esempio seguente:
startup=1
Infine avviare il servizio con il seguente comando in una finestra di terminale:
sudo /etc/init.d/monit start
L’interfaccia amministrativa di monit sarà raggiungibile all’indirizzo http://localhost:2812.
X.509 è uno standard ITU-T per infrastrutture a chiave pubblica.
Il cuore del meccanismo X.509 sono i certificati. Essi vengono rilasciati da una autorità per la certificazione ed hanno lo scopo di certificare l’appartenenza di una chiave pubblica ad un particolare «Nome Distintivo» oppure ad un «Nome Alternativo» come potrebbe essere un indirizzo e-mail o un record DNS. Una infrastruttura PKI è strutturata gerarchicamente da più CA al cui vertice si trova una CA root che certifica le sub-CA.
Il certificato appartenente alla autorità viene definito certificato root. Una violazione di tale certificato, autofirmato dalla stessa autorità, comprometterebbe l’intero sistema.
Esistono diverse autorità per la certificazione universalmente riconosciute, ma ogni azienda può crearne una propria da utilizzare privatamente al suo interno.
La struttura di un certificato digitale X.509 v3 è la seguente:
Il seguente è un esempio di certificato:
Certificate:
Data:
Version: 3 (0x2)
Serial Number: 1 (0x1)
Signature Algorithm: md5WithRSAEncryption
Issuer: C=DE, ST=NRW, L=Steinfurt, O=Spenneberg.com,
CN=RootCA 2003/Email=ralf@spenneberg.net
Validity
Not Before: Apr 30 06:08:56 2003 GMT
Not After : Apr 29 06:08:56 2004 GMT
Subject: C=DE, ST=NRW, L=Steinfurt, O=Spenneberg.com,
CN=VPN-Gateway/Email=ralf@spenneberg.net
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
RSA Public Key: (1024 bit)
Modulus (1024 bit):
00:c5:3b:9c:36:3a:19:6c:a9:f2:ba:e9:d2:ed:84:
33:36:48:07:b2:a3:2d:59:92:b0:86:4c:81:2c:ea:
5c:ed:f3:ba:eb:17:4e:b3:3a:cc:b7:5b:5d:ca:b3:
04:ed:fb:59:3c:c5:25:3e:f3:ff:b0:22:10:fb:de:
72:0a:ee:42:4b:9a:d3:27:d3:b6:fb:e9:88:10:c8:
47:b7:26:4f:71:40:e4:75:c4:c0:ee:6b:87:b8:6f:
c9:5e:66:cf:bb:e7:ad:72:68:b8:6d:fd:8f:4c:1f:
3a:a2:0d:43:25:06:b9:92:e7:20:6c:86:15:a0:eb:
7f:f7:0b:9a:99:5d:14:88:9b
Exponent: 65537 (0x10001)
X509v3 extensions:
X509v3 Basic Constraints:
CA:FALSE
Netscape Comment:
OpenSSL Generated Certificate
X509v3 Subject Key Identifier:
CB:5C:19:9B:E6:8A:8A:FE:0E:C4:FD:5E:DF:F7:BF:3D:A8:
18:7C:08
X509v3 Authority Key Identifier:
keyid:01:BB:C6:33:BE:F5:9A:5E:B0:0C:5D:BD:41:E9:78:
6C:54:AD:66:8E
DirName:/C=DE/ST=NRW/L=Steinfurt/O=Spenneberg.com/
CN=RootCA 2003/Email=ralf@spenneberg.net
serial:00
Signature Algorithm: md5WithRSAEncryption
6f:89:2b:95:af:f1:8d:4d:b7:df:e8:6d:f7:92:fb:48:8c:c4:
1a:43:68:65:97:01:87:a6:84:b5:a1:38:bd:62:74:70:db:9e:
78:19:d9:0c:af:18:ad:13:77:56:7d:3f:19:61:da:ba:74:30:
8e:c5:50:0e:e3:eb:ff:95:cd:8d:d6:7e:c3:0e:ab:5b:34:94:
bc:16:0f:ef:dc:de:40:bb:7d:ba:a2:b8:5d:f9:74:e7:28:58:
75:a0:66:d2:8d:85:ba:38:82:08:10:33:ef:be:29:c9:31:9d:
63:a9:f7:e0:99:ea:a7:ed:b6:b5:33:1b:1c:4a:a4:05:40:6e:
40:7b
-----BEGIN CERTIFICATE-----
MIIDjDCCAvWgAwIBAgIBATANBgkqhkiG9w0BAQQFADCBgjELMAkGA1UEBhMCREUx
DDAKBgNVBAgTA05SVzESMBAGA1UEBxMJU3RlaW5mdXJ0MRcwFQYDVQQKEw5TcGVu
bmViZXJnLmNvbTEUMBIGA1UEAxMLUm9vdENBIDIwMDMxIjAgBgkqhkiG9w0BCQEW
E3JhbGZAc3Blbm5lYmVyZy5uZXQwHhcNMDMwNDMwMDYwODU2WhcNMDQwNDI5MDYw
ODU2WjCBgjELMAkGA1UEBhMCREUxDDAKBgNVBAgTA05SVzESMBAGA1UEBxMJU3Rl
aW5mdXJ0MRcwFQYDVQQKEw5TcGVubmViZXJnLmNvbTEUMBIGA1UEAxMLVlBOLUdh
dGV3YXkxIjAgBgkqhkiG9w0BCQEWE3JhbGZAc3Blbm5lYmVyZy5uZXQwgZ8wDQYJ
KoZIhvcNAQEBBQADgY0AMIGJAoGBAMU7nDY6GWyp8rrp0u2EMzZIB7KjLVmSsIZM
gSzqXO3zuusXTrM6zLdbXcqzBO37WTzFJT7z/7AiEPvecgruQkua0yfTtvvpiBDI
R7cmT3FA5HXEwO5rh7hvyV5mz7vnrXJouG39j0wfOqINQyUGuZLnIGyGFaDrf/cL
mpldFIibAgMBAAGjggEOMIIBCjAJBgNVHRMEAjAAMCwGCWCGSAGG+EIBDQQfFh1P
cGVuU1NMIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQUy1wZm+aKiv4O
xP1e3/e/PagYfAgwga8GA1UdIwSBpzCBpIAUAbvGM771ml6wDF29Qel4bFStZo6h
gYikgYUwgYIxCzAJBgNVBAYTAkRFMQwwCgYDVQQIEwNOUlcxEjAQBgNVBAcTCVN0
ZWluZnVydDEXMBUGA1UEChMOU3Blbm5lYmVyZy5jb20xFDASBgNVBAMTC1Jvb3RD
QSAyMDAzMSIwIAYJKoZIhvcNAQkBFhNyYWxmQHNwZW5uZWJlcmcubmV0ggEAMA0G
CSqGSIb3DQEBBAUAA4GBAG+JK5Wv8Y1Nt9/obfeS+0iMxBpDaGWXAYemhLWhOL1i
dHDbnngZ2QyvGK0Td1Z9Pxlh2rp0MI7FUA7j6/+VzY3WfsMOq1s0lLwWD+/c3kC7
fbqiuF35dOcoWHWgZtKNhbo4gggQM+++KckxnWOp9+CZ6qfttrUzGxxKpAVAbkB7
-----END CERTIFICATE-----
Per installare OpenSSL è sufficiente installare il pacchetto openssl presente nei repository ufficiali.
Prima di cominciare è necessario creare una cartella che conterrà tutte le informazioni relative all’autorità che si desidera creare. Aprire una finestra di terminale e digitare i seguenti comandi:
cd mkdir rootCA cd rootCA mkdir certs crl newcerts private cd rootCA touch index.txt echo "00" > serial
Copiare il file di configurazione /etc/ssl/openssl.cnf nella cartella corrente con il seguente comando:
cp /etc/ssl/openssl.cnf .
Aprire il file appena copiato con un editor di testo e modificarlo come nel seguente esempio:
[ CA_default ] dir = . ... [ req_distinguished_name ] countryName = Country Name (2 letter code) countryName_default = IT countryName_min = 2 countryName_max = 2 stateOrProvinceName = State or Province Name (full name) stateOrProvinceName_default = Milano localityName = Locality Name (eg, city) localityName_default = Milano 0.organizationName = Organization Name (eg, company) 0.organizationName_default = Ubuntu Italian Community organizationalUnitName = Organizational Unit Name (eg, section) organizationalUnitName_default = Consiglio
| Le stringhe «countryName_default», «stateOrProvinceName_default» «0.organizationName_default» e «organizationalUnitName_defaul» possono essere personalizzare con dei valori più appropriati. |
Per generare la richiesta di certificato con la chiave privata residente in private/rootCAkey.pem è sufficiente digitare il seguente comando:
openssl req -config openssl.cnf -new -x509 -keyout private/rootCAkey.pem -out rootCAcert.pem -days 365
È possibile verificare il contenuto del certificato e della chiave privata appena generati con i seguenti comandi:
openssl x509 -in rootCAcert.pem -text openssl rsa -in private/rootCAkey.pem -text
| Una violazione del certificato o della chiave privata appena generati comprometterebbe la sicurezza dell’intera infrastruttura |
Creare una cartella per contenere i certificati degli utenti con il seguente comando in una finestra di terminale:
mkdir utenti cd utenti
Generare la richiesta di certificato per ogni singolo utente con il seguente comando:
openssl req -config ../openssl.cnf -new -keyout utentekey.pem -out utentereq.pem
Infine, non resta che firmare la richiesta con la chiave privata dell’authority. Digitare il seguente comando:
cd .. openssl ca -config openssl.cnf -policy policy_anything -cert rootCAcert.pem -keyfile private/rootCAkey.pem -out utenti/utentecert.pem -infiles utenti/utentereq.pem
| I comandi sopra citati vanno adattati alle proprie esigenze. |
Avira Antivir Personal Edition Classic è un software antivirus concesso sotto licenza freeware dalla casa produttrice Avira GmbH.
| In questa guida si è scelto di non attivare il supporto di scansione in tempo reale. |
Installare Java come illustrato nella giuda contenuta nella documentazione della comunià. Andare sul sito di Antivir e scaricare il pacchetto antivir-workstation-pers.tar.gz all’interno del quale è presente anche un’esaustiva documentazione.
sudo -s
mv antivir-workstation-pers.tar.gz /opt cd /opt
tar zxvf antivir* cd antivir-workstation-pers-2.1.10-15
chmod a+rwx install chown nome_utente install ./install
A questo punto ha inizio l’installazione del programma. Viene chiesto di prendere visione della licenza. Se si vuole saltare questo passaggio è suffciente premeteil tasto «q».
Di seguito vengono riportate le domande poste e le risposte che permettono un’installazione standard (ovviamente è possibile modificarle in base alle proprie esigenze):
Do you agree to the license terms? [n] y Enter the path to your key file: [hbedv.key] premere INVIO Would you like to install the internet update daemon? [n] y Would you like to create a link in /usr/sbin for avupdater ? [y] premere INVIO Would you like the internet update daemon to start automatically? [y] premere INVIO
Un discorso a parte merita il suguente punto:
How should AvGuard be installed? [n] premere INVIO
| Avguard è una funzionalità che permette di scansionare un file nel momento stesso in cui si effettua un accesso a tale file, la funzione è anche conosciuta col nome di real-time. Su un sistema Microsoft Windows si tratta senza alcun dubbio di un’opzione da abilitare mentre su un sistema Linux è ragionevole affermare che causerebbe un inutile spreco di risorse. Se si vuole abilitare questa opzione si deve installare manualmente il modulo Dazuko, come descritto nella documentazione presente nel pacchetto. |
In questo caso non attivare l’opzione Avguard e continuare nel processo:
How should AvGuard be installed? [n] premere INVIO Would you like to install the GUI (+ SMC support)? [y] premere INVIO Would you like to configure the AntiVir updater now? [y] premere INVIO Would you like email notification about updates? [n] premere INVIO Would you like the updater to log to a custom file? [y] premere INVIO What will be the log file name with absolute path (it must begin with ‘/’) ? [/var/log/avupdater.log] premere INVIO How often should AntiVir check for updates? [2] premere INVIO Does this machine use an HTTP proxy server? [n] premere INVIO Save configuration settings? [y] premere INVIO Would you like to apply the new configuration? [y] premere INVIO
Andare in Sistema -> Preferenze -> Sessioni , selezionare «Nuovo», in «Nome» inserire un nome a piacere e infine in «Comando:» digitare «/usr/lib/AntiVir/avupdater start»
A questo punto bisogna inserire l’utente nel gruppo «Antivir» andando su Sistema -> Amministrazione -> Utenti e gruppi , fare clic sul pulsante «Gestione gruppi». Dalla finestra che si apre selezionare «Antivir», cliccare su «Proprietà» e spuntare le caselle «Root» e «Nome utente».
Per comodità si può anche aggiungere la voce nel menù. Quindi si deve andare su Sistema -> Preferenze -> Menù Principale , spostarsi nella sezione «Accessori», fare clic su «Nuova voce», in «Tipo» selezionare dal menù a tendina «Applicazione», in «Nome» inserire un nome a piacere e infine in «Comando» digitare «/usr/lib/antivir-gui».
Si potrà così aprire l’antivirus dal menù Applicazioni -> Accessori -> Antivir.
Una volta rieffettuato il login tutto dovrebbe funzionare correttamente.
Per la rimozione bisogna procedere manualmente:
sudo -s
rm -r /usr/lib/AntiVir
rm /etc/avupdater.conf rm /etc/avguard.conf
rm /usr/bin/antivir rm /usr/bin/antivir-gui
find /etc/init.d /usr/sbin -name "*avguard" rm /etc/init.d/avguard rm /usr/sbin/avguard
| L’operazione al punto 5 non è necessaria in quanto in questa guida non è stato installato Avguard. |
find /etc/init.d /usr/sbin -name "*avupdater" rm /etc/init.d/avupdater rm /usr/sbin/avupdater
La presente guida intende offrire una panoramica delle questioni legate al malware su GNU/Linux ed orientare l’utente sulla utilità o meno di installare un antivirus sul proprio sistema.
Non è sufficiente che il malware entri a contatto con il sistema per avviarsi, ma è necessario che entri in esecuzione. In base a questa banale considerazione molti antivirus mettono i file infetti in quarantena, ossia in una cartella controllata dove non possono più agire.
Quando il malware entra in contatto con il sistema deve presentarsi uno dei seguenti casi affinché esso possa entrare in esecuzione:
Una vulnerabilità è una falla di un programma che produce un comportamento non previsto dal programmatore o considerato (a torto) non pericoloso.
I sistemi operativi di tipo Unix hanno una rigida e complessa gestione dei permessi. Ogni utente, e quindi ogni programmi eseguito da tale utente, può fare con un file solo ciò che è consentito in base ai permessi che egli possiede. Si consulti la guida del comando sudo per approfondire la logica dei permessi. Questo implica alcune conseguenze:
In base a ciò, un malware che agisce a livello utente non può creare danni al sistema, ma può al limite cancellare o infettare solo i file appartenenti a quel determinato utente.
Di norma nessun sistema di tipo Unix installa i programmi (neppure i programmi utente) nella directory Home dell’utente. Ciò, unito alla suddetta gestione dei permessi, mette al riparo il sistema dall’infezione da parte dei tradizionali virus che non trovano eseguibili a cui “attaccarsi”. I worm non possono agire perché per farlo devono avere i permessi di esecuzione. I rootkit non possono installarsi autonomamente in quanto caricare un modulo/driver nel kernel richiede i permessi di amministrazione, a meno di vulnerabilità del sistema. Infatti una vulnerabilità grave può permettere al malware di superare tali restrizioni e acquisire i permessi di amministratore.
Un software libero/open source, e quindi GNU/Linux, ha la caratteristica di avere il codice sorgente liberamente consultabile e modificabile. Questo apparentemente potrebbe rendere meno sicuro il sistema. In teoria, se tutti conoscono il codice sorgente, chiunque può scoprirne le vulnerabilità e quindi sfruttarle con fini fraudolenti.
Nella pratica, però, si realizza l’esatto opposto: proprio perché tutti possono scoprire facilmente le vulnerabilità, esse possono venire tempestivamente corrette. Molte vulnerabilità vengono infatti corrette ancora prima che possano essere sfruttate a danno del sistema.
| Per i motivi esposti navigare sul Web con un browser open source è più sicuro che navigare con uno proprietario e usare una suite per l’ufficio open source è più sicuro che usarne una proprietaria. |
Sono stati adottati vari meccanismi preventivi per rafforzare la sicurezza del sistema come:
Per comprendere quanto i sistemi Unix siano sicuri è utile consultare alcune fonti:
Nella realtà il concetto di virus è praticamente sconosciuto nei sistemi di tipo Unix essendo i pochi finora scoperti non in grado di diffondersi efficacemente, perché necessiterebbero di entrare fraudolentemente in possesso dei permessi di amministratore.
| E’ interessante sapere che OpenBSD, un sistema di tipo Unix, ha avuto solo due falle di sicurezza remote in 10 anni di sviluppo. |
I virus di Windows sono programmi scritti per un altro sistema operativo. Normalmente non possono agire su GNU/Linux (si consulti la sezione seguente per conoscere le eccezioni a tale regola). Pertanto non ci si deve preoccupare se un file infetto viene a contatto con il sistema. Anche aprire i file .doc non è pericoloso perché OpenOffice non soffre delle stesse vulnerabilità dei concorrenti programmi proprietari.
Per quanto detto finora, di norma non vi è alcun bisogno di antivirus su un sistema GNU/Linux. Infatti gli antivirus per GNU/Linux sono in realtà antivirus contro il malware di Windows. Tuttavia in alcune situazioni un antivirus è consigliato:
La sicurezza di un sistema dipende non solo dalla robustezza dello stesso, ma dai comportamenti dell’utente. Nessun sistema è sicuro se l’utente compie azioni che lo mettono a rischio. Ecco alcuni utili consigli:
| I consigli riportati sopra vanno presi come tali. Ad esempio, non è necessario affrettarsi a installare l’ultima versione disponibile di Firefox dal sito di Mozilla: se contiene correzioni di sicurezza significative, verrà segnalata tra gli aggiornamenti della distribuzione in breve tempo. |
Nonostante i sistemi GNU/Linux e in generale i sistemi di tipo Unix siano in genere abbastanza sicuri con le impostazioni di default, in rete sono presenti numerose guide per aumentare la sicurezza dei sistemi GNU/Linux.
Ecco alcuni dei principali motivi:
Molti produttori di antivirus sostengono che la crescente diffusione sui sistemi desktop di GNU/Linux accrescerà l’insicurezza del sistema, portando alla nascita di malware e in particolare di virus. Se si è compreso quanto detto in precedenza, si è già in grado di rispondere negativamente a tale affermazione: difatti le banali regole già richiamate sono più che sufficienti a mettersi al riparo dai problemi di sicurezza legati al malware.
Inoltre ci sono considerazioni legate all’esperienza che vanno ugualmente tenute in considerazione:
Le tecniche di Port knocking permettono di aumentare considerevolmente la sicurezza di un server che deve garantire alcuni servizi non permanenti attraverso IP pubblici. Se s’inviano dei pacchetti a delle porte prestabilite sulle quali il demone è in ascolto e nel caso la sequenza sia corretta, questi attiverà un comando che potrà eseguire delle regole di iptables che apriranno le porte necessarie alla connessione. Il vantaggio è notevole in quanto il server potrebbe rimanere sempre in stealth e aprire le porte per un determinato servizio solo in caso di necessità.
È necessario che il firewall iptables sia configurato e attivo.
Per utilizzare le tecniche di Port knocking è necessario installare il pacchetto knockd, reperibile dal componente universe dei repository ufficiali.
START_KNOCKD=1
KNOCKD_OPTS="-i eth0"
Modificare con un editor di testo e con i privilegi di amministrazione il file /etc/knockd.conf impostandolo come segue:
[options]
logfile = /var/log/knockd.log
[openSSH]
sequence = 7000,8000,9000
# Questa è la sequenza delle porte sulle quali knockd rimarrà in ascolto. Di default il protocollo è TCP.
# Quali e quante porte usare è discrezionale.
# sequence = 7000:udp,8000:tcp,9000:udp
# Esempio con sequenza con porte miste udp/tcp
seq_timeout = 30
#Tempo di attesa massimo per completare la sequenza.
command = /sbin/iptables -A INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
# Quando la sequenza verrà accettata verrà inserita una regola che aprirà la porta SSH standard.
tcpflags = syn
# Ulteriore filtro, sul tipo di flag del pacchetto inviato alla sequenza di porte.
[closeSSH]
sequence = 9000,8000,7000
# Questa è un'altra sequenza di porte sulle quali knockd rimarrà in ascolto.
seq_timeout = 30
command = /sbin/iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
# Quando la sequenza verrà accettata verrà inserita una regola che cancellerà quella creata in precedenza.
tcpflags = syn
# Ulteriore filtro, sul tipo di flag del pacchetto inviato alla sequenza di porte.
La variabile «%IP%» passa alla regola di iptables l’indirizzo che ha effettuato la richiesta di connessione, in questo caso verrà permessa l’apertura della porta SSH discriminando solo l’IP validato.
Un’altra possibilità per usare il demone knockd, utilizzabile SOLO se il firewall sul server è configurato per accettare le connessioni “established” e “related” alla porta che si vuole aprire (es ssh, 22) è di chiudersi subito dietro la porta appena aperta, per evitare che, restando “aperta”, qualche malintenzionato tenti un brute-force al servizio, lanciando uno script anzichè impostando delle regole sul firewall.
Per questo scopo il file /etc/knockd.conf può ad esempio essere modificato, con un editor di testo e con i privilegi di amministrazione, come segue (per spiegazioni sul significato delle opzioni vedere la sezione precedente):
[options]
logfile = /var/log/knockd.log
[openSSH]
sequence = 7000,8000,9000
seq_timeout = 30
start_command = /etc/init.d/ssh start
tcpflags = syn
cmd_timeout = 5
stop_command = /etc/init.d/ssh stop
# Dopo cmd_timeout secondi, viene eseguito il comando stop_command
Ricordiamo ancora che è indispensabile che il firewall sul server accetti le connessioni “related” ed “established” altrimenti la sezione “stop_command”, appena sarà eseguita, vi chiuderà la connessione SSH senza quindi avere possibilità di connettervi al server!
root@server2:~# iptables -nL | grep ":22" ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 tcp dpt:22 ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 tcp spt:22 dpts:513:65535 state RELATED,ESTABLISHED ACCEPT tcp -- 0.0.0.0/0 0.0.0.0/0 tcp spts:1024:65535 dpt:22 flags:0x17/0x02 state RELATED,ESTABLISHED ACCEPT udp -- 0.0.0.0/0 0.0.0.0/0 udp dpt:22 state ESTABLISHE root@server2:~#
Nell’esempio sopra esposto si è visto come aprire una sola porta. Se l’esigenza fosse però quella di aprirne di più procedere creando più sessioni «[openServizio]» e «[closeServizio]». Questo sistema risulta però scomodo per ovvi motivi, per ottenere lo stesso risultato è consigliato usare degli script.
Modificare con un editor di testo e con i privilegi di amministrazione il file /etc/knockd.conf impostandolo come segue:
[options]
logfile = /var/log/knockd.log
[open]
sequence = 7000,8000,9000
seq_timeout = 30
tcpflags = syn
command = sh /etc/open_ports %IP%
[close]
sequence = 9000,8000,7000
seq_timeout = 30
tcpflags = syn
command = sh /etc/close_ports %IP%
In questo caso invece di eseguire direttamente iptables si richiamano due script passando il parametro «%IP%» alla variabile speciale «$1».
Modificare con un editor di testo e con i privilegi di amministrazione il file /etc/open_ports impostandolo come segue:
#! /bin/sh iptables -A INPUT -s $1 -p tcp --dport 22 -j ACCEPT iptables -A INPUT -s $1 -p tcp --dport 21 -j ACCEPT iptables -A INPUT -s $1 -p tcp --dport 631 -j ACCEPT iptables -A INPUT -s $1 -p tcp --dport 5125 -j ACCEPT iptables -A INPUT -s $1 -p tcp --dport 5126 -j ACCEPT iptables -A INPUT -s $1 -p tcp --dport 8888 -j ACCEPT iptables -A INPUT -s $1 -p tcp --dport 10000 -j ACCEPT iptables -A INPUT -s $1 -p tcp --dport 81 -j ACCEPT
Modificare con un editor di testo e con i privilegi di amministrazione il file /etc/close_ports impostandolo come segue:
#! /bin/sh iptables -D INPUT -s $1 -p tcp --dport 22 -j ACCEPT iptables -D INPUT -s $1 -p tcp --dport 21 -j ACCEPT iptables -D INPUT -s $1 -p tcp --dport 631 -j ACCEPT iptables -D INPUT -s $1 -p tcp --dport 5125 -j ACCEPT iptables -D INPUT -s $1 -p tcp --dport 5126 -j ACCEPT iptables -D INPUT -s $1 -p tcp --dport 8888 -j ACCEPT iptables -D INPUT -s $1 -p tcp --dport 10000 -j ACCEPT iptables -D INPUT -s $1 -p tcp --dport 81 -j ACCEPT
Di seguito viene mostrato come configurare i client a dipendenza del sistema operativo utilizzato.
Scaricare i sorgenti da questo indirizzo all’interno della propria Home e scompattarli, entrare nella cartella knock-0.x/src e digitare all’interno di una finestra di terminale il seguente comando:
gcc -o knock knock.c
Sempre da una finestra di terminale digitare il comando per la connessione oppure seguire i passaggi per creare un alias di connessione
Scaricare da questo indirizzo e digitare all’interno di una finestra DOS il comando per la connessione tralasciando la prima parte «./»
Consultare la relativa pagina.
Per effettuare la connessione digitare il seguente comando all’interno di una finestra di terminale:
./knock -v ip_host port1 port2 port3 port...
Nel caso una porta sia configurata tramite il protocollo UDP, usare la sintassi «port:udp»
Creare un alias aggiungendo la seguente riga al file .bash_aliases nella home dell’utente e creare successivamente il file “connectServer”:
utente@client:/home/Scrivania/# cd utente@client:~# vi .bash_aliases
Contenuto del file ~/.bash_aliases:
alias ll='ls -l' alias la='ls -a' alias count='ll | wc -l' alias SshServer='~/connectServer' # Parte da aggiungere
Contenuto del file ~/connectServer
# ip_del_server va sostiuito con l'ip o il dns name del server a cui connettersi (es: 192.168.0.2 oppure www.myserver.com) telnet ip_del_server 7000 telnet ip_del_server 8000 telnet ip_del_server 9000 # Attesa di due secondi prima di effettuare la connessione: il server potrebbe metterci del tempo prima di avviare il demone SSH! sleep 2 # Da abilitare se si vuole effettuare la connessione con utente root # ssh -l root ip_del_server ssh ip_del_server
Salvare il file connectServer e assicurarsi che sia eseguibile:
utente@client:~# chmod +x connectServer
A questo punto per connettersi al server (dopo aver riaperto una shell, altrimenti il nuovo alias non sarà riconosciuto) basterà digitare quanto segue:
utente@client:~# SshServer
È possibile applicare numerose patch a netfileter, utili ad ampliare in modo considerevole le funzionalità di base offerte con il kernel.
| Molte di queste modifiche sono attualmente in fase di sviluppo, è sconsigliato applicarle sul proprio kernel predefinito. |
Per applicare le patch al proprio kernel sono necessari:
Scaricare patch’o'matic nella propria Home con i seguenti comandi:
cd wget ftp://ftp.lt.netfilter.org/pub/netfilter/patch-o-matic-ng/patch-o-matic-ng-20040621.tar.bz2 tar -jxvf patch-o-matic-ng-20040621.tar.bz2 cd patch-o-matic-ng-20040621
A questo punto si può procedere con la procedura standard di P-O-M:
export KERNEL_DIR=/usr/src/kerneldir (Indicare la directory dove si trovano i sorgenti del kernel da patchare) export IPTABLES_DIR=/usr/src/iptablesdir (dove sono stati scompattati i sorgenti di iptables) ./runme pending
Con queste opzioni applichiamo le patch base, mentre usando
./runme base
o
./runme extra
applicheremo le patch degli altri due gruppi principali. Per ognuna della patch viene fornita una breve spiegazione e chiesto se si vuole aggiungerla nel kernel. Le opzioni disponibili più importanti, una volta che siamo nella procedura di configurazione di P-O-M, sono T e F; T serve per fare un test per verificare che la patch sia applicabile, F serve per forzarne l’applicazione anche se il test fallisce. Una volta completata questa operazione è possibile procedere alla compilazione del kernel secondo le solite procedure. Nel menu di configurazione del kernel tutte le patch aggiuntive sono include nella voce “NetFilter Configuration” del menu Networking options.
Patch sperimentale che serve per impostare un numero massimo di connessioni tcp da un singolo host IP o da una intera rete. Introduce il match connlimit con le opzioni:
Esempi:
Per limitare l’accesso SSH a due sole connessioni per IP sorgente:
-I INPUT -p tcp --dport 22 --syn -m connlimit --connlimit-above 2 -j DROP
Per impostare massimo 16 connessioni per rete di 256 indirizzi ad un server web dietro il firewall Linux:
-A FORWARD -d 213.215.144.242 -p tcp -m tcp --dport 80 --syn -m connlimit --connlimit-above 16 --connlimit-mask 32 -j DROP
Per impostare a 250 il numero massimo di connessioni contemporanee che possono essere fatte ad un server SMTP:
-A FORWARD -d 213.215.144.242 -p tcp -m tcp --dport 25 --syn -m connlimit --connlimit-above 250 --connlimit-mask 0 -j DROP
Voce nel kernel .config: CONFIG_IP_NF_MATCH_CONNLIMIT Nome modulo: ipt_connlimit
E’ possibile identificare dei Port Scan tramite il match psd con le seguenti opzioni:
Un esempio essenziale per aggiungere un log, che può essere verboso, di tutti gli scan (Consigliabile aggiungerlo alla fine della catena di INPUT, con un default DROP finale):
iptables -A INPUT -m psd -j LOG --log-prefix "PORTSCAN: "
Voce nel kernel .config: CONFIG_IP_NF_MATCH_PSD Nome modulo: ipt_psd
Iptables è il firewall, da linea di comando, installato in modo predefinito su Ubuntu. Questo howto mostrerà brevemente come avere un firewall minimale ma robusto.
Un computer connesso ad internet scambia continuamente dati col resto del mondo.
I dati che dal mondo esterno entrano nel nostro computer possono essere di tipo “buono”, come ad esempio una pagina di un sito che abbiamo richiesto, un amico che ci contatta in chat o un file che stiamo scaricando con un programma di filesharing, e di tipo “cattivo”, come ad esempio un cracker che ci contatta in vari modi e a nostra insaputa per cercare di entrare nel nostro computer.
Il compito del firewall è riconoscere il traffico buono da quello cattivo, e bloccare il traffico cattivo. Per farlo, ha bisogno che siamo noi a dirgli cosa è buono e cosa no, mediante delle regole per fare i controlli sul traffico di dati.
Iptables raggruppa tutti i controlli che può fare sul traffico in entrata, nella cosiddetta Chain INPUT, catena di input. I controlli sul traffico in uscita sono invece raggruppati nella Chain OUTPUT. La Chain FORWARD serve per esempio quando il traffico di dati non è indirizzato a noi ma passa comunque per il nostro computer.
Ognuna di queste catene ha una policy, una politica, cioè un’azione predefinita da eseguire quando tutti gli altri controlli della catena hanno fallito nel riconoscere se il dato era buono o meno.
Seguite la guida per Firestarter
Il firewall è incluso in Ubuntu ed è attivo all’avvio del sistema senza richiedere alcuna azione da parte dell’utente. Anche iptables è incluso in Ubuntu, e bisogna usarlo da riga di comando per configurare il firewall.
Per usare iptables sono necessari i privilegi di amministrazione.
Dal momento che i comandi che trovate in questa guida servono a modificare la configurazione del firewall “a caldo”, senza scrivere niente in file di configurazione, ma caricando direttamente le impostazioni in memoria, al successivo avvio del computer la configurazione fatta non sarà più disponibile.
Per ovviare a questo problema si possono inserire i comandi in uno script da lanciare all’avvio del computer.
Per avere sott’occhio in ogni momento la configurazione del firewall, è sufficiente digitare in un terminale:
sudo iptables -L
Per esempio, con Ubuntu appena installato, il firewall è sì attivo, ma non ha ancora una vera configurazione, perciò l’output dovrebbe essere:
Chain INPUT (policy ACCEPT) target prot opt source destination Chain FORWARD (policy ACCEPT) target prot opt source destination Chain OUTPUT (policy ACCEPT) target prot opt source destination
In modo predefinito il firewall lascia passare tutto, come indicano le scritte “policy ACCEPT” e l’assenza di altre regole.
A volte le informazioni mostrate non sono sufficienti; in questi casi basta aggiungere -v oppure -vv al precedente comando. Per esempio:
sudo iptables -vv -L
Per iniziare, possiamo bloccare tutto il traffico proveniente dal mondo esterno (per poi in seguito consentire solo il traffico che riteniamo buono), impostando una policy che faccia scomparire nel nulla tutti i pacchetti in entrata:
sudo iptables -P INPUT DROP
In questo momento non possiamo navigare nel web, e più in generale il nostro PC non si accorgerà di qualsiasi dato ci venga spedito da chicchessia. Niente paura, fra qualche riga vedremo come istruire iptables a lasciare passare il traffico a cui siamo interessati.
Un’altra buona policy da impostare è:
sudo iptables -P FORWARD DROP
Per quanto riguarda il traffico che dal nostro PC esce verso il mondo esterno, possiamo benissimo permetterlo senza preoccuparci troppo; infatti, se MS Windows è succube di programmini malefici che una volta insediatisi in un PC tentano di comunicare (dati sensibili, attacchi informatici, eccetera) col mondo esterno, ciò in GNU/Linux non avviene, o meglio la probabilità che avvenga è del tutto risibile.
Innanzitutto dobbiamo consentire tutto il traffico interno al nostro computer, che passa per l’interfaccia di loopback “lo“. Quindi da terminale digitiamo:
sudo iptables -A INPUT -i lo -j ACCEPT
La seconda cosa che potremmo voler fare è navigare nel web e più in generale lasciare entrare tutto il traffico che è stato da noi richiesto:
sudo iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
Ci sono situazioni in cui vogliamo permettere a un utente esterno di contattare il nostro PC e di inviarci dati, per esempio se abbiamo installato un server SSH, un server web o un programma che per svolgere il suo compito deve fungere anche da server, ad esempio un programma di filesharing come aMule.
Il nostro server SSH usa la porta 22 (a meno che non lo abbiamo configurato diversamente), quindi dobbiamo dire a iptables di lasciare entrare il traffico tcp sulla porta 22 (il relativo traffico di risposta lo abbiamo già permesso prima), quindi:
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
In ogni momento possiamo controllare come abbiamo configurato il firewall, come spiegato precedentemente.
Il server web usa la porta 80 (anche qui, a meno di configurazioni personalizzate), quindi consentiamo tutto il traffico che dall’esterno chiede di entrare attraverso la nostra porta 80:
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
Il programma di filesharing aMule deve accettare connessioni in entrata per poter funzionare al meglio. Per impostazione predefinita usa le porte 4662(con protocollo tcp) e 4672(con protocollo udp), quindi le seguenti regole indicano al firewall di accettare il traffico in ingresso su quelle due porte:
sudo iptables -A INPUT -p tcp --dport 4662 -j ACCEPT sudo iptables -A INPUT -p udp --dport 4672 -j ACCEPT
Insomma, il meccanismo dovrebbe essere chiaro.
Abbiamo così ottenuto un piccolo firewall che lascia uscire tutti i dati dal nostro computer verso l’esterno, e lascia entrare tutti i dati che abbiamo richiesto:
sudo iptables -vv -L
Chain INPUT (policy DROP)
pkts bytes target prot opt in out source destination
0 0 ACCEPT all -- lo any anywhere anywhere
0 0 ACCEPT all -- any any anywhere anywhere state RELATED,ESTABLISHED
0 0 ACCEPT tcp -- any any anywhere anywhere tcp dpt:ssh
0 0 ACCEPT tcp -- any any anywhere anywhere tcp dpt:www
Chain FORWARD (policy DROP)
pkts bytes target prot opt in out source destination
Chain OUTPUT (policy ACCEPT)
pkts bytes target prot opt in out source destination
Buona parte degli utenti che arrivano da Windows sono abituati a dare per scontato l’utilizzo del firewall sul proprio sistema operativo, dove lo si usa indiscriminatamente per “barricare” il sistema e poi consentire via via l’accesso alla rete ai programmi che si vogliono utilizzare. Questo perché c’è sempre la paura che alcuni servizi si attivino all’insaputa dell’utente e facciano in modo che il proprio pc e i suoi dati sensibili possano essere esposti alla rete.
Nei sistemi GNU/Linux il firewall ritorna ad essere lo strumento da utilizzare nel caso l’utente decida d’installare programmi per mettere a disposizione servizi dal suo pc verso altri pc con regole ben precise. Per l’utilizzo desktop così come lo troviamo per predefinito su Ubuntu, escludendo alcuni casi specifici, si può affermare che il firewall praticamente non serva.
In questa guida vengono approfonditi in modo discorsivo alcuni aspetti tecnici, in modo che anche chi non ha profonde conoscenze tecniche possa comprendere la logica di base che porta ad una così grande differenza fra i due sistemi a proposito di sicurezza di rete.
Le principali vie del traffico di rete sono in entrata e uscita. Più nello specifico il traffico è costituito da:
Quello che spesso risulta essere poco chiaro è la differenza fra questi due tipi di connessione.
Per chiarire queste differenze è vivamente consigliata la lettura della guida sulle connessioni, alla fine della quale saranno chiari i concetti di connessioni di INPUT, OUTPUT e FORWARD, fondamentali per capire quale è il compito di un firewall all’interno di una rete.
Gli applicativi installati in modo predefinito nella versione Desktop di Ubuntu sono pensati essenzialmente per consentire di uscire su internet alla ricerca di informazioni, file o quant’altro, piuttosto che per accettare connessioni in entrata dall’esterno.
I programmi che accettano connessioni dall’esterno sono detti server. Questa categoria comprende per fare alcuni esempi i server web che ospitano le pagine HTML, oppure i server ssh o telnet, i quali consentono l’apertura di una shell su di un pc remoto.
Nella versione Desktop di Ubuntu sono presenti alcuni server, ma volti principalmente all’utilizzo delle periferiche hardware come X (grafica video), cups (stampa), sane (scanner), ecc.., di default chiusi verso connessioni esterne.
Chiunque desideri offrire un servizio di rete ad utenti remoti deve necessariamente installare un apposito programma server sul proprio pc; questo programma si mette in ascolto su una porta, e tutte le connessioni INPUT entranti si connettono a questa porta per entrare in comunicazione con il server.
| Non è possibile connettersi da remoto ad un pc se non c’è almeno un server in ascolto su una qualsiasi porta. Per fare un esempio banale è come bussare ad una casa disabitata: nessuno verrà ad aprire. |
I server menzionati in precedenza (tipo web, ssh, telnet..) di default non vengono installati, pertanto è perfettamente inutile installare un firewall per regolamentare l’accesso a porte sulle quali nessun programma è in ascolto (come avere un poliziotto in un quartiere deserto).
Anche nel caso in cui si installi esplicitamente un programma server, come ad esempio tutti i programmi p2p è ancora inutile utilizzare un firewall allo scopo di chiudere le porte. Difatti questo avrebbe il solo scopo di impedire ai server installati di accedere alla rete e compiere il loro dovere!
Più avanti all’interno di questa guida verranno valutati i casi in cui il firewall può rendersi necessario anche su di un sistema desktop.
Solitamente gli utenti di Windows sono abituati ad utilizzare un firewall, questo sostanzialmente per due motivi:
Nel primo caso spesso il firewall integrato nella maggior parte dei router è sufficiente a bloccare il traffico in entrata.
Mentre nel secondo caso per tenere a bada le connessioni “indesiderate” in uscita, risulta più agevole l’utilizzo di un firewall installato sul sistema operativo stesso.
I vantaggi di GNU/Linux sotto questi aspetti sono piuttosto evidenti. Il sistema non effettua alcuna operazione sospetta o nascosta all’utente e proprio per la sua natura opensource (e quindi di trasparenza), eventuali comportamenti anomali sarebbero facilmente individuabili dalla comunità che lavora al suo sviluppo.
Inoltre la sua proverbiale immunità ai virus fa sì che le sue connessioni in uscita siano considerate con abbondanti margini sicure.
Molti utenti di internet si trovano già ad usufruire, anche inconsapevolmente, degli effetti di un firewall.
Ad esempio i router che la maggior parte degli utenti usano per connettersi tramite una connessione ADSL, integrano nella maggior parte dei modelli un firewall (in genere basato su Iptables, incluso nelle distribuzioni Linux-embedded contenute nella maggior parte dei router).
In genere di default i firewall dei router bloccano tutte le connessioni in entrata ma permettono quelle in uscita, pertanto interferiscono solo con il funzionamento dei programmi server. La maggior parte degli utenti si rende conto di essere dietro ad un firewall quando prova ad usare programmi p2p (come ad esempio Amule) e scopre che non funzionano correttamente, oppure vanno a rilento.
Il firewall incluso in questi dispositivi ha effetto su tutti i pc che vi si connettono, pertanto a meno che non ci sia la necessità di configurazioni particolari, risulta inutile configurare un firewall diverso su ciascun dispositivo. Oltre che ridondante come soluzione vi è il rischio di eccessive complicazioni.
Innanzitutto occorre ricordare che il firewall, ancor prima che un vero e proprio dispositivo di sicurezza (tipo gli antivirus, antispyware…), è uno strumento per regolare il traffico di rete.
Il suo utilizzo può entrare in gioco quando dalla propria macchina c’è la necessita di mettere “qualcosa” a disposizione di altri pc e a seconda dei casi quando occorrono delle regole ben precise sul “come” regolare il relativo traffico di rete.
In definitiva i casi in cui anche in ambiente desktop si arrivi ad utilizzare il firewall possono sussistere. È comunque evidente come la casistica sia piuttosto ristretta.
AppArmor è una implementazione del Linux Security Module di controlli d’accesso basati sul nome. AppArmor confina i singoli programmi a un gruppo di file selezionati e capacità POSIX 1003.1e draft.
In Ubuntu 8.04 «Hardy Heron» e successive, AppArmor è installato e caricato in modo predefinito. Alcuni pacchetti installano dei profili propri, ma profili aggiuntivi possono essere trovati nel pacchetto apparmor-profiles presente nel componente universe.
Tutti i comandi debbono essere eseguiti in un terminale.
sudo apparmor_status
sudo aa-complain /percorso/al/binario
Esempio:
sudo aa-complain /bin/ping
| Nella modalità apprendimento (in originale complain) vengono rilevate le violazioni alle regole dei profili di AppArmor (per esempio il programma profilato accede a file non permessi dal profilo). Tali violazioni sono permesse, ma anche registrate. Questa modalità è conveniente per lo sviluppo di profili ed è usata dagli strumenti di AppArmor per la generazione dei profili (dalla documentazione su novell.com). |
sudo aa-complain /etc/apparmor.d/*
sudo aa-enforce /percorso/al/binario
Esempio:
sudo aa-enforce /bin/ping
| Il caricamento di un profilo nella modalità di esecuzione (enforcment) fa sì che sia rispettata la politica definita nel profilo e allo stesso tempo segnalata a syslogd ogni tentata violazione (dalla documentazione su novell.com). |
sudo aa-enforce /etc/apparmor.d/*
sudo /etc/init.d/apparmor kill sudo update-rc.d -f apparmor remove
sudo /etc/init.d/apparmor start sudo update-rc.d apparmor start 37 S .
sudo /etc/init.d/apparmor reload
cat /etc/apparmor.d/nome.profilo | sudo apparmor_parser -r
Esempio:
cat /etc/apparmor.d/bin.ping | sudo apparmor_parser -r
ln -s /etc/apparmor.d/nome.profilo /etc/apparmor.d/disable/ apparmor_parser -R /etc/apparmor.d/nome.profilo
Esempio:
ln -s /etc/apparmor.d/bin.ping /etc/apparmor.d/disable/ apparmor_parser -R /etc/apparmor.d/bin.ping
In modo predefinito, i profili sono abilitati (cioè caricati all’interno del kernel e applicati ai processi).
rm /etc/apparmor.d/disable/nome.profilo cat /etc/apparmor.d/nome.profilo | sudo apparmor_parser -a
Esempio:
rm /etc/apparmor.d/disable/bin.ping cat /etc/apparmor.d/bin.ping | sudo apparmor_parser -a
I profili possono essere trovati in /etc/apparmor.d/.
Alcune personalizzazioni possono essere compiute in /etc/apparmor.d/tunables/.
La posizione delle directory home può essere regolata in /etc/apparmor.d/tunables/home.
Riavviare i processi elencati. Anche eseguire un riavvio di sistema corregge il problema.
AppArmor può tenere traccia e proteggere solo i processi che sono avviato dopo che il modulo kernel è stato caricato. Dopo l’installazione dei pacchetti apparmor, AppArmor viene avviato. I processi già in esecuzione però non vengono protetti da AppArmor. Sia riavviare il processo che l’intero sistema corregge il problema.
È anche possibile applicare un profilo a un processo già in esecuzione attraverso il seguente comando:
sudo sh -c "echo 'setprofile /percorso/al/binario' > /proc/pid/attr/current"
Provare a pensare a come è possibile mettere sotto tortura l’applicazione. Il piano di test dovrebbe essere diviso in casi di test più piccoli. Ciascun caso di test dovrebbe avere una piccola descrizione ed elencare i passi da seguire.
Alcuni casi di test standard sono:
Usare aa-genprof per generare un nuovo profilo.
Da un terminale, usare il comando aa-genprof:
sudo aa-genprof eseguibile
Esempio:
sudo aa-genprof slapd
Maggiori informazioni sono disponibili nella pagina di manuale:
man aa-genprof
Per fare in modo che il proprio nuovo profilo sia incluso nel pacchetto apparmor-profiles, aprire in Launchpad un bug per il pacchetto AppArmor:
Quando il programma non si comporta in modo corretto, vengono inviati dei messaggi di audit ai file di registro. È possibile usare il programma aa-logprof per scansionare i file di registro in cerca dei messaggi di AppArmor, revisionare tali messaggi e aggiornare i profili:
sudo aa-logprof
Maggiori informazioni sono disponibili nella pagina di manuale:
man aa-logprof
Sebbene Ubuntu sia fornito sicuro e pronto da usare, molte persone hanno la necessità di offrire servizi sui loro computer, come per esempio mettere in esecuzione un server FTP o Apache. Lo scopo di questa pagina è di rendere note agli utenti alcune impostazioni che dovrebbero essere modificate.
In modo predefinito, /dev/shm è montato in lettura/scrittura. Recentemente è emerso in diverse mailing list che trattano di sicurezza, che /dev/shm potrebbe essere usato in un attacco rivolto contro un servizio in esecuzione come httpd. Inoltre non vi è alcun motivo per montarlo in lettura/scrittura. Per cambiare questa impostazione, modificare il file /etc/fstab in modo da includere la riga seguente:
tmpfs /dev/shm tmpfs defaults,ro 0 0
Le modifiche avranno effetto al successivo riavvio, a meno che non si rimonti manualmente /dev/shm.
Questo non è un problema grave, visto che persino OpenBSD viene fornito permettendo il login come root (sebbene la documentazione suggerisca di rimuoverlo) e che Ubuntu non viene fornito con root abilitato in modo predefinito. Comunque, in diversi ambienti è procedura standard creare un account root, anche se mai usato. Se viene creato un account root e si sta usando sshd, modificare il file /etc/ssh/sshd_config e sostituire la seguente riga:
PermitRootLogin yes
con:
PermitRootLogin no
Affinché la modifica abbia effetto è necessario riavviare il server OpenSSH, operazione che può essere effettuata eseguendo da terminale:
sudo /etc/init.d/ssh restart
Questo non è un problema di per sé, ma se sono presenti nel sistema degli account con password deboli, allora utenti non-amministratore malevoli (o software malevoli che questi possono usare) potrebbero usare su per guadagnare l’accesso a tali account. Per negare agli utenti non-amministratori l’accesso a su, digitare quanto segue in un terminale:
sudo chown root:admin /bin/su sudo chmod 04750 /bin/su