DiGiTaL RiOt

Voci categorizzate come ‘Programmazione’

Script Bash che sorride alla connesione!

Dicembre 2, 2007 · Lascia un Commento

Ispirato da un intervento del Linux Date di Ancona ho scritto un piccolo script per testare la connessione ad internet tramite l’utilizzando Ping e cosa farmene (a parte testarci la mia connessione :D ) se non condividerlo con voi!!!

if ping -c1 www.google.com >/dev/null; then echo ":)" else echo ":(" fi;

Ho scelto di pingare google per avere la (quasi totale) certezza che il server sia attivo :D

Naturalmente basta salvarlo in un file come ad esempio test.sh ed eseguirlo nel modo seguente:

fatmatt@debian#: sh test.sh

Vi auguro di non vedere nessuna “:(” :D

Categorie: Linux · Programmazione

Pillole contro il mal di XSS

Ottobre 29, 2007 · Lascia un Commento

Continua la mia serie di mini articoli sull’argomento XSS, che, a quanto pare, incuriosisce moltissimi naviganti della rete :D (mi riferisco alle statistiche dei motori di ricerca ;) ).

xsswarning.jpg

Questo articolo non è esattamente un tutorial riguardante una tecnica di XSS, ma più che altro una raccolta di pillole di saggezza che tutti dovrebbero assimilare.

  • Controllate la presenza di tags HTML e rendeteli inoffensivi (non del tutto!) con la funzione php strip_tags()
  • Se non potete rimuovere a priori i tag html dalle query, rimpiazzateli con il corrispondente riferimento ad entità: la funzione htmlentities() sostituisce i caratteri “<” e “>” con “<” e “>”
  • Evitate di utilizzare le funzioni include() e require() passando come argomento variabili definite dall’utente, come elementi degli array $_POST $_GET $_REQUEST e $_FILE, potreste dar luogo a vulnerabilità critiche: inclusione di files di installazione del vostro CMS oppure files di configurazione di vario genere contenenti username, password ed altre informazioni importanti.

Filtrate approfonditamente le query, controllando anche la codifica ASCII ed HEX

Attenti all’utilizzo delle MAGIC QUOTES: Un tentativo da parte degli sviluppatori PHP di incrementare la sicurezza di PHP tramite il filtraggio automatico delle stringhe, aggiungendo il carattere di escape. Questa opzione non vi mette al riparo dagli attacchi di XSS e SQL Injection, poiché il controllo può in molti casi essere bypassato. Inoltre, il sistema di MAGIC QUOTES comporta alcuni problemi di portabilità del codice, che potrebbe assumere comportamenti diversi in base alla configurazione della vostra installazione di PHP.

Categorie: Hacking · Programmazione · Sicurezza · XSS · javascript · php

Directory sotto controllo con Perl

Ottobre 29, 2007 · Lascia un Commento

folder_locked.png
Navigando per CPAN, l’imponente archivio dei moduli Perl, mentre cercavo delle funzioni per smanettare con i permessi sui file, mi sono imbattuto nel modulo File::Monitor, che permette di monitorare file e directory in cerca (o in attesa) di cambiamenti di qualsiasi tipo.
Capirete che questo genere di funzionalità puà rivelarsi molto utile qualora si volesse monitorare lo stato di una directory importante a cui nessuno dovrebbe apportare modifiche, come ad esempio le directory di installazione del vostro sito internet, le directory contenenti informazioni sugli utenti che dovrebbero essere modificate solo dall’amministratore di sistema o dal sistema stesso ecc.. .
Questo modulo offre una classe principale File::Monitor, a cui assegnare diversi elementi da controllare e grazie ad un sistema di gestione degli eventi, ad ogni occorrenza di un determinato tipo di evento, potrete eseguire una specifica serie di istruzioni (contenute in subroutine).
Ecco la lista gerarchizzata dei possibili tipi di evento:

change

created

deleted

metadata

time

mtime

ctime

perms

uid

gid

mode

size

directory

files_created

files_deleted

Ogni volta che File::Monitor rileva un cambiamento in uno dei suoi “bersagli”, incapsula le informazioni a riguardo in un oggetto di tipo Delta, da cui poi possiamo estrarle con dei semplici metodi.

Ecco un semplice esempio di come monitorare una directory in modo superficiale, senza controllare nel dettaglio i cambiamenti apportati ai files, naturalmente.

Questo esempio è molto esemplificato e se voleste scrivere uno script che controlli ogni aspetto dei vostri files, dovreste aggiungere istruzioni per ogni tipo di evento.

use File::Monitor;sub getDate() {

#Funzione che restituisce la data nel formato: gg/mm/aaaa--hh-mm-ss;

 	@time = localtime();

#è necessario aggiungere 1900 perchè localtime contiene il numero di anni passati dal 1900

 	$time[5] = $time[5]+1900;

#è necessario aggiungere 1 al mese perchè localtime conta i mesi a aprtire da 0

 	$time[4] = $time[4]+1;

 	return $time[3]."/".$time[4]."/".$time[5]."--".$time[2].":".$time[1].":".$time[0];

}

sub DIRchanged() {

#Ecco cosa facciamo quando la directory cambia

                open(FH,">>/tmp/dirMonitor.log") || die "ERRORE!!\t Impossibile aprire il log!!\n";

 	print "Data: ".&getDate()."\t";

 	print "ATTENZIONE!! La directory $DIR ha subito delle modifiche!!\n";

 	print FH "Data: ".&getDate()."\t";

 	print FH "ATTENZIONE!! La directory $DIR ha subito delle modifiche!!\n";

 	close(FH);

            }

#Oggetto fondamentale

my $monitor = File::Monitor->new();

#Prendiamo la directory da controllare, che è passata argomento

unless (-d $ARGV[0]) { die("ERRORE:\t La directory da monitorare specificata, non esiste!!\n\n")

$DIR = $ARGV[0];

$monitor->watch( {

        name        => $DIR,

        recurse     => 1,

        files       => 0

    } );

#Il primo scan on rileva cambiamenti ma raccoglie le informazioni sui files

$monitor->scan();

#Per ogni cambiamento, esegue i controlli che vogliamo

foreach my $change ($monitor->scan()) {

if ($change->is_event('changed')) {

&DIRchanged();

}

}

Per prima cosa ho incluso la libreria Monitor, poi ho definito due subroutine:
getDate(): formatta la data corrente in modo approfondito fino ai secondi
DIRchanged(): risponde all’evento changed modificando un file di log ed emettendo il segnale di allarme allo Standard Output

Creo l’oggetto monitor, e poi controllo che esista la directory da controllare passata come argomento da riga di comando, altrimenti termina con un messaggio di errore.

Il metodo watch(), assegna la directory da controllare e setta i flag che ne definiscono il comportamento:
recurse: Se settato a true e il flag base è una directory, scansiona ricorsivamente tutto l’albero directory sottostante alla directory specificata
files: Se settato a true e il flag base è una directory, scansiona tutti i file e directory sottostanti alla directory specificata, ma non ricorsivamente

In questo modo però solamente i nomi dei files e delle directory vengono controllati, per approfondire il controllo dobbiamo lavorare con i Delta Objects.

A questo punto, lanciamo il primo scan, che non rileva cambiamenti dei files in quanto stiamo facendo il primo controllo ed il monitor non ha ancora nessuna informazione a riguardo, ma si tratta della fase di acquisizione delle informazioni su di essi.

Tutti gli scan successivi restituiscono un oggetto di tipo Delta, su cui effettueremo i nostri test.

Categorie: File::Monitor · Programmazione · Sicurezza · perl

Perl ed il modulo Term::ReadLine

Ottobre 25, 2007 · Lascia un Commento

Vi siete mai chiesti come implementare un prompt dei comandi per le vostre applicazioni? Perl vi fornisce un modulo perfetto allo scopo, che in poche righe di codice (12 nel caso del nostro esempio) vi permette di configurare un terminale con tanto di storico dei comandi inseriti.
Buttiamoci subito nell’ analisi del codice:

##############Config########################
 my $PROMPTSTRING = '%PSH% >>>';
 my $PROMPTNAME = 'term';
 ##############Main########################
 use Term::ReadLine;
 my $term = new Term::ReadLine $PROMPTNAME;
 my $out = $term->OUT || \*STDOUT;
 while (defined($_ = $term->readline($PROMPTSTRING))) {
  my $result = eval($_);
  warn $@ if $@;
  chop($result);
  print $result, "\n" unless $@;
  $term->addhistory($_) if /\s/;
}

Le prime due istruzioni, impostano il messaggio che visualizzeremo nel prompt ed il nome del terminale, mentre la terza include il modulo perl che fornisce tutte le subroutines necessarie (si trova facilmente il deb nei repository Debian), non c’è bisogno che vi ricordi che senza quel modulo non funziona una mazza vero?.

Dopo l’inclusione del modulo inizia la parte interessante:
Creiamo l’oggetto Term::ReadLine ed impostiamo come output, la variabile $out, che conterrà l’output del prompt stesso e quello emesso dallo standard output.

Il ciclo while tiene vivo il terminale, salvando il comando immesso dall’utente nella variabile $_; quindi ad ogni ciclo, viene valutata la stringa $_ come se fosse una istruzione perl e viene eseguita come sottoprogramma (tutto questo grazie alla funzione eval() ).
Infine visualizziamo l’output oppure gli eventuali messaggi di errore per poi aggiungere il nostro comando alla history.

Per maggiori informazioni vi rimando a:

Categorie: Programmazione · Term::ReadLine · perl

Prima release seria per eMule Log Checker

Ottobre 7, 2007 · 1 Commento

elalogo.png

Ho terminato la prima release seria di emule Log Checker (o Analyzer non fa differenza XD), in cui ho implementato alcune opzioni da riga di comando , l’opzione di help ed un mitico File README!!! :D

È disponibile un archivio zip contenente lo script e la documentazione, basta cliccare sul link download

P.S. In caso decidiate di scaricare il file, vi sarei davvero grato se lasciaste un commento all’articolo di presentazione presente al sito bubbledev.altervista.org, giusto per rendermi conto del numero di downloads e per ricevere feedback da voi (potete anche utilizzare la mail)

Categorie: Progetti · Programmazione · eMule · perl