Visto che continuo ad apportare modifiche e ad aggiungere funzioni allo script descritto nei post [1] e [2] ho deciso di dedicargli una pagina.

wscanner

wscanner è una piccola utility scritta in ruby che permette di effettuare una scansione continua delle wireless presenti calcolandone la potenza e la stabilità attraverso un algoritmo che garantisce una precisione migliore di quella che si ottiene con i normali tool di sistema.

wscanner stima con precisione la potenza del segnale e l’intervallo di ricezione dei beacon e usa questi due valori per creare uno stimatore della stabilità della linea, permette inoltre di ordinare l’output in base a uno qualunque dei campi.

[DOWNLOAD]

Screenshot

ESSID               Fortuna             MPower              MLatence            Crittografia        Channel            
Blablabl            71.6887747240122    59.0016312599182    76.1845626831055    on                  4                  
Blablablablabl      70.304306283199     58.1249465942383    120.036134719849    on                  6                  
Blablab             68.0                55                  2360                on                  11                 
Blablablablabl      60.4558893562849    48.1255178451538    116.457891464233    on                  6                  
Blablablablabl      56.1277235802154    48.069091796875     578.2275390625      on                  1                  
Blablablablabl      55.0035566766891    46.90625            584.8046875         on                  1                  
Blabl               49.863372552562     56.0                2352.6875           off                 11                 
Blablablablabl      49.4456755534296    42.646484375        802.43896484375     on                  1                  
Blablab             48.0                35                  108                 off                 6                  
Blablab             41.9536093504313    39.27734375         1526.44999694824    on                  8                  
Blablablablabl      37.3471193379942    41.310546875        2775.2587890625     on                  1                  
Blablablabl         30.7177777881897    30.75               2595.5400390625     on                  9                   

12 celle rilevate
F per ordinare per fortuna, N per ordinare per essid
C per ordinare per canale, E per ordinare per crittografia
Q per uscire

Wirelessmonitor v1.2.0 (c)Darshan 2008-2009 (thedarshan.wordpress.com)

Stima della potenza e dell’intervallo di ricezione usando la media esponenziale ponderata

Lo script usa la media esponenziale ponderata per stimare il tempo medio di ricezione dei beacon e la potenza.

La media esponenziale ponderata è descritta nell’RFC2988 ed è tipicamente usata per stimare l’RTT nelle connessioni TCP; essa può essere facilmente adattata alla stima dell’intervallo tra la ricezione dei beacon perchè i due “scenari” (nel senso americano del termine) sono molto simili.

A differenza della media aritmetica ,che assegna un peso contante ai singoli campioni, la media esponenziale ponderata assegna un peso che decresce esponenzialmente dall’ultimo campione; in questo modo i campioni recenti hanno un peso superiore rispetto ai campioni vecchi.

per calcolare la media esponenziale ponderata si fa uso di 4 variabili:A,B,MEDIA,CAMPIONE

MEDIA è il valore attuale della media
CAMPIONE è il valore dell’ultimo rilevamento
A e B sono i pesi da dare all’ultimo campione e ai campioni precedenti; tipicamente A+B=1

inizialmente MEDIA è posto uguale a CAMPIONE. il suo valore viene aggiornato secondo la formula:

Calcolo della stabilità della linea: il parametro “fortuna”

Il parametro fortuna viene calcolato in maniera empirica a partire dalla media dei beacon e dalla media delle potenze

def fortuna(p,l)
	f= (p+13) / (1.0+(l-50)/6000)
	return 100 if f>100
	return f
end

Prove empiriche mi hanno dimostrato che una rete con il parametro fortuna superiore al 50% risulta stabile

Lo script completo

#!/usr/bin/ruby
@versione="1.2.0"
@monitors=Hash.new("None")
@stato="F"

def spazia(valore,n=20)
    return valore.to_s if n @essid ,
                "fortuna" => @fortuna,
                "mpower" => @power,
                "mlatence" => @beacon,
                "beacon"=> beacon,
                "power" => power,
                "same" => same.to_i,
                "enc" => @enc,
                "chan" => @chan.to_i
                }
    end

    def compatta()
        return spazia(@map["essid"])+spazia(@map["fortuna"])+spazia(@map["mpower"])+spazia(@map["mlatence"])+spazia(@map["enc"])+spazia(@map["chan"])
    end

    def estesa()
        ora=Time.now.strftime("%I:%M:%S ")
        puts "\ec \n#{ora} #{battery()}\n"+@cella
	puts "Power    = #{@map["power"]}"
	puts "Latence  = #{@map["beacon"]}\n"
	puts "Scarto   = #{@map["same"]}%\n"
	verso="up";verso="down" if @power>@map["power"]
	puts "MPower   = #{@power} (#{verso})";
	verso="up";verso="down" if @beacon>@map["beacon"]
	puts "MLatence = #{@beacon} (#{verso})"
	puts "Fortuna  = #{@fortuna}"
	puts "Codifica = #{@map["enc"]}"

    end
end

def thread_main()
    #lista solo le celle attualmente visibili.
    #le statistiche delle celle non visibili non vengono aggiornate.
    responso= `iwlist eth1 s`
    celle=tokenize(responso)
    celle.delete(nil)
        ora=Time.now.strftime("%I:%M:%S ")
        puts "\ec#{ora} #{battery()}\n\n"
    puts spazia("ESSID")+spazia("Fortuna")+spazia("MPower")+spazia("MLatence")+spazia("Crittografia")+spazia("Channel")
    temp=Hash.new(nil)
    celle.each_key{|k|
            @monitors[k]=Monitor.new(k) if @monitors[k]=="None"
            @monitors[k].estrai(celle)
            if @stato=="F"
                temp[-@monitors[k].to_i]=@monitors[k].compatta()
            elsif @stato=="E"
                temp[@monitors[k].enc + @monitors[k].essid]=@monitors[k].compatta()
            elsif @stato=="C"
                temp[@monitors[k].chan + @monitors[k].essid]=@monitors[k].compatta()
            else
                temp[@monitors[k].essid]=@monitors[k].compatta()
            end
        }
    temp=temp.to_a.sort
    temp.each{|v| puts v[1]}
    puts "\n#{celle.size} celle rilevate"
    puts "F per ordinare per fortuna, N per ordinare per essid"
    puts "C per ordinare per canale, E per ordinare per crittografia"
    puts "Q per uscire"
    puts "\nWirelessmonitor v#{@versione} (c)Darshan 2008-2009 (thedarshan.wordpress.com)"
end

thread_main()

esecutore=Thread.new {
    while(true)
#        puts "\ec"
        thread_main()
        sleep 2
    end
}

while(cosa=readline.chomp.upcase)
	if cosa=="Q" then
		Thread.kill(esecutore)
		exit
	end
	@stato=cosa
end