Pentru desfășurarea laboratorului pornim de la arhiva de sarcini a laboratorului. Descărcăm și decomprimăm arhiva în directorul so2/ din directorul home al utilizatorului student de pe sistemul fizic:

student@eg106:~$ cd so2/
student@eg106:~/so2$ wget http://elf.cs.pub.ro/so2/res/laboratoare/lab05-tasks.zip
student@eg106:~/so2$ unzip lab05-tasks.zip
student@eg106:~/so2$ tree lab05-tasks

În cadrul directorului lab05-tasks/ se găsesc resursele necesare pentru dezvoltarea exercițiilor de mai jos: fișiere schelet de cod sursă, fișiere Makefile și Kbuild, scripturi și programe de test.

Vom dezvolta exercițiile pe sistemul fizic și apoi le vom testa pe mașina virtuală QEMU. După editarea și compilarea unui modul de kernel îl vom copia în directorul dedicat pentru mașina virtuală QEMU folosind o comandă de forma

student@eg106:~/so2$ cp /path/to/module.ko ~/so2/qemu-so2/fsimg/root/modules/

unde /path/to/module.ko este calea către fișierul obiect aferent modulului de kernel. Apoi vom porni, din directorul ~/so2/qemu-so2/, mașina virtuală QEMU folosind comanda

student@eg106:~/so2/qemu-so2$ make

După pornirea mașinii virtuale QEMU vom putea folosi comenzi în fereastra QEMU pentru a încărca și descărca modulul de kernel:

# insmod modules/module-name.ko
# rmmod module/module-name

unde module-name este numele modulului de kernel.

Găsiți definițiile următoarelor simboluri în nucleul Linux:

• structura resource;
• funcția request_region și de acolo funcția __request_region;
• funcția request_irq și de acolo funcția request_threaded_irq;
• funcția inb, varianta de pe arhitectura x86.

Urmăriți în codul nucelului Linux:

• funcția de inițializare a driver-ului de tastatură i8042_setup_kbd
• funcția de tratarea a întreruperii pentru tastatură AT sau PS/2, înregistrată cu funcția de inițializare: atkbd_interrupt

Obiectivul exercițiilor următoare este să creați un driver pentru a intercepta tastele apăsate (keylogger). Driver-ul va intercepta IRQ-ul destinat controller-ului de tastatură și va inspecta codurile tastelor primite, stocându-le într-un buffer.

Pentru început ne propunem să alocăm spații din zona I/O pentru dispozitive hardware. Vom vedea că nu putem să alocăm spațiu pentru tastatură întrucât regiunea aferentă e deja alocată. Apoi vom aloca spațiu I/O pentru portul serial.

În fișierul so2_kbd.c avem un schelet de implementare a unui driver de tastatură. Parcurgeți codul sursă din acest fișier și urmăriți funcția so2_kbd_init. Codul din cadrul funcției so2_kbd_init care alocă porturile I/O (STATUS_REG și DATA_REG, folosind request_region) este comentat pentru că ar returna o eroare.

Decomentați liniile din cadrul funcției so2_kbd_init și returnați cod de eroare la nevoie, prin:

1. atribuirea unui cod de eroare specific (de exemplu -EBUSY) variabilei err;
2. salt (goto) la label-ul corespunzător (out_unregister).

Compilați fișierul sursă so_kdb.c în modulul so2_kdb.ko folosind, pe sistemul fizic, comanda

make

și încărcați-l în nucleu, în mașina virtuală QEMU, folosind comanda

insmod so2_kbd.ko

Observați că obțineți eroare la încărcare: insmod: Can't insert '.../so2_kbd.ko': Device or resource busy. Acest lucru se întâmplă întrucât avem deja un driver care a întregistrat spațiul de I/O și kernel-ul poate deja accesa porturile I/O aferente. Ca să validăm că, într-adevăr, adresele aferente celor două registre (STATUS_REG și DATA_REG) sunt înregistrate, rulăm, în mașina virtuală QEMU comanda

cat /proc/ioports | grep keyboard

Observăm că sunt înregistate cele două porturi (0x60: DATA_REG și 0x64:STATUS_REG) corespunzătoare registrelor pentru tastatură.

Pentru a folosi cu succes alocarea de porturi I/O, alocați pentru portul serial COM1. Pentru portul serial COM1 aveți nevoie de:

• adresa de start a portului serial COM1; este vorba de 0x3F8
• numărul de registre accesibile de la adresa de mai sus; este vorba de 8 registre

Folosiți funcția request_region (în cadrul funcției so2_kbd_init) pentru a aloca porturile aferente și folosiți funcția release_region (în cadrul funcției so2_kbd_exit). Apoi compilați și inserați modulul în nucleu. Verificați conținutul fișierului /proc/ioports și verificați acum că spațiul I/O 0x3f8-0x3ff este alocat driverului nostru.

Descărcați modulul din kernel folosind comanda

rmmod so2_kdb

și verificați acum conținutul fișierului /proc/ioports; observți că a dispărut alocarea spațiului I/O pentru COM1 (0x3f8-0x3ff).

Încărcați și descărcați de mai multe ori modulul de kernel pentru a vă asigura că totul merge cum trebuie.

Pentru a verifica tratarea corectă a cazului de eroare, încărcați driverul de port serial din sistem, folosind comanda:

modprobe 8250.ko

Acum încercați din nou încărcarea modulului so2_kbd.ko. Observăm eroare la înregistrarea spațiului de I/O care este acum adjudecat de driverul de port serial. Putem valida acest lucru urmărind /proc/ioports.

Descărcați din kernel modulele pentru portul serial, verificați că spațiul I/O pentru COM1 este liber și inserați din nou modulul so2_kbd.ko. Ar trebui ca totul să funcționeze.

Urmărim să înregistrăm o rutină de tratare a întreruperii de tastatură. Veți scrie o funcție (rutină) de tratare a înteruperii și o veți înregistra folosind request_irq.

Implementarea o veți face în fișierul so2_kbd.c. Zonele din program în care trebuie să acționați au comentarii marcate cu /* TODO 2: ... */ și indicații despre ce trebuie să urmăriți.

Pentru început definiți rutina de tratare a întreruperii (numită so2_kbd_interrupt_handle) ca nefăcând nimic. Rutina trebuie să lase întreruperea să fie procesată de handler-ul inițial; în caz contrar, veți pierde controlul tastaturii în mașina virtuală.

Apoi înregistrați și deînregistrați rutina de tratare a întreruperii. Linia de întrerupere (IRQ line) este definită de macro-ul I8042_KBD_IRQ. Rutina de tratare a întreruperii trebuie înregistrată cu IRQF_SHARED, pentru a partaja linia de întrerupere cu driverul de tastatură (i8042).

Compilați modulul și încărcați-l în nucleu. Ulterior încărcării în nucleu, puteți observa înregistrarea liniei de întrerupere prin consultarea fișierului /proc/interrupts. Urmăriți linia din output aferentă IRQ line-ului pentru tastatură (definit în macro-ul I8042_KBD_IRQ). Observați că sunt două drivere înregistrate la această linie de întreruper (deci avem o linie de întrerupere partajată): driverul inițial i8042 și driverul nostru so2_kbd. Descărcați modulul din nucleu.

Afișați un mesaj în rutina de tratare a întreruperii pentru a verifica dacă este apelată. Compilați și reîncărcați modulul în nucleu. Verificați folosind dmesg că rutina de tratatre a întreruperii este apelată în momentul în care apăsați pe tastatură în mașina virtuală.

Pentru implementarea keylogger-ului vrem să colectăm tastele apăsate într-un buffer al cărui conținut să îl transmitem apoi în user space. Pentru aceasta în rutina de tratare a întreruperii veți face următoarele:

1. Veți captura tastele apăsate (doar pressed nu și released)/
2. Veți identifica tastele ce reprezintă caractere ASCII.
3. Veți copia caracterele ASCII corespunzătoare tastelor apăsate și le veți stoca în buffer-ul buf din structura de tip struct so2_device_data aferentă dispozitivului.

Implementarea o veți face în fișierul so2_kbd.c. Zonele din program în care trebuie să acționați au comentarii marcate cu /* TODO 3: ... */ și indicații despre ce trebuie să urmăriți.

La fiecare pas compilați modulul, încărcați modulul în kernel, apăsați în mașina virtuală taste pentru a verifica funcționalitatea, și apoi descărcați modulul.

Pentru început completați funcția i8042_read_data() pentru citirea registrului I8042_DATA_REG al controller-ului de tastatură. Funcția trebuie doar să returneze valoarea registrului. Valoarea registrului se mai numește scancode, este ceea ce este generat la fiecare apăsare de tastatură.

Apelați funcția i8042_read_data() în handler-ul de întrerupere so2_kbd_interrupt_handler() (adică la fiecare tastă apăsată) și afișați valoarea citită din registru.

	printk(LOG_LEVEL "IRQ: %d, scancode=0x%x (%u, %c)\n",
		irq_no, scancode, scancode, scancode);

Observați că scancode-ul (valoarea registrului citit) nu este un caracter ASCII aferent tastei apăsate. Va trebui să interepretăm scancode-ul.

Observați că valoarea registrului este un cod al tastei apăsate (se mai numește scancode), nu reprezintă valoarea ASCII a caracterului apăsat. De asemenea, este trimisă o întrerupere la apăsarea tastei și este trimisă o întrerupere la eliberarea tastei. Pentru aceasta, va trebui să selectați doar cazurile de apăsare de tastă și să decodificați tastele apăsate în caractere ASCII.

showkey -s

În handler-ul de întrerupere (so2_kbd_interrupt_handler) interpretați scancode-ul pentru a vedea dacă este o apăsare sau o ridicare de tastă și obțineți caracterul ASCII aferent. Afișați informațiile obținute.

	printk(LOG_LEVEL "IRQ %d: scancode=0x%x (%u) pressed=%d ch=%c\n",
		irq_no, scancode, scancode, pressed, ch);

Dorim să colectăm caracterele apăsate (nu și celelalte taste) într-un buffer care apoi va fi citit din user space.

Actualizați handler-ul de tratare a întreruperii (so2_kbd_interrupt_handler) astfel încât un caracter ASCII citit să fie adăugat la sfârșitul buffer-ului aferent dispozitivului. Dacă buffer-ul este plin, caracterul va fi ignorat.

	struct so2_device_data *data = (struct so2_device_data *) dev_id;

Pentru a avea acces la datele colectate de keylogger va trebui să le transmitem în user space. Facem acest lucru prin intermediului unui dispozitiv de tip caracter (/dev/so2_kbd). La citirea din acest dispozitiv de tip caracter vom primi datele din buffer-ul din kernel space în care am colectat tastele apăsate.

Implementarea o veți face în fișierul so2_kbd.c. Zonele din program în care trebuie să acționați au comentarii marcate cu /* TODO 4: ... */ în funcția so2_kbd_read() și indicații despre ce trebuie să urmăriți.

La fiecare pas compilați modulul, încărcați modulul în kernel, apăsați în mașina virtuală taste pentru a verifica funcționalitatea, și apoi descărcați modulul.

Este permis un singur cititor la un moment dat astfel încât protejăm codului funcției so2_kbd_read() cu un mutex.

Întrucât nu dorim modificări la nivelul buffer-ului din partea handler-ului de întrerupere în timp ce facem citirea sa în funcția so2_kbd_read() veți folosiți un spinlock și veți dezactiva întreruperile în funcția so2_kbd_read.

Pentru copierea în user space veți folosi apelul copy_to_user. Întrucât nu puteți folosi copy_to_user în timp ce aveți un spinlock luat, trebuie să folosiți un buffer temporar.

Pentru testare, va trebui să creați fișierul de tip caracter /dev/so2_kbd folosind utilitarul mknod cu majorul și minorul dispozitivului sunt definiți în macro-urile din so2_kbd.c: SO2_KBD_MAJOR și SO2_KBD_MINOR. Adică va trebui să rulați comanda

mknod /dev/so2_kbd c 42 0

Compilați modulul pe sistemul fizic, apoi porniți mașina virtuală și încărcați modulul în nucleul mașinii virtuale. Testați folosind comanda

cat /dev/so2_kbd

O să obțineți conținutul bufferului keylogger-ului din kernel space.

Dorim să "curățăm" buffer-ul dacă este tastată o parolă. În acel moment buffer-ul va fi resetat: conținutul său va fi resetat și dimensiunea va fi 0.

Implementarea o veți face în fișierul so2_kbd.c. În rutina de tratare a întreruperii veți reține în câmpul passcnt câte caractere din parolă au fost potrivite. Parola este definită de macro-urile MAGIC_WORD și MAGIC_WORD_LEN.

Când se detectează întreaga parolă, curătați buffer-ul. Pentru curățare, reinițializați câmpul buf_idx la valoarea 0 și umpleți cu 0-uri buffer-ul.

La primirea unui caracter nou, verificați dacă acesta corespunde cu caracterul de pe poziția curentă din parolă. În caz afirmativ, incrementați contorul; altfel, resetați counterul la 0.

Pentru testare, va trebui să creați fișierul de tip caracter /dev/so2_kbd folosind utilitarul mknod cu majorul și minorul dispozitivului sunt definiți în macro-urile din so2_kbd.c: SO2_KBD_MAJOR și SO2_KBD_MINOR. Adică va trebui să rulați comanda

mknod /dev/so2_kbd c 42 0

Compilați modulul pe sistemul fizic, apoi porniți mașina virtuală și încărcați modulul în nucleul mașinii virtuale. Consultați conținutul buffer-ului folosind comanda

cat /dev/so2_kbd

Apăsați pe taste și apoi apăsați conținutul macro-ului MAGIC_WORD (adică root) și apoi consultați din nou conținutul buffer-ului. Ar trebui să fie resetat.

Implementarea curentă este problematică pentru că rutina de tratare a întreruperii este cea care face resetarea buffer-ului, lucru care este consumator de timp și nerecomandat să fie făcut în context întrerupere.

O soluție este să actualizăm comportamentul astfel încât resetarea buffer-ului să se producă la apelul funcției so2_kbd_read(). După ce informația este copiată în user space, buffer-ul este resetat. Nu mai resetăm în momentul tastării

Simplificați implementarea în așa fel încât resetarea buffer-ului să se producă în funcția so2_kbd_read() imediat după copierea datele în user space.

Pentru verificarea după citirea din /dev/so2_kbd veți avea buffer-ul resetat. Citiri ulterioare vor găsi buffer-ul gol.

Implementați colectarea de date de la tastatură, și transmiterea lor în user space folosind API-ul kfifo.

• Soluții exerciții laborator 5