R0ket Keyboard sniffer: Difference between revisions

From
Jump to navigation Jump to search
Line 25: Line 25:
...
...
==Nützliche Funktionen um auf den Funkchip zuzugreifen==
==Nützliche Funktionen um auf den Funkchip zuzugreifen==
Um die Pakete aus dem Chip auszuleden, kann man die Funktion nrf_rcv_pkt_time_encr() von der r0ket firmware benutzen. Allerdings, da ja wichitg ist CRC auszuschalten, muss diese angepasst werden:
...

(Problem: diese müssen teilweise verändert werden. u.a. wegen CRC)
<syntaxhighlight lang="c">
uint8_t readPkt(uint16_t maxtime, uint8_t maxsize, uint8_t * pkt){
uint8_t len;
uint8_t status=0;
uint16_t cmpcrc;

nrf_write_reg(R_CONFIG,
R_CONFIG_PRIM_RX| // receive mode
R_CONFIG_PWR_UP // power on
);

nrf_cmd(C_FLUSH_RX);
nrf_write_reg(R_STATUS,0);

CE_HIGH();

for(uint8_t i = 0; i < maxsize; i++) pkt[i] = 0x00; // clear packet buffer

#define LOOPY 10
for (;maxtime >= LOOPY;maxtime-=LOOPY){
delayms(LOOPY);
status =nrf_cmd_status(C_NOP);
if( (status & R_STATUS_RX_DR) == R_STATUS_RX_DR){
if( (status & R_STATUS_RX_P_NO) == R_STATUS_RX_FIFO_EMPTY){
nrf_cmd(C_FLUSH_RX);
delayms(1);
nrf_write_reg(R_STATUS,0);
continue;
} else { // get/check packet
nrf_read_long(C_R_RX_PL_WID,1,&len);
if(len>32 || len==0){
continue;
return -2; // no packet error
};

nrf_read_pkt(len,pkt);

cmpcrc=crc16(pkt,len-2);
if(cmpcrc != (pkt[len-2] <<8 | pkt[len-1])) {
continue;
return -3; // CRC failed
};
break;
};
};
};

CE_LOW();
CS_HIGH();

if(maxtime<LOOPY)
return 0; // timeout

return len;
};
</syntaxhighlight>


=Theoretisches zum Finden der MAC-Adresse des Keyboards=
=Theoretisches zum Finden der MAC-Adresse des Keyboards=

Revision as of 04:28, 23 September 2011

Einleitung

Die R0ket wurde als Badge auf dem Chaos Communication Camp 2011 verteilt. Sie beinhaltet unter anderem einen Nordic VLSI nRF24L01+ chip, welcher im 2,4 GHz Spektrum funkt. Derselbe Chip wird in vielen Funklösungen verwendet, z.B. in Funkkeyboards von Microsoft oder in TurningPoint ResponseCard RF ("Clicker"). Wie Max Moser und Thorsten Schröder in ihrem KeyKeriki V2.0 Projekt gezeigt haben, kann der nRF24L01+ auch zum sniffen von Datenübertragungen verwendet werden. Travis Goodspeed hat Code für das Next Hope Badge entwickelt, um das Microsoft Wireless Comfort Desktop Kit abzuhören. Dieser Code soll nun auf die R0ket portiert werden.

Vorraussetzungen

Es wird folgende Hard- und Software benötigt:

  1. R0ket
  2. geeignetes MS Keyboard (mit einem nRF24L01+)
  3. ...

Vorgehensweise

Folgende Punkte sollen zum sniffen des Keyboards abgearbeitet werden:

  • Zunächst werden die Register des Chips so konfiguriert, dass überhaupt Pakete empfangen werden können. (Siehe #Theoretisches zum Finden der MAC-Adresse des Keyboards)
  • Die empfangenen Pakete enthalten auch viel Noise. Es werden zunächst die Frequenz und die Bitrate der Tastatur bestimmt und solche Pakete herausgefiltert, die tatsächlich zum Keyboard gehören. Dadurch lässt sich nun auch die MAC-Adresse des Keyboards finden.
  • Mit der gefundenen Adresse wird gezielt das Keyboard ausgehorcht. Die Pakete müssen noch entschlüsselt werden.

Aktueller Stand

  • Eigene Programme können auf die R0ket geladen werden.
  • Register des Chips wurden konfiguriert, um einen Empfang zu ermöglichen.
  • Die R0cket zeigt an, dass sie Pakete empfängt. Diese können wir nun auch auslesen.
  • Momentan sind wir dabei, die Pakete auf mögliche MAC-Adressen zu untersuchen, bzw. die Frequenz und die Bitrate der Tastatur herauszufinden.

Programmierung der R0cket

Code auf die R0cket laden

...

Nützliche Funktionen um auf den Funkchip zuzugreifen

Um die Pakete aus dem Chip auszuleden, kann man die Funktion nrf_rcv_pkt_time_encr() von der r0ket firmware benutzen. Allerdings, da ja wichitg ist CRC auszuschalten, muss diese angepasst werden:

uint8_t readPkt(uint16_t maxtime, uint8_t maxsize, uint8_t * pkt){
    uint8_t len;
    uint8_t status=0;
    uint16_t cmpcrc;

    nrf_write_reg(R_CONFIG,
            R_CONFIG_PRIM_RX|					// receive mode
            R_CONFIG_PWR_UP						// power on
            );

    nrf_cmd(C_FLUSH_RX);
    nrf_write_reg(R_STATUS,0);

    CE_HIGH();

    for(uint8_t i = 0; i < maxsize; i++) pkt[i] = 0x00;	// clear packet buffer

    #define LOOPY 10
    for (;maxtime >= LOOPY;maxtime-=LOOPY){
        delayms(LOOPY);
        status =nrf_cmd_status(C_NOP);
        if( (status & R_STATUS_RX_DR) == R_STATUS_RX_DR){
            if( (status & R_STATUS_RX_P_NO) == R_STATUS_RX_FIFO_EMPTY){
                nrf_cmd(C_FLUSH_RX);
                delayms(1);
                nrf_write_reg(R_STATUS,0);
                continue;
            } else {							// get/check packet
                nrf_read_long(C_R_RX_PL_WID,1,&len);
                if(len>32 || len==0){
                    continue;
                    return -2;					// no packet error
                };

                nrf_read_pkt(len,pkt);

                cmpcrc=crc16(pkt,len-2);
                if(cmpcrc != (pkt[len-2] <<8 | pkt[len-1])) {
                    continue;
                    return -3;					// CRC failed
                };
                break;
            };
        };
    };

    CE_LOW();
    CS_HIGH();

    if(maxtime<LOOPY)
        return 0;								// timeout

    return len;
};

Theoretisches zum Finden der MAC-Adresse des Keyboards

Aufbau der Datenpakete

Die gesendeten Pakete beginnen normalerweise mit einer Preambel, gefolgt von ein SYNC-field. Die Preambel ist dabei entweder AA oder EE (sich abwechselnde 0en und 1en), je nachdem, ob das erste bit des SYNC-field 1 oder 0 ist. Die Preambel zeigt an, dass ein Paket beginnt. Das SYNC-field dient dazu, den Rest des Paketes bitweise zu synchronisieren. Bei den nRF24L01+ chips dient die MAC-Adresse als SYNC-field, ist also von Gerät zu Gerät unterschiedlich. Zusätzlich erlaubt der Chip keine MAC-Adressen, die kürzer als 3 Byte sind, was im Folgenden umgangen werden soll.

Ausnutzen der Preambel

Der Trick von Travis Goodspeed nutzt um Pakete empfangen zu können, die den SYNC-Teil als Payload enthalten, ein paar unzulässige Registereinstelungen und Hintergrundnoise aus. Es wird wie folgt vorgegangen: (1) Limitieren der MAC-Adresse auf 2 Byte (2) Ausschalten von CRC (Checksummen) (3) Setzten der MAC auf den Wert der Preambel (4) Durchsuchen des empfangenen Noise auf eine gültige MAC-Adresse

Die Idee ist, anzufangen ein Paket zu empfangen, bevor tatsächliche ein SYNC-field gesendet wurde, denn der Chip übermittelt nicht Adressen eines Paketes, sondern nur die Payload. Um die MAC-Adresse zu ermitteln, ist es aber wichtig, den SYNC-Teil auszuwerten. Hintergrundnoise enthält viele 0x00 und 0xFF Pakete und auch viele 0xAA und 0x55. Wenn nun die Adresse auf 0x00AA oder 0x0055 gesetzt wird, kann der eigentliche SYNC-Teil als Payload empfangen werden. Zum Beispiel: Gesendetes Paket: 0x550102030201BEEF, Preambel: 0x55, SYNC: 0x0102030201, Payload: 0xBEEF Empfangenes Paket: 0x5500550102030201BEEF, Preambel: 0x55, SYNC: 0x0055, Payload: 0x0102030201BEEF

Das Datenblass zum Chip enthält die nötigen Funktionen zu den Registern. #Literatur und Links

Zunächst soll die Adresse auf ein absolutes Minimum reduziert werden. Dazu wird Reg 0x03, welches für die Adresslänge zuständig ist, auf 0x00 gesetzt, obwohl dies laut Datenblatt unzulässig ist. Checksummen lassen sich im Reg 0x00 ausschalten. Die Adresse lässt sich im Register 0x0a festlegen. Dies resultiert in einer großen Menge an falschen Paketen, die aus dem Hintergrundnoise entstehen. Aus diesen müssen nun noch die tatsächlich vom Keyboard gesendeten Pakete herausfiltert werden.

MAC-Adresse finden im Datenstrom

MAC Adressen sind 3 bis 5 Byte lang. Dies lässt sich nun ausnutzen, um aus den empfangenen Paketen die häufigsten Adressen herauszufiltern. Wir beginnen damit, die Pakete zunächst nur auf die ersten 3 Byte zu untersuchen.

Probleme

Folgende Probleme traten bei der Programmierung der R0cket und dem empfangen von Paketen auf:

  • ...

Literatur und Links

KeyKeriki V2

Promiscuity is the nRF24L01+'s Duty

R0ket

Datasheet des nRF24L01+