[hack] Lecteur RFID chinois – Huge success

Bonjour à tous !

This was a triumph.
I’m making a note here: HUGE SUCCESS
It’s hard to overstate my satisfaction.

~~ musique de Portal ~~

Pourquoi cet article alors que j’ai déjà parlé du lecteur RFID chinois dans l’article juste avant ?
Pourquoi je commence cet article avec une référence à Portal ?
Pourquoi *BAM* … aie

Plus sérieusement, je fais cet article pour remercier toutes les personnes qui m’ont aidé (ou qui ont essayé) à « hacker » le lecteur :
– Damien
– Guigui
– blakk-olifant
– Adrien
– Simon
– Guillaume
– et Antafuli

Sans eux je serais encore en train de chercher comment décoder les trames du lecteur …
La méthode de codage des IDs RFID était barbare, plutôt loufoque sur les bords, mais ça ne les a pas arrêtez pour autant 🙂

Et maintenant que j’ai toutes les cartes en main je vais pouvoir vous faire un résumé rapide 😉

—

La documentation du lecteur :

Elle était bien caché au fin fond d’un site de vente chinois plus ou moins recommandable mais la voici :
(j’ai fait un miroir du pdf sur mon compte dropbox par sécurité)
https://dl.dropbox.com/u/53604363/USB%20Desktop%20Reader_BlackBox%20D10.pdf

Je vous laisse la feuilleter rapidement, je repasserai sur les points importants dans la suite de l’article.

—

Est-ce que le lecteur peut lire des cartes HID / iProx ?

Le site du fabricant dit que oui, la documentation aussi …
Je n’ai pas pu tester malheureusement (je n’ai tout simplement pas de carte HID sous la main), donc pour le moment la question reste sans réponse.
Théoriquement rien n’empêche le lecteur de gérer deux protocoles RFID 125KHz différents donc pourquoi pas …

—

Est-ce que le lecteur peut aussi programmer des cartes HID / iProx / EM4100-RW ?

Toujours d’après le site du fabricant et de la documentation : oui
Est-ce que cela est vraiment possible : … je sais pas non plus !

Comme on peut le voir dans la documentation le lecteur semble ce comporter comme un port série usb (chipset CH34x).
Et une application nommée « iProxCard Programmer » s’occupe de la programmation des cartes iProx.

Mon lecteur lui ne se comporte que comme un clavier usb … ce qui me laisse vraiment penser qu’il existe deux versions différentes du même lecteur :
– une haut de gamme (lecture / écriture en mode port série usb)
– et une bas de gamme (lecture seule en mode clavier usb)

—

Mais c’est pas tout !

En y regardant de plus près avec un PC linux on remarque quelque chose de spécial concernant l’usb :
skywodd@skywodd-eeepc /dev $ tail /var/log/kern.log
Feb 5 19:27:57 skywodd-eeepc kernel: [ 434.260120] usb 2-2: >new low-speed USB device number 4 using uhci_hcd
Feb 5 19:27:58 skywodd-eeepc kernel: [ 434.506143] usb 2-2: >New USB device found, idVendor=08ff, idProduct=0009
Feb 5 19:27:58 skywodd-eeepc kernel: [ 434.506156] usb 2-2: >New USB device strings: Mfr=1, Product=1, SerialNumber=2
Feb 5 19:27:58 skywodd-eeepc kernel: [ 434.506166] usb 2-2: >Product: USB Reader With Keyboard
Feb 5 19:27:58 skywodd-eeepc kernel: [ 434.506175] usb 2-2: >Manufacturer: USB Reader With Keyboard
Feb 5 19:27:58 skywodd-eeepc kernel: [ 434.506184] usb 2-2: >SerialNumber: FM8PU83-Ver0E-0000
Feb 5 19:27:58 skywodd-eeepc kernel: [ 434.532967] input: USB Reader With Keyboard USB Reader With Keyboard as /devices/pci0000:00/0000:00:1d.0/usb2/2-2/2-2:1.0/input/input14
Feb 5 19:27:58 skywodd-eeepc kernel: [ 434.533460] hid-generic 0003:08FF:0009.0003: >input,hidraw0: USB HID v1.10 Keyboard [USB Reader With Keyboard USB Reader With Keyboard] on usb-0000:00:1d.0-2/input0
Pour le moment rien de bien extraordinaire, c’est un clavier usb … rien de plus …

Sauf que, un lsusb plus tard …
skywodd@skywodd-eeepc /dev $ lsusb
Bus 002 Device 005: ID 08ff:0009 AuthenTec, Inc. <---------- HoHoHo !
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 004 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 005 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub

Ça vous dit rien AuthenTec ?
C’est une société spécialisé dans les lecteurs d’empreintes digitales racheté par Apple en novembre dernier.

Apparemment il faisaient des chipsets usb pour lecteur RFID par le passé et je ne suis pas le seul à avoir remarquer la chose :
http://wiki.techinc.nl/index.php/AuthenTec-RFID-reader
(dommage qu’il n’y ait pas plus d’information sur ce wiki …)

—

Bref, savoir qui a réellement fabriqué quoi n’est pas le plus important.
Le plus important c’est de savoir comment interpréter les données émises par le lecteur !

Un début de réponse se trouve ici (merci Guillaume pour le lien) :
http://www.ardushop.com/kits/electronic-brick-125khz-rfid-card-reader.html

En y regardant bien le lecteur du lien ci-dessus retourne 10 octets de données, calés entre un entête et une checksum.
Si on applique le même algorithme avec les données du lecteur « BlackBox » … miracle, ça marche (merci Antafuli pour les calculs) !

—

Comment c’est codé et comment on décode tout ça ?

Préparez un tube d’aspirine ça va faire mal à la tête …

D’habitude les chinois font au plus simple et au moins chère, pour le coup c’est pas du tout le cas !
L’algorithme de codage / décodage est complètement tiré par les cheveux …

Partons de l’ID (en hexadécimal) d’une carte RFID connu (une carte Parallax pour le coup) :
26 00 D7 18 74

La première étape consiste à supprimer l’octet de poids fort (le premier octet en partant de la gauche) :
00 D7 18 74

La seconde étape consiste à convertir ce chiffre hexadécimal en une valeur décimal (passage de la base 16 à la base 10 pour les matheux) :
0xD71874 = 14096500

Ajoutez ensuite quelques zéro sur la gauche pour avoir 10 chiffres :
0014096500

Et pour finir passer chaque chiffre à la moulinette, en utilisant ce tableau :
0 = E0
1 = 26
2 = E9
3 = 22
4 = 27
5 = 28
6 = 2D
7 = E8
8 = 5F
9 = E7
(ne me demandez où est la logique dans cette suite de chiffre je n’ai même pas cherché)
(EDIT: ce sont les scan code des chiffres 0 à 9 des claviers qwerty)
(ces valeurs ont était vérifiés avec mon spoofer RFID et des ID calculés spécialement pour avoir chaque digit séparément)

Pour cet exemple on obtient :
0 0 1 4 0 9 6 5 0 0
E0 E0 26 27 E0 E7 2D 28 E0 E0

Si on passe cette carte sur le lecteur (pour vérifier) et que l’on affiche les frappes du clavier en hexa :

C’est la même trame que notre calcul !

Vous vous demandez sûrement pourquoi ils n’ont pas tout simplement envoyé l’ID du tag en hexa sans ce poser de question ?
Et bien je me pose la même question !
Le fait est qu’avec le système actuel un octet de l’ID du tag est perdu, réduisant grandement le nombre de combinaisons possibles sans conflit d’ID …

—

Un petit script pour automatiser tout ça :

En python (on change pas les bonnes habitudes) :

# Blackbox D9 RFID reader data decoder

# Convertie une chaîne de caractères hexa séparés par des espaces en une valeur brute
def hexa_to_rawID(hexStr):
    hexStr = ''.join(hexStr.split())
    return int(hexStr, 16)

# Convertie une valeur brute en une valeur "tronquée"
def rawID_to_semiID(rawID):
    return int(rawID) & 0xFFFFFFFF

# Encode une valeur "tronquée" en une chaîne hexa comme celle que donnerait le lecteur
def semiID_to_rfid(semiID):
    convTable = {'0':'E0', '1':'26', '2':'E9', '3':'22', '4':'27', '5':'28', '6':'2D', '7':'E8', '8':'5F', '9':'E7'}
    res = []
    for c in str(int(semiID)).zfill(10):
        res.append(convTable[c])
    return ' '.join(res)

# Converti un tableau de données binaire en une chaine de caractéres hexa
def binary_to_rfid(binary):
    res = []
    for byte in binary:
        byte = ord(byte)
        res.append(hex(byte)[-2:].upper())
    return ' '.join(res)

# Décode une chaine hexa généré par le lecteur en une valeur "tronquée"
def rfid_to_semiID(rawRFID):
    rconvTable = {'E0':'0', '26':'1', 'E9':'2', '22':'3', '27':'4', '28':'5', '2D':'6', 'E8':'7', '5F':'8', 'E7':'9'}
    res = ''
    for v in rawRFID.split():
        res += rconvTable[v]
    return int(res, 10)

# ID des tags de test
tagIDs = [
    '26 00 D7 18 74',
    '26 00 D6 F1 A8',
    '01 07 DD 76 72',
    '01 07 DD 72 75',
    '01 07 DD 59 3B',
    '01 07 DD 74 95',
    '01 07 DD 79 11' ]

# Valeurs lu pour chacun des tags de test
readIDs = [
    'E0 E0 26 27 E0 E7 2D 28 E0 E0',
    'E0 E0 26 27 E0 5F 2D 28 2D 5F',
    'E0 26 22 26 E7 28 27 E9 E7 E0',
    'E0 26 22 26 E7 28 22 26 5F E7',
    'E0 26 22 26 E7 27 2D 5F 26 26',
    'E0 26 22 26 E7 28 22 5F 26 22',
    'E0 26 22 26 E7 28 27 E7 2D 26' ]

# Calcul de chaque tags
for i in range(0, len(tagIDs)):
    tagID = tagIDs[i]
    print 'Real ID:', tagID # ID réel
    rawID = hexa_to_rawID(tagID)
    print 'Raw ID:', hex(rawID).strip('L') # ID réel en valeur brute
    semiID = rawID_to_semiID(rawID)
    print 'Semi ID:', hex(semiID).strip('L') # ID tronqué
    rfid = semiID_to_rfid(semiID)
    print 'RFID ID:', rfid # ID encodé
    print 'RFID ID:', readIDs[i] # ID réelement lu (doit être identique que la ligne au dessus)
    semiID = rfid_to_semiID(rfid)
    print 'Semi ID:', hex(semiID).strip('L') # ID (re)décodé

# Démonstration du décodage depuis un tableau de données binaire (les même principe est applicable avec stdin)
binary = '\xE0\xE0\x26\x27\xE0\xE7\x2D\x28\xE0\xE0'
rfid = binary_to_rfid(binary)
semiID = rfid_to_semiID(rfid)
print hex(semiID)[2:].zfill(10)

Bon bidouillage à tous !