Petar Karan

Fail2Ban creare jail personalizzato (esempio con portale in PHP)

Obiettivo: realizzare una jail personalizzata per Fail2Ban su Ubuntu, per banner gli IP che tentano più di 3 accessi errati su un nostro portale in PHP

Fail2Ban funziona sotto linux e permette di banner mediante il firewall elenchi di indirizzi IP, basandosi sui log dei programmi a cui si vuole applicare.

Vediamo anzitutto come installarlo (per una guida dettagliata rimando alla guida ufficiale, oppure a questa guida qua).

Dal terminale digitiamo:

sudo apt-get update && sudo apt-get install fail2ban

1	sudo apt-get update && sudo apt-get install fail2ban

Ricordo che il connettore && concatena due comandi successivi (per esempio A && B), per cui se il comando A ha successo, allora viene eseguito il comando B.

Una volta installato modifichiamo il file jail.conf digitando sempre sul terminale:

sudo nano /etc/fail2ban/jail.conf

1	sudo nano /etc/fail2ban/jail.conf

Da qui possiamo fare una prima configurazione modificando i seguenti parametri (non si trovano in questo ordine):

ignoreip = 127.0.0.1/8
bantime = 600
findtime = 600 
maxretry = 3

1

2

3

4

ignoreip = 127.0.0.1/8

bantime = 600

findtime = 600

maxretry = 3

Questo significa che verranno ignorati gli IP interni della macchina, che il tempo di ban sarà di 600 secondi (10 minuti), per ogni 3 errori riscontrati nell’arco di 600 secondi.

Per esempio se volessimo abilitare il controllo degli accessi sul SSH allora cerchiamo la jail relativa e impostiamo true ad enabled.

Adesso creiamo il nostro meccanismo di ban personalizzato.

Per farlo, e testarlo, creiamo anzitutto un file apposito in PHP sotto apache. Da terminale digitiamo:

cd /var/www/html
sudo nano test.php

1 2	cd /var/www/html sudo nano test.php

A questo punto scriviamo nel file PHP il codice necessario per registrare un errore in un file log.

<?php

function logError( $msg ) {
	
	if(!isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {
		$client_ip = $_SERVER['REMOTE_ADDR'];
	} else {
		$client_ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
	}
	
	error_log("[" . $_SERVER['HTTP_HOST'] . "]" . $client_ip . " - " . date("c") . " - " . $msg . "\n",3,"/var/log/paginatest.log");
	
}

if( $_POST["errore"] ) {
	
	logError("LoginError");
	
}

?>
<form action="" method="post">
	<input type="submit" name="errore" value="invia" />
</form>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

<?php

function logError( $msg ) {

if(!isset($_SERVER['HTTP_X_FORWARDED_FOR'])) {

$client_ip = $_SERVER['REMOTE_ADDR'];

} else {

$client_ip = $_SERVER['HTTP_X_FORWARDED_FOR'];

}

error_log("[" . $_SERVER['HTTP_HOST'] . "]" . $client_ip . " - " . date("c") . " - " . $msg . "\n",3,"/var/log/paginatest.log");

}

if( $_POST["errore"] ) {

logError("LoginError");

}

?>

</form>

Faccio notare che questo genererà una pagina con un pulsante che ad ogni pressione registrerà un “LoginError” nel file in /var/log/paginatest.log.

Quello che è importante, di tutto lo script, è il modo in cui viene scritto il file di log degli errori con error_log.

Fatto questo creiamo il file log vuoto e diamo i permessi a www-data per poterlo modificare dal PHP. Senza questa modifica il file non risulterà modificabile dal PHP.

sudo nano/var/log/paginatest.log
sudo chown www-data:www-data /var/log/paginatest.log

1 2	sudo nano/var/log/paginatest.log sudo chown www-data:www-data /var/log/paginatest.log

Adesso creiamo il nostro filtro personalizzato dentro per Fail2Ban. Dal terminale digitiamo:

cd /etc/fail2ban/filter.d
sudo nano paginatest.conf

1 2	cd /etc/fail2ban/filter.d sudo nano paginatest.conf

Dentro il file paginatest.conf, aperto con nano, inseriamo le seguenti righe di codice:

[INCLUDES]
[Definition]
failregex = <HOST> .*LoginError.*$
ignoreregex =

1

2

3

4

[INCLUDES]

[Definition]

failregex = <HOST> .*LoginError.*$

ignoreregex =

Salviamo il file. Faccio notare che si userà il riconoscimento di stringa sulle righe contenenti “LoginError” il $msg del file PHP che abbiamo creato in precedenza.

Di nuovo dal terminale digitiamo:

sudo nano /etc/fail2ban/jail.conf

1	sudo nano /etc/fail2ban/jail.conf

A questo punto ci spostiamo in fondo al file, dove si trovano le altre jail ed inseriamo il seguente codice:

[paginatest]

enabled	 = true
port	 = http,https
filter 	 = paginatest
logpath  = /var/log/paginatest.log
maxretry = 3

1

2

3

4

5

6

7

[paginatest]

enabled = true

port = http,https

filter = paginatest

logpath = /var/log/paginatest.log

maxretry = 3

In questo modo impostiamo il ban su tutte le connessioni HTTP e HTTPS alla data pagina, leggendo il file log che abbiamo creato, con un massimo numero di tentativi uguale a 3.

Facciamo ripartire Fail2Ban:

sudo service fail2ban restart

1	sudo service fail2ban restart

Immaginiamo di testare adesso il nostro programma da un altro computer della rete, per esempio un computer all’indirizzo IP 192.168.0.19

Dopo 3 tentativi di errore dovremmo poter verificare qualcosa di simile:

Faccio notare che per visualizzare tutti gli IP bannati è sufficiente interrogare iptables:

sudo iptables -L -v | grep REJECT

1	sudo iptables -L -v \| grep REJECT

Se andiamo a verificare il file di log vedremo che i nostri “errori”, ovvero le pressioni sul suddetto tasto, in questo caso, hanno generato le seguenti righe:

Per sbannare un indirizzo IP ricordiamoci di utilizzare il seguente commando:

sudo fail2ban-client set paginatest unbanip 192.168.0.19

1	sudo fail2ban-client set paginatest unbanip 192.168.0.19

In questo caso rimuoviamo dalla blacklist l’indirizzo 192.168.0.19

Operazioni elementari sui file con Bash

Anzitutto vediamo come creare una serie di file vuoti in bash, utilizzando il commando touch.

#!/bin/bash

for n in $( seq 1 10 ); do
	touch "./elemento$n.txt"
done

1

2

3

4

5

#!/bin/bash

for n in $( seq 1 10 ); do

touch "./elemento$n.txt"

done

Adesso proviamo a rinominare i file creati (cambiando l’estensione da *.txt a *.log), tenendo a mente i seguenti modificatori fondamentali:

#: sottrae dall’inizio della stringa (minimale)

%: sottrae dalla fine della stringa (minimale)

/ : sostituisce una sottostringa con un altra (solo la prima volta che viene incontrata)

#!/bin/bash

for f in ./*.txt; do
	mv "$f" "${f/%txt/log}";
done

1

2

3

4

5

#!/bin/bash

for f in ./*.txt; do

mv "$f" "${f/%txt/log}";

done

Infine mettiamo insieme il tutto in un piccolo eseguibile che, una volta richiamato, permette di modificare l’estensione di tutti i file da ext1 a ext2.

#!/bin/bash

rinomina() {

	for f in ./*.$1; do
		mv "$f" "${f/%$1/$2}"
	done

}

if [ $# -eq 2 ]
	rinomina $1 $2
else
	echo "Usage: $0 [ext1] [ext2]"
fi

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

#!/bin/bash

rinomina() {

for f in ./*.$1; do

mv "$f" "${f/%$1/$2}"

done

}

if [ $# -eq 2 ]

rinomina $1 $2

else

echo "Usage: $0 [ext1] [ext2]"

fi

Il programma in questione accetta come argomento le due estensioni da modificare, qualora non vengano forniti esattamente due argomenti segnala all’utente l’utilizzo corretto. Dopodiché passa in rassegna, nella sua cartella di appartenenza tutto i file con estensione ext1 e li modifica all’estensione ext2.

Bash, dimensione cartella in bytes

Questa volta proviamo un esercizio un poco più complesso sempre con bash e calcoliamo la dimensione totale dei file in una cartella.

#!/bin/bash

elenca() {

	if [ $# -eq 0 ]
	then
		cartella="."
	else
		cartella=$1
	fi

	totale=0
	ls -l $cartella | (while read permessi pos utente gruppo dim riga; do
		totale=$((totale + dim))
	done

	echo "$totale bytes")

}

elenca $1

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

#!/bin/bash

elenca() {

if [ $# -eq 0 ]

then

cartella="."

else

cartella=$1

fi

totale=0

ls -l $cartella | (while read permessi pos utente gruppo dim riga; do

totale=$((totale + dim))

done

echo "$totale bytes")

}

elenca $1

Questa è un’occasione per notare alcune caratteristiche:

dopo la dichiarazione del ciclo while e prima del punto e virgola, è possibile specificare un elenco di parametri nei quali verrà suddivisa la stringa per ogni riga del precedente risultato
il termine $# fa riferimento al numero di parametri presenti nell’argomento al programma (il parametro 0 è il nome del programma stesso)
il termine $1 prende il primo parametro dell’argomento, successivo al termine 0-esimo riferito al nome del programma stesso

L’utilizzo del programma avviene in questo modo:

Elenco file in bash con ciclo for

Vediamo come elencare i file con altri due esempi, anzitutto prendendo il commando ls:

#!/bin/bash

elenca() {

	for file in `ls`
	do
		echo "File: $file"
	done

}

elenca

1

2

3

4

5

6

7

8

9

10

11

12

#!/bin/bash

elenca() {

for file in `ls`

do

echo "File: $file"

done

}

elenca

E poi con piccola variazione, questa volta eseguiamo il commando all’interno di $( )

#!/bin/bash

elenca() {

	for file in $( ls -l ); do
		echo "File: $file"
	done

}

elenca

1

2

3

4

5

6

7

8

9

10

11

#!/bin/bash

elenca() {

for file in $( ls -l ); do

echo "File: $file"

done

}

elenca

Bash, ciclo for con sequenza

Altro esempio di ciclo for con sequenza in bash.

#!/bin/bash

elenca() {

        for n in $( seq 1 10 ); do
                echo "N: $n"
        done

}

elenca

1

2

3

4

5

6

7

8

9

10

11

#!/bin/bash

elenca() {

for n in $( seq 1 10 ); do

echo "N: $n"

done

}

elenca

Il risultato è così:

Ciclo for elementare in Bash

Prosegue la rubrica delle lezioni banali di Bash.

Proviamo adesso ad inserire un elementare ciclo for che stampi dei numeri a video.

#!/bin/bash

elenca() {

        for n in 1 2 3 4 5
        do
                echo "Numero $n di 5"
        done

}

elenca

1

2

3

4

5

6

7

8

9

10

11

12

#!/bin/bash

elenca() {

for n in 1 2 3 4 5

do

echo "Numero $n di 5"

done

}

elenca

Il risultato dovrebbe essere analogo a questo qua:

Come scrivere i programmi in bash, ovvero “Ciao, Mondo!” in bash

Con l’occasione di un corso di Linux che sto tenendo, ho deciso di pubblicare un po’ di esercizi e spunti per tutti quelli che fossero interessati ad avvicinarsi al bellissimo mondo di bash.

Cominciamo con il nostro primo programma in assoluto: ciaomondo.sh

NB: l’estensione *.sh non è obbligatoria

Creiamo un file chiamato ciamondo.sh digitando da terminale

sudo nano ciaomondo.sh

1	sudo nano ciaomondo.sh

A questo punto ci troviamo dentro l’editor NANO, per salvare utilizziamo CTRL+O, per uscire CTRL+X.

Inseriamo il seguente codice:

#!/bin/bash

ciao(){

        echo "Ciao, Mondo!"

}

ciao

1

2

3

4

5

6

7

8

9

#!/bin/bash

ciao(){

echo "Ciao, Mondo!"

}

ciao

Ciao è una funzione, o metodo, che non va altro che stampare a schermo, mediante echo la stringa “Ciao, Mondo!”.

Perché possa funzionare richiamiamo la funzione dopo averla dichiarata.

Salviamo e torniamo nella cartella dove abbiamo creato il file.

Rendiamo il file eseguibile con:

sudo chmod a+x ciaomondo.sh

1	sudo chmod a+x ciaomondo.sh

E poi testiamolo:

 ./ciaomondo.sh

1	./ciaomondo.sh

Leggere il filesystem OS Journaled (HFS) del Mac su un computer Windows

Soluzione: usare il programma HFSExplorer scaricabile da qui

Per leggere il contenuto di un disco o una chiavetta formattati con il filesystem proprietario del Mac, è sufficiente utilizzare un qualche programma come HFSExplorer, che permette di leggere HFS (Mac OS Standard), HFS+ (Mac OS Extended) e HFSX (Mac OS Extended con case sensitive).

Il programmino gira su Java, che quindi è eventualmente necessario installare sul proprio computer.