Émulateur de carte EM Marine
Chacun de nous, qui a déjà été dans des bureaux ordinaires, était certainement intéressé par le fonctionnement de ces laissez-passer sans contact. Dans cet article, nous aborderons le principe de fonctionnement des cartes sans contact et réaliserons un émulateur à partir de littéralement trois composants radio.
Technologie RFID
L'apparition des tags
RFID RFID (English Radio Frequency IDentification, Radio Frequency Identification) - a une gamme de fréquences assez large et un assez grand nombre de normes différentes qui sont en quelque sorte applicables à cette technologie. Pour référence: les fréquences utilisées sont: 125-135 kHz, 400 kHz, 6,78 MHz, 13,56 MHz (cartes métro et cartes bancaires), 27,125 MHz, 40,68 MHz, 433,29 MHz, 869 MHz, 915 MHz, 2,45 GHz, 5,8 GHz et 24,125 GHz. Comme vous pouvez le voir, la gamme de fréquences est très large.
Nous parlerons des cartes les plus répandues et les moins protégées de la gamme de fréquences 125 kHz. Je vais analyser la norme EM Marine 4102, car c'est ce que je connais le mieux. Cependant, le code de l'émulateur vous permet de travailler avec d'autres normes fonctionnant à 125 kHz.
Afin que nous puissions approfondir la théorie, il convient de dire quelques mots sur le fonctionnement de la RFID. Plus loin dans le texte, des informations relatives à la norme EM Marine 125 kHz seront fournies, d'autres solutions RFID sont disposées de la même manière.
Le lecteur, en plus de l'échange d'informations, fournit de l'énergie. La balise est une ROM qui est alimentée par un champ électromagnétique, et après mise sous tension, elle donne simplement les informations enregistrées.
Ce schéma montre clairement comment l'émetteur et le récepteur sont disposés. Les deux circuits oscillatoires sont accordés à la résonance et sont utilisés pour la transmission de données et la transmission d'énergie, pour alimenter une étiquette passive, qui est notre carte.
Plus de détails sur le principe de fonctionnement peuvent être trouvés dans [1]
L'intérieur de la carte démontée
Si vous démontez la carte, vous pouvez voir une antenne sous la forme d'une bobine et une puce remplie d'un composé, qui contient une ROM et un condensateur de 75 pF.
Description du protocole EM4102
Avant d'aller plus loin, comprenons la norme EM4102 que nous allons émuler. L'étiquette RFID conforme EM4102 contient 64 bits de mémoire en lecture seule. En fait, il s'agit de la ROM, c'est-à-dire que les informations peuvent être lues à partir de celle-ci, mais ne peuvent être ni modifiées ni écrites, en d'autres termes, cette puce est flashée une fois en usine. La structure de la mémoire de la balise est visible dans la figure ci-dessous.
Lorsque l'étiquette pénètre dans un champ électromagnétique émis par un lecteur RFID, elle reçoit de l'énergie du champ (alimentation) et commence à transmettre des données. Les 9 premiers bits sont des bits logiques. Ces bits sont utilisés comme une séquence de jetons pour indiquer le début de la transmission. Puisque toutes les autres données utilisent la parité, cette séquence de neuf bits de uns ne se produira plus nulle part ailleurs. Ensuite, il y a 10 groupes de 4 bits de données et 1 bit de parité pour chaque groupe. Enfin, il y a 4 bits de la somme de contrôle et le dernier bit d'arrêt, qui est toujours nul.
L'étiquette répète le cycle de transfert de données pendant qu'elle est alimentée. Par conséquent, nous observons la lecture constante de l'étiquette sur le lecteur.
Je vais donner un exemple des données transmises par l'étiquette avec le numéro: 0x06Est le numéro de version et 0x001259E3 est les données.
À propos, le nombre imprimé sur la carte peut être traduit en un nombre hexadécimal que le lecteur recevra. Par exemple, le numéro est écrit sur la carte: 116,23152
- 116 en notation décimale est 0x74 en hexadécimal;
- 23152 en décimal est 0x5A70 en hexadécimal;
En les combinant, nous obtenons le numéro de série de la carte, que le lecteur nous donnera: 0x00745A70 .
Modulation du signal
La transmission des données de l'étiquette vers le lecteur se fait en modulant le signal porteur du lecteur (dans notre cas, la fréquence porteuse est de 125 kHz). Veuillez noter que cette fréquence porteuse fournit également de la puissance et module le signal. Tout d'abord, considérons un schéma simplifié d'interaction entre un lecteur et une balise. Souvenez-vous de cette image, nous y reviendrons plus tard.
Comme vous pouvez le voir, l'étiquette possède un circuit oscillatoire LC, une diode qui sert à redresser le courant alternatif, un condensateur pour lisser l'ondulation (cela fait partie de l'alimentation de l'étiquette), et un transistor, en contrôlant lequel nous pouvons moduler le signal. Sur le lecteur, cela se traduira par une modification du courant circulant dans la bobine. En termes simples, lorsqu'elle pénètre dans le champ du lecteur, l'étiquette consomme un courant électrique (à peu près constamment), lors de la transmission d'informations, elle change la valeur du courant consommé par un transistor et ainsi le lecteur peut recevoir un signal en mesurant la consommation d'énergie.
Le lecteur génère un champ magnétique à l'aide d'un modulateur et d'une bobine et capte le signal modulé, puis le décode.
Un exemple de modulation d'un signal porteur
Si je ne vous ai pas complètement confondu, alors allons plus loin. Afin de transmettre des données, nous devons moduler le signal. Autrement dit, il superposera les bits des informations transmises sur la fréquence porteuse.
Il existe trois schémas de modulation courants selon la norme RFID:
- Code de Manchester
- Code Manchester à deux phases
- Codage par décalage de phase
Étant donné que la norme EM4102 utilise le schéma de codage Manchester, nous l'examinerons. Lors de la modulation pour le protocole EM4102, le temps de transmission d'un bit peut être de 64, 32 ou 16 périodes de la fréquence porteuse (125 kHz).
Avec ce codage, la marque change le niveau de transmission du signal exactement au milieu de la période de transmission d'un bit. La transition du niveau bas au niveau haut à ces moments signifie l'état du "1" logique, et la transition du niveau haut vers le niveau bas, représente l'état du "0" logique.
Véritable signal modulé capturé sur la bobine du lecteur.
Créer un émulateur RFID
Eh bien, si vous êtes toujours là et que votre tête n'est pas enflée à cause de ces calculs, il est temps de créer un émulateur RFID, à partir de deux parties seulement. Le génie réside dans cette simplicité. J'ai assemblé l'appareil, empruntant l'idée et le code à Micah Dowty , les photos sont à moi.
Voici un cafard miniature qui pourrait bien imiter le tag de
site du projet . Le code est très intéressant, on pourrait dire brillant et laconique (l'assembleur est utilisé). Insistons-y en détail. Nous allons l'analyser. Vous pouvez voir le code ici .
Pour commencer, voyons comment cette chose fonctionne généralement, bien que, par définition, cela ne devrait pas fonctionner, car elle contredit le schéma de câblage habituel du microcontrôleur. Le schéma de l'appareil est tiré du code source.
Une bobine d'inductance d'environ 1 μH et un microcontrôleur ATtiny85
Voilà, Mesdames et Messieurs, un véritable Hacking, quand le niveau de compréhension des caractéristiques de fonctionnement de l'équipement permet de créer des solutions techniques qui dépassent les limites indiquées par le constructeur! Et cela fonctionne, personnellement vérifié. C'est le vrai sens du mot "hacker", il ne s'agit pas de piratage et de vol.
Pour l'avenir, je dirai que cette bobine n'est pas suffisante pour un fonctionnement normal, et pourtant j'ai dû fabriquer une antenne normale, raccrocher les condensateurs d'alimentation et un condensateur résonnant. Mais pour démontrer les principes du travail, c'est tout à fait approprié.
Comment ça marche:
Avant de commencer à analyser le code de cet émulateur, faisons-en une antenne normale. Mes expériences avec les circuits actuels ont révélé une extrême instabilité dans son fonctionnement. Cela ne fonctionne que très près du lecteur, et même pas toujours. Par conséquent, dans un premier temps, j'ai soudé un condensateur de 0,1 μF aux jambes de puissance du contrôleur, puis j'ai décidé de faire un vrai grand circuit oscillatoire, comme dans une vraie étiquette.
- AVR /. /, . , . , . , . , . , .
- AVR. , , , ( 0,1 ). AVR. , , 125!
- . ATtiny85 2,5 . 1,8 . AVR , ...
- , ! , , . Clock ! 125 , RFID. , !
- ? -, . . EM4102 32 . HID FSK 4 . RFID- . « » , RFID -.
La première modification est un condensateur de 0,1 uF pour l'alimentation
Création d'antenne
Il n'y a pas d'astuce pour créer une antenne bobine, mais il faut tout de même se familiariser avec la documentation et comprendre la physique du processus ... Ce n'est pas difficile, et même un écolier peut le gérer, il faut juste un peu de patience et de persévérance.
Il est très facile d'assembler et de configurer l'antenne, tout comme sur l'image de [1] .
Pour calculer l'antenne, vous devez vous rappeler un peu de théorie. Nous devons créer un circuit oscillant qui sera accordé à une fréquence de 125 kHz. Ouvrons le cours des Fondements théoriques du génie électrique et lisons ce qu'est un circuit oscillatoire:
Un circuit oscillant, un circuit électrique contenant une inductance et un condensateur dans lesquels des oscillations électriques peuvent être excitées.
Circuit oscillatoire parallèle
Si nous quittons toutes les mathématiques et allons au point, le circuit oscillatoire a un paramètre tel que la fréquence de résonance, qui est déterminée par la formule.
Où f est la fréquence d'oscillation, L est l'inductance de la bobine, C est la capacité du condensateur.
Dans ce cas, nous avons un paramètre fixe - la fréquence, et nous pouvons jouer avec la capacité et l'inductance. Pour calculer la bobine, nous utiliserons le document [2] . Tous ceux qui vont fabriquer des antennes pour des étiquettes RFID (de n'importe quelle fréquence) doivent se familiariser avec!
De nombreux artisans, tant pour les lecteurs que pour les émulateurs (l'essentiel n'est pas important), fabriquent des bobines rondes. Ils sont plus faciles à compter et à fabriquer, mais ils présentent un inconvénient majeur: leurs dimensions linéaires sont plus grandes que la carte. Je veux faire un inducteur en forme de rectangle, avec des dimensions linéaires inférieures aux dimensions d'une carte standard et pour que le dispositif résultant ait la taille d'une carte RFID standard. En conséquence, je choisis la taille du futur inducteur pratiquement la même que dans la marque actuelle, c'est-à-dire environ 70x40 mm... Si vous sélectionnez un condensateur de 10 nF, l'inductance de la bobine (à partir de la formule ci-dessus) doit être de 162 μH. Regardez maintenant la documentation pour calculer une bobine rectangulaire. Pour enrouler la bobine, j'ai choisi un fil d'une section de 0,2 mm. En conséquence, nous ouvrons la section correspondante de la documentation, et la formule glorieuse suivante est présentée à nos yeux.
Comme vous pouvez le voir, les paramètres d'épaisseur et de largeur de la bobine sont inconnus et variables (ils reposent sur l'épaisseur du fil de 0,2 mm), mais des estimations générales m'ont donné un chiffre de 42 tours. Il serait possible de faire plusieurs itérations et de faire un calcul simple et précis, mais dans notre cas pièce, cela fera l'affaire.
Après cela, il est nécessaire de fabriquer un cadre de 70x40 mm pour enrouler la bobine. Je l'ai fabriqué à partir de PCB et enroulé une bobine autour de lui.
Cadre PCB
Bobinage et bobine finie
Malheureusement, je n'ai pas d'inductance, j'ai donc dû continuer en utilisant la méthode scientifique de poke. Comme j'ai probablement fait une erreur dans les calculs, et dans le nombre de tours lorsque j'ai enroulé la bobine, comme je les faisais approximativement et à l'œil nu, j'ai décidé de sélectionner la capacité résonnante manuellement. Pour ce faire, j'ai fixé la bobine sur le lecteur de carte, collé ses extrémités dans la planche à pain («matelas à trous»), puis j'ai commencé à connecter les conteneurs un à un, tout en enregistrant le signal sur l'oscilloscope.
Premiers pas avec le condensateur
résonnant J'ai d'abord vérifié le condensateur 10nF, qui devrait résonner. Mais l'amplitude du signal a immédiatement chuté par rapport à la bobine vide. Ensuite, j'ai pris un condensateur plus petit. Et donc je suis passé par les condensateurs jusqu'à ce que j'attrape la résonance. Ainsi, la capacité de résonance du condensateur était de 3,2 nF.
Signal sans condensateur, bobine vide
Signal 10 nF
1 nF, 2 nF
3 nF, 4 nF, 2,2 nF
3.2 nF
On voit que j'ai essayé différentes options, et il était clair que le maximum se situe quelque part entre 3 et 4 nF et le résultat était un condensateur de 3,2 nF (composé de deux condensateurs en parallèle). Voilà, notre bobine est prête pour d'autres expériences.
En général, je tiens à noter qu'une bobine peut généralement être réalisée sous la forme de pistes sur une carte de circuit imprimé, et avec une petite série de produits, cela devrait être fait. Voici un exemple d'une telle carte, à 125 kHz d' Alexander Guthmann . Malheureusement, le site est pratiquement mort, et l'auteur n'a pas été en contact depuis longtemps, nous ne nous contentons donc que de mes photos. Si quelqu'un peut aider à le trouver, je vous en serais reconnaissant! Je ne sais pas ce qui lui est arrivé.
Ainsi, la réalisation immédiate de l'émulateur sous la forme d'une carte de circuit imprimé ne pose aucun problème. Je pense qu'avec le manuel [2] , vous pouvez le calculer vous-même, puisqu'un écolier allemand de quatorze ans pourrait le faire.
Passons en revue le code
Jetons un coup d'œil au code, que vous pouvez voir ici . Il existe un exemple d'émulation de deux types de cartes, je n'analyserai que EM4102.
Tout d'abord, comme le code l'indique, lors du clignotement du microcontrôleur, nous devons flasher les bits de fusible à la valeur lfuse à 0xC0 : de sorte que le contrôleur soit cadencé à partir d'un générateur externe. J'attire votre attention sur le fait que tout contrôleur clignotant sera associé au fait qu'il devra être cadencé à partir d'une source externe, car nous définissons des bits fusibles avec génération à partir d'un générateur externe!
Tout le code est basé sur des macros. Permettez-moi de vous rappeler ce que sont les macros - un programme qui prépare le code pour la compilation. Notre programme se compose de quelques instructions assembleur: rjmp, call (2 horloges), nop, ldi, out et ret (toutes 1 horloge)! Tout, tout le reste du code est formé de macros en fonction de la macro de numéro de série (définir). La particularité du travail est que nous avons assez peu de cycles d'horloge pour un travail normal. Essayez de faire quelque chose en 32 cycles d'horloge, sachant que les instructions de saut dans le contrôleur AVR prennent 2 cycles d'horloge. Par conséquent, tout le code est généré par des macros en fonction de la carte d'identité.
#define FORMAT_IS_EM4102
#define EM4102_MFR_ID 0x12
#define EM4102_UNIQUE_ID 0x3456789A
Définissez le type de carte que nous émulons et définissez les cartes d'identité. Il s'agit de la macro principale sur la base de laquelle le reste du code est formé. Et, tadam, sa majesté macros.
.macro delay cycles
.if \cycles > 1
rjmp .+0
delay (\cycles - 2)
.elseif \cycles > 0
nop
delay (\cycles - 1)
.endif
.endm
Macro de retard, accepte le nombre de ticks de retard comme entrée. Macro récursive assez évidente, elle effectue le retard en utilisant la commande nop (pas d'opération, 1 cycle d'horloge) et la commande rjmp. + 0 (passer à la ligne suivante, 2 cycles d'horloge). En combinant ces commandes entre elles, vous pouvez effectuer le retard de la longueur souhaitée en mesures. En fait, le code ne fait rien, il ne fait que perdre du temps à la machine.
Si vous pensez toujours, alors je violerai complètement votre cerveau, mais le code est si ingénieux que vous devrez le supporter.
Encodage de macro récursif par code Manchester.
.macro manchester bit, count=1
.if \count
manchester (\bit >> 1), (\count - 1)
.if \bit & 1
baseband_1
baseband_0
.else
baseband_0
baseband_1
.endif
.endif
.endm
.macro stop_bit
baseband_0
baseband_1_last
.endm
En fait, toute la logique est implémentée ici. Accepte un masque de bits et un compteur de bits en entrée. Si le compteur n'est pas nul, alors nous nous appelons à nouveau, en décrémentant le compteur (macro récursive, ouais). Plus loin dans le corps lui-même, il y a des appels aux macros baseband_0, baseband_1 et baseband_1_last. Selon le bit que nous avons «1» ou «0», nous modulons le signal de code Manchester de zéro à un ou de un à zéro.
Rappelez-vous ci-dessus, j'ai donné le tableau de l'article, comment le contenu de la carte est encodé, où vont les bits de parité et les bits d'arrêt à la fin. Donc, notre tâche est maintenant d'encoder les étiquettes d'identification avec cette méthode, pour cela nous avons deux macros.
#define ROW_PARITY(n) ( (((n) & 0xF) << 1) | \
(((n) ^ ((n) >> 1) ^ ((n) >> 2) ^ ((n) >> 3)) & 1) )
#define COLUMN_PARITY ( (EM4102_MFR_ID >> 4) ^ \
(EM4102_MFR_ID) ^ \
(EM4102_UNIQUE_ID >> 28) ^ \
(EM4102_UNIQUE_ID >> 24) ^ \
(EM4102_UNIQUE_ID >> 20) ^ \
(EM4102_UNIQUE_ID >> 16) ^ \
(EM4102_UNIQUE_ID >> 12) ^ \
(EM4102_UNIQUE_ID >> 8) ^ \
(EM4102_UNIQUE_ID >> 4) ^ \
(EM4102_UNIQUE_ID) )
ROW_PARITY - calcul du bit de parité dans une chaîne de quatre bits, COLUMN_PARITY - calcul de la somme de contrôle du message entier.
Toute la logique de notre travail est décrite dans une macro en .main
header
manchester ROW_PARITY(EM4102_MFR_ID >> 4), 5
manchester ROW_PARITY(EM4102_MFR_ID >> 0), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 28), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 24), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 20), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 16), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 12), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 8), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 4), 5
manchester ROW_PARITY(EM4102_UNIQUE_ID >> 0), 5
manchester COLUMN_PARITY, 4
stop_bit
Eh bien, c'est-à-dire que nous transférons simplement l'en-tête 9 bits de la même manière, puis le codage Manchester, en calculant le bit de parité tous les 4 bits, à la fin une somme de contrôle et un bit d'arrêt.
Il reste à déterminer ce qu'est la bande de base. Pour cela, nous avons une autre macros wrapper (oui, combien est possible, hein?).
.macro baseband_0
rcall baseband30_0
rjmp .+0
.endm
.macro baseband_1
rcall baseband30_1
rjmp .+0
.endm
.macro baseband_1_last
rcall baseband30_1
rjmp main
.endm
.macro header
manchester 0x1FF, 9
.endm
Macros Baseband * - exécutez le code d'assemblage: appelez les fonctions appropriées, puis effectuez une transition vers une autre instruction. La macro baseband_1_last est similaire à la macro baseband_1, sauf qu'elle effectue un saut inconditionnel non pas vers la commande ci-dessous, mais vers le début de la fonction principale. En-tête de macro - sert à afficher l'en-tête de neuf bits du même type égal à un, et appelle la macro Manchester avec la transmission du nombre et du nombre de bits transmis.
La dernière chose à analyser est les fonctions baseband30_0 et baseband30_1. Ils sont décrits par le code suivant.
baseband30_0:
ldi r16, OUT_PINS // 1
rjmp baseband30 // 2
/*
* Emit a 1 at the baseband layer.
* Takes a total of 30 clock cycles, including call overhead.
*/
baseband30_1:
ldi r16, 0 // 1
rjmp baseband30 // 2
/*
* Internal routine for baseband32_0 and _1. Must use
* a total of 24 clock cycles. (32 - 1 ldi - 2 rjmp - 3 rcall)
*/
baseband30:
out _SFR_IO_ADDR(DDRB), r16 // 1
delay 19 // 19
ret // 4
Selon la fonction appelée baseband30_0 ou baseband30_1, la valeur de ce qui devrait être sur la broche d'E / S est écrite dans le registre r16: 1 ou 0. Après cela, il y a une transition inconditionnelle vers la bande de base30, la sortie est effectuée et un retard de 19 cycles d'horloge, après quoi il y a un retour.
La plus grande magie de ce code est qu'il est calculé exactement avant chaque cycle d'horloge, chaque horloge de transmission du code Manchester prend exactement autant de périodes que le permet la norme, à savoir 32 cycles d'horloge processeur! C'est incroyablement ingénieux, vous devez vous rappeler combien de mesures chaque commande prend.
Compilons-le plutôt et voyons à quoi il ressemble, comment toutes ces macros se développent. Nous compilons avec la commande make (après avoir installé avr-gcc) et démontons le fichier elf résultant
00000000 __vectors:
0: 0e c0 rjmp .+28 ; 0x1e __ctors_end
2: 15 c0 rjmp .+42 ; 0x2e __bad_interrupt
...
Premièrement, nous avons des vecteurs d'interruption, mais nous ne nous intéressons qu'au premier saut. Puisque le reste des vecteurs ne mène nulle part.
0000001e __ctors_end:
1e: 11 24 eor r1, r1
20: 1f be out 0x3f, r1 ; 63
22: cf e5 ldi r28, 0x5F ; 95
24: d2 e0 ldi r29, 0x02 ; 2
26: de bf out 0x3e, r29 ; 62
28: cd bf out 0x3d, r28 ; 61
2a: 02 d0 rcall .+4 ; 0x30 main
2c: 11 c1 rjmp .+546 ; 0x250 _exit
Ici, nous configurons les ports d'E / S et nous appelons la fonction principale. Un main se compose d'une quantité insensée d'appels à la bande de base30 * et de fonctions de saut (c'est ainsi que s'est déroulé notre cirque infernal de macros).
00000030 main:
30: 01 d1 rcall .+514 ; 0x234 baseband30_1
32: 00 c0 rjmp .+0 ; 0x34 main+0x4
34: fd d0 rcall .+506 ; 0x230 baseband30_0
36: 00 c0 rjmp .+0 ; 0x38 main+0x8
38: fd d0 rcall .+506 ; 0x234 baseband30_1
3a: 00 c0 rjmp .+0 ; 0x3c main+0xc
3c: f9 d0 rcall .+498 ; 0x230 baseband30_0
3e: 00 c0 rjmp .+0 ; 0x40 main+0x10
40: f9 d0 rcall .+498 ; 0x234 baseband30_1
42: 00 c0 rjmp .+0 ; 0x44 main+0x14
44: f5 d0 rcall .+490 ; 0x230 baseband30_0
46: 00 c0 rjmp .+0 ; 0x48 main+0x18
48: f5 d0 rcall .+490 ; 0x234 baseband30_1
4a: 00 c0 rjmp .+0 ; 0x4c main+0x1c
4c: f1 d0 rcall .+482 ; 0x230 baseband30_0
...
22e: 00 cf rjmp .-512 ; 0x30 main
Et ainsi de suite ... jusqu'à ce que nous revenions à la principale
Eh bien, voyons à quoi ressemble notre module de bande de base.
00000230 baseband30_0:
230: 08 e1 ldi r16, 0x18 ; 24
232: 02 c0 rjmp .+4 ; 0x238 baseband30
00000234 baseband30_1:
234: 00 e0 ldi r16, 0x00 ; 0
236: 00 c0 rjmp .+0 ; 0x238 baseband30
00000238 baseband30:
238: 07 bb out 0x17, r16 ; 23
23a: 00 c0 rjmp .+0 ; 0x23c baseband30+0x4
23c: 00 c0 rjmp .+0 ; 0x23e baseband30+0x6
23e: 00 c0 rjmp .+0 ; 0x240 baseband30+0x8
240: 00 c0 rjmp .+0 ; 0x242 baseband30+0xa
242: 00 c0 rjmp .+0 ; 0x244 baseband30+0xc
244: 00 c0 rjmp .+0 ; 0x246 baseband30+0xe
246: 00 c0 rjmp .+0 ; 0x248 baseband30+0x10
248: 00 c0 rjmp .+0 ; 0x24a baseband30+0x12
24a: 00 c0 rjmp .+0 ; 0x24c baseband30+0x14
24c: 00 00 nop
24e: 08 95 ret
À la fin, vous pouvez voir comment le délai s'est développé en une liste de sauts et de nop pour le délai. C'est une si belle magie.
Eh bien, nous avons compris le code. Récupérez le cerveau drainé des oreilles, nous procédons aux tests.
Des tests
Nous appliquerons toutes les connaissances acquises et effectuerons des tests. Nous compilons le firmware, flashons le contrôleur, en nous rappelant de régler correctement les bits Fuse.
Firmware scarf Nous
connectons notre circuit oscillatoire et testons sur un vrai lecteur industriel, pas de demi-mesures, des conditions de combat justes.
Banc d'essai
Et, voilà! Cela fonctionne, lit correctement et donne l'identifiant correct dans une boucle! Sans alimentation externe, avec fonctionnement uniquement depuis le terrain. Reste à mettre tout cela en ordre et à fabriquer une véritable étiquette RFID.
La version finale «plastifiée» de l'étiquette
Total
Je peux honnêtement admettre que je ne croyais pas vraiment que cela fonctionnerait. Alimentation sur le terrain, modes de fonctionnement non standard du contrôleur, fonctionne strictement selon les cycles d'horloge, inducteur maison. Plus le travail de la RFID lui-même. Et maintenant, comme un travail insignifiant se répand pendant quelques mois de lecture de la documentation et de débriefing. Mais ça marche, et cette chose est vraiment géniale. Alors les gars, ce genre de chose est du vrai piratage. Fonce!
Devoirs
Puisque vous lisez toujours cet article sympa, je l'ai écrit, essayé, fait, il est maintenant temps pour vous d'essayer de faire quelque chose. Le code de l'émulateur contient une section qui émule les cartes de proximité HID avec un codage par décalage de phase. Vous devez comprendre la norme HID et ce codage pour le plaisir et une meilleure assimilation. Envoyez la solution dans les commentaires. Bonne chance.
Bibliographie
