==Phrack Inc.== Volume 0x0b, Issue 0x3e, Phile #0x0f of 0x10 |=--------=[ Introduction for Playing Cards for Smart Profits ]=--------=| |=----------------------------------------------------------------------=| |=------------------=[ ender ]=-----------------=| --=[ Sommaire ]=---------------------------------------------------------- 1 - Introduction 2 - A propos du standard ISO7816 2.1 - Réception de Anwer to Reset 2.2 - Emission de commandes 2.3 - Réception de réponses 2.4 - Exemples 2.5 - Vos droits 3 - SmartCard Man in the Middle 4 - BruteForcing de cartes non-identifiées 5 - Exemples de mapping et de systèmes de fichiers 5.1 - Mapping d'une ancienne carte de crédit francaise 5.2 - Système de Fichiers des Cartes SIM 6 - Crypter avec une carte à puce 7 - Les bandes magnétiques 7.1 - ISO 7.2 - ALPHANUMERIQUE 7.3 - BINAIRE 8 - Cartes à puce synchrones 9 - Programmation d'une carte pour du ISO7816 10 - Conclusion 11 - Remerciements 12 - Bibliographie Annexe A : Log de communication --[ 1 - Introduction ]----------------------------------------------------- Tout ce qui est écrit dans cet article doit être utilisé pour cracker des cartes et ne devrait pas être utilisé pour sécuriser une application déjà existante. Cependant, le but de cet article est de vous montrer comment engager le dialogue avec vos carte à puces (très utile quand vous n'avez pas de petite amie à qui parler), et non le moyen d'utiliser des cartes déjà crackées. Ce dont vous avez besoin pour étudier les cartes : - LE standard : ISO7816 ( http://www.cardwerk.com/smartcards/smartcard_standards.aspx ) - un lecteur de carte à puce (Phoenix) - optionellement un lecteur/enregistreur de bandes magnétiques (just for fun) - peut-être un Season -j'expliquerai plus tard- - quelques cartes banquaires - et un ordinateur : - Sous GNU/Linux / Unix : vous pouvez voir avec shcap (www.afturgurluk.org/~ender/ ) ou essayer SmartCard Toolkit (http://freshmeat.net/projects/sctk/ ) - Sous le non-système d'exploitation de Bill : WinExplorer de Dexter (www.geocities.com/Winexplorer/ ) --[ 2 - A propos du standard ISO7816 ]------------------------------------ Vous aurez besoin de vous référer à ce standard. Nous verrons comment engager la communiaction avec une carte à puce insérée dans votre phoenix (lecteur de carte à puce), qui est inséré dans votre port rs232. J'ai inclus deux exemples : une carte de crédit, et une carte SIM. Si aucune carte spécifique n'est mentionnée dans la présentation du protocole, c'est que l'information est valide pour toutes les cartes compatibles 7816 ISO. ----[ 2.1 - Réception du Answer To Reset (ATR) ]------------------------------ D'aord, vous devrez reset-er la carte (avec un ioctl, ou en tapant directement 'reset' dans un SmartCard shell) pour démarrer la carte, ensuite elle envoie un tampon de données pour s'identifier elle-même, et pour expliciter ses spécifications comme la fréquence, le voltage de programmation, le GuardTime, la Convention (inverse/direct)... Ce qu'il est réellement utile de connaître est : La ATR ressemble à ceci : ATR : TS T0 TA1 TB1 TC1 TD1 TA2 ... TDn Tk TCK TS : 3B Direct Convention 3F Inverse Convention T0 : donne le nombre d'Octets Historiques (spécifique à la carte) Tk : les k Octets Historiques... pas vraiment bavard en fait :/ TCK : juste un checksum pour vérifier que vous avez une bonne ATR... Nota : Si vous ne recevez pas 0x3B ou 0x3F pour TS, vous devez peut-être reconfigurer votre soft pour recevoire Octet dans une autre convention... ----[ 2.2 - Emission de commandes ]---------------------------------------- Les instructions sont envoyées à la carte via un lien série. Le protocole est expliqué dans le standard mais est simplement un I2C sans scl. Les paquets sont composés de cinq parties : CLA : 1 octet. Classe ISO, c'est à dire : BC = carte de crédit française, A0 = carte SIM 00 = cartes Moneo / Open Cards INS : 1 octet. Instruction, c'est à dire : 20 = vérification du PIN B0 = Lire B2 = Lire enregistrement D0 = Ecrire D2 = Ecrire enregistrement A4 = Choisir dossier 8x = cryptage avec la clef "x", les algorithmes dépendent de la carte, C0 = obtenir réponse... P1, P2 : 2 octets. Paramètres, en général c'est une adresse à lire/écrire. LEN : 1 octet. Longeur attendue pour la réponse ou longeur de l'argument ARG : LEN octets. L'arguement que vous donnez à l'instruction (octets à écrire, données à crypter, PIN à vérifier,...) ; parfois, la carte doit répondre un octet d'acceptation - selon l'instruction- entre chaque octet dans le tampon de l'argument. ----[ 2.3 - Réception de réponses ]--------------------------------------- Pour accepter une commande, la carte renvoie l'octet d'instruction au terminal, ensuite une longueur de données égale au paramètre LEN de la commande, et termine par SW1, SW2 (0x90 0x00 lorsque l'opération s'est bien passée). Si l'opération a échoué, alors seuls SW1 et SW2 sont envoyés, avec un code d'erreur spécifique : 0x6E 0x00 erreur de CLA 0x6D 0x00 erreur de INS 0x6B 0x00 erreur de P1, P2 0x67 0x00 erreur de LEN 0x98 0x04 Mauvais PIN 0x98 0x08 Accès non-autorisé 0x98 0x40 Carte bloquée ... ----[ 2.4 - Exemples ]---(------------------------------------------------- Voici quelques exemples pris depuis shcap. Vous pouvez le télécharger depuis . Mais vous pouvez faire de même avec 7816shell Si vous utilisez shcap : oops:~/7816/shcap_rel$ sudo ./shcap Terminal> help Shcap v0.0.9 by ender connect - Connect to the Serial port given with -D parameter XX .. XX - Send XX .. XX to the card log - Log comm between card and terminal (need a season) bf - Try to find ISO CLA byte of the card reset - Reset the card direct - Set direct convention inverse - Set inverse convention cd XX XX - Select directory XX XX cat XX XX - Read rd_len bytes at address XX XX readrec XX - Read rd_len on record XX of current file get N - Get N bytes of the answer login - Verify PIN given cypher XX .. XX - Cypher 8 Bytes set - Set parameter : cla=XX Set the iso class to XX (default 00) key=X Set the cyphering key to X (default 0) rd_len=N Set the read lenght to N (default 8) timeout=N Set the poll timeout to Nms (default 500ms) help - Display this help quit - Exit the shell ###### Example avec une Bull CP8 mask 4 BO' (carte de crédit française) ###### Terminal> connect Reset for a B4/B0' : ATR: 3F 65 25 08 93 04 6C 90 00 Analysing the ATR : 3F - Convention inverse 6 - TB and TC sent (if TD is not sent, the protocol is 0 : send words) 5 - 5 historical Bytes 25 - TB : Programming current : max 50mA - Programming Voltage 5V 08 - TC : GuardTime : 8 * 1/9600Hz = 833us Historical Bytes 93 04 6C 90 00 --Note that the 90 00 change to 90 10 after a first wrong PIN code Reading Constructor Area of a B4/B0' : Terminal> set cla=bc ISO CLASS set to BC Terminal> set rd_len=8 READ LENGHT set to 8 Terminal> cat 09 C0 --Read at $09C0 8 bytes Card> B0 19 DF 64 08 1F F4 0F B0 90 00 Analysing Constructor Area : 19 DF 64 08 : Card Serial Number 1FF4 / 0FB0 : Free Read area : $07F8 / Access Control : $03E8 90 00 : ok Signing Data with salt in [07E8] : Terminal> set key=0 --Cipher 8 Bytes with K0 KEY set to 0 Terminal> cypherCB 09 11 15 04 16 00 07 E8 --ARG=09 11 15 04 16 00 [07 E8] Card> 90 00 --Instruction ok Getting response : Terminal> get 8 --Get answer 8 bytes Card> C0 12 4F 54 A3 64 C5 2B 07 90 00 --12 4F 54 A3 64 C5 2B 07 ok ##### Example avec une carte SIM pour GSM ##### Terminal> set cla=a0 ISO CLASS set to A0 Verifying PIN 12345678 on a SIM : Terminal> login --Check PIN 8 Bytes Enter your PIN code : 12345678 --The PIN is encoded in ASCII Card> 90 00 --PIN ok Selecting /TELE COM/SMS/ directory in a SIM : Terminal> cd 7f 10 --Select TELECOM dir : 7F 10 Card> 9F 16 --Dir description, 20Bytes Terminal> cd 6f 3c --Select SMS subdir : 6F 3C Card> 9F 0F --Dir description, 15Bytes Reading msg (15 Bytes) : Terminal> get 15 --Get 15 Bytes Card> C0 00 00 ** ** 6F 3C ** ** ** ** ** ** ** ** ** 90 00 Reading the 3rd SMS of current file : Terminal> set rd_len=176 READ LENGHT set to 176 Terminal> redrec 3 --Read record 3, 176Bytes Card> B2 00 FF .. FF 90 00 --status = 00, data=0xff..ff Terminal> quit Bien. C'est tout pour les exemples... pas vraiment difficile, n'est-ce pas ? --[ 2.5 - Vos droits ]----------------------------------------------------- Les carte à puces utilisent différentes sortes de systèmes de fichiers, il y a donc des droits (xwr) pour les différentes zones qui sont des fichiers. Le droit d'executer est évidemment réservé aux instructions... Généralement, pour une carte appartenant à un seul fournisseur, il y a trois niveaux : -Nobody, lorsque vous démarrez la carte vous n'êtes pas encore identifiés... -Owner (propriétaire), vous êtes "entrés" ["logged in"] lorsque vous entrez votre PIN -Provider (fournisseur), il y a un autre code appelé PUK que vous ne pouvez pas connaître. Il est utilisé par exemple lorsque vous bloquez stupidement votre carte, pour reset-er le mécanisme de blocage. Dans une carte SIM (tout au moins la carte SIM sur laquelle j'ai travaillé), vous ne pouvez pas lire ou écrire si vous ne vous êtes pas log-és. Lorsque vous entrez le PIN (le nom de l'instruction est verify), alors vous pouvez lire, et même écrire dans certains fichiers (surtout dans le dossier TELECOM, contenant vos SMS, vos numéros appelés, etc.). Dans les cartes de crédit, qui sont divisées en zones, vous avez besoin du PIN juste pour lire/écrire votre Bulletin de Transactions (tout au moins pour les françaises... C'est également un trou de sécurité majeur si le PIN n'est pas vérifié dynamiquement par la banque). --[ 3 - SmartCard Man in the middle ]-------------------------------------- Un Season est un truc très utile pour étudier les carte à puces : _____________ __________ | |-- 6 |-- | | Terminal | |--/------------| Carte | |___________|-- | |________| | / 3 Affichage ;) ___|____ ____________ | Season | 3 | logging: | |________|------/-----RS232-->| 3F 16 15 | |__________| Vous aurez besoin de connecter 6 fils de votre carte à puce à votre Wafer, mais seulement 3 à votre ordinateur. Si vous avez lu les standard, vous savez qu'il n'y a qu'une broche dédiée aux Entrées/Sorties. Vous devrez également connecter la masse (utile d'avoir une référence...) et la broche Reset pour démarrer le log lorsque la carte démarre. Cela vous permettra de log-er le dialogue entre le terminal et la carte à puce. C'est le moyen le plus connu pour analyser une carte à puce lorsque vous avez accès au terminal, mais vous pouvez tout aussi bien étudier le terminal avec un analyseur logique horriblement cher et faire du reverse sur les résultats sur l'écran de votre oscilloscope (ça pourrait paraître vraiment stupide, mais quelqu'un l'a fait :p). Si pour quelque raison que ce soit vous n'avez pas accès au terminal, reportez-vous à la partie suivante. Le plan d'un Season est très simple, vous pouvez ajouter quelques LEDs pour voir ce qui se passe. Le MAX32 sert à convertir les 5V des broches de la carte aux 12V du lien RS232 de votre ordinateur (ou laptop ;). +-------------------------+ | | +-----------------------------|-+ LED 3mm R1 250ohm| | 1 _ _16| | ____|/|___/\/\/\__+ | -| |_| |-+ | | |\| | | +---------------+ -| M |---|-----+ | Connector ISO 1 | | | -| A |---+ __|__ | __|_|_______ 5 | -| X |- ///// 1 |______ 5 | | | . . ._______ | -| 2 |- /+_| __+-------+ \ . . . . / | | -| 3 |---------------------------+_| |___| | 6 \_______/ 9 | +---| 2 |-----------------+ |___|__|_+----+ | DB9 | -|_____|- | 4 \__|__|__/ 8 | | | 8 9 +---------------------+ | | | +-------------------------------------------------------+ __|__ ///// Plan d'un Season Branches ISO Broches DB9 1. Vcc 5. Gnd 1 2 3 4 5 2. Rst 6. Nc DCD RxD TxD GND 3. Clk 7. I/O 6 7 8 9 4. Nc 8. Nc N'oubliez pas d'ajouter 4 x 0,1µF entre les broches 2-16, 15-16, 1-3 et 4-5 du MAXX232. Vous pouvez vous référer à la doc du MAXX232 pour plus de détails (les plans ASCII ne sont pas très clairs...). A présent que vous devez log-er les données, vous n'avez juste qu'à écrire quelque part sur votre disque dur les données envoyées et reçues par la carte. Vous pouvez essayer par la commande 'log' dans shcap, ou avec le programme 7816logger de sctk. Le vrai problème est d'analyser les données. * D'abord, la carte envoie une ATR (qui signifie Answer to Reset). * Maintenant le terminal connaît l'indentité de la carte, il peut envoyer des instructions composées en premier lieu de 5 octets. * Ensuite la carte répète le code de l'instruction et le terminal peut envoyer le tampon argument s'il n'est pas vide, la carte répond, * et caetera... Vous pouvez essayer de rechercher la classe ISO (envoyée juste après la ATR) et tenter d'indenter votre log avec juste cette information, et la connaissance du "protocole" comme expliqué plus haut... Après ceci, vous devriez être en mesure de recréer le comportement attendu par le terminal, sauf pour les instructions cryptographiques... mais c'est un autre problème. Vous avez sûrement entendu parler de S/DPA (Single/Differential Power Ananlysis), DFA (Differential Fault Attack) ou Time Attack qui sont les moyens courants pour "facilement" retrouver les clefs stockées dans les cartes. Mais notre sujet n'est pas là. [NdT : au sujet des trois attaques citées, voir les articles dans MISC #7 et #9] Evidemment, si vous voulez faire une attaque contre un terminal avec un tel système, vous pouvez, en passant par-dessu [overriding] la vraie carte, enregistrant ce que la carte doit répondre, et en traîtant la réponse avan de la rejouer. Le traîtement pourrait être utilisé, par exemple, pour faire croire au terminal que le PIN que vous avez entré était le bon (parce que vous êtes méchants et que vous essayez une carte qui n'est pas la votre), en mettant la carte en standby et en reproduisant le comportement de la carte comme si le PIN était réellement le bon... Ca ne fonctionne que si le système d'authentification de la carte à puce n'a pas besoin du PIN pour générer le certificat, ce qui n'est pas vraiment commun. Bon, si vous pouvez reproduire l'authentification, il n'est pas nécessaire de faire une telle attaque, parce que vous pouvez vous débarrasser de la carte originale, mais ce n'est pas un moyen facile ;). Vous trouverez à la fin de l'article un exemple de communication entre une carte de crédit et un terminal. Les données dans la carte ne sont pas toujours évidentes à deviner. Généralement, vous pouvez espérer trouver quelque part une documentation officielle, ou tenter de voir les changements qui arrivent entre chaque utilisation de la carte. --[ 4 - BruteForcing de cartes non-identifiées ]--------------------------- Lorsque vous ne connaissez pas la classe ISO de la carte avec laquelle vous voulez jouer, vous pouvez "bruteforcer" la classe ISO. Ce n'est pas vraiment difficile si votre ordinateur sait compter de 0x00 à 0xFF. En récupérant les codes d'erreur de la carte, vous savez si la classe est le bonne parce que la carte vous envoie une erreur INS (6D 00), au lieu d'une erreur CLA (6E 00). Donc vous l'avez. Et les instructions sont publiques, donc je vous met quelques exemples, et les autres sont dans le standard ISO7816 et sur Internet... Deviner l'architecture d'une carte est une autre histoire. Essayez toujours l'instruction 0xB0 pour voir si vous pouvez lire quelques adresses, et vous pourrez interpréter les messages d'erreur si vous ne pouvez pas lire. Si la carte à puce possède un système de fichiers, vous pouvez le vérifier en sélectionnant (ins 0xA4) le répertoire racine 0x3FF0, et voir ce qui s'y passe. Obtenez une réponse pour voir s'il y a d'autres répertoires. Comme vous le savez le code d'erreur pour un faux P1 P2 (mauvaise adresse), vous pouvez également essayer d'évaluer la capacité de la carte : 8 Ko ? 64 Ko ? Cela ne fonctionne que s'il n'y a pas de système de fichiers, comme dans les cartes de crédit... Regardez les exemples ci-dessous : --[ 5 - Examples de mapping et de systèmes de fichiers ]------------------- ----[ 5.1 - Mapping d'une ancienne carte de crédit Française ]------------- Bull CP8 mask B0-B0' _____________________ $1000 | zone constructeur | |___________________| $09C0 | | | LECTURE LIBRE | |___________________| $07F8 | bulletin | | des transactions | |___________________| $03E8 | COMPTEUR D'ACCES | |___________________| $02B0 | ZONE SECRETE | |___________________| $0200 | N/A | |___________________| $0000 ----[ 5.2 - Système de fichiers des cartes SIM ]--------------------------- --GSM SIMcard 3F00 ROOT dir | \__2FE2 Card serial Number 7F10 TELECOM | |\__6F3A Directory |\__6F3B Fixed directory |\__6F3C SMS |\__6F40 Last calls |\__6F42 SMS pointer |\__6F43 SMS status |\__6F44 Dialing numbers |\__6F4A Extension 1 \__6F4B Extension 2 7F20 GSM | |\__6F05 Language |\__6F07 IMSI |\__6F20 Cyphering Key |\__6F30 Provider selector |\__6F31 Search Period |\__6F37 Account Max |\__6F38 Sim Service Table |\__6F39 Cumulated calls |\__6F3D Capability Config Param |\__6F3E Group ID 1 |\__6F3F Group ID 2 |\__6F41 Price per unit |\__6F45 Cell Broadcast msg ID |\__6F74 Broadcast Control Chan |\__6F78 Access Control Class |\__6F7B Providers Forbidden |\__6F7E Location Info |\__6FAD Admin data \__6FAE Phase ID Ensuite, vous pouvez log-er la communication entre votre carte SIM et votre téléphone mobile si vous voulez plus d'informations ;) --[ 6 - Crypter avec des cartes à puces ]-------------------------------------- Toutes les carte à puces peuvent crypter ou générer des certificats pour s'authentifier d'elles-mêmes à un terminal ou un fournisseur d'accès. La plupart des instructions de 0X80 à 0X8F sont utilisées pour le faire. Pour obtenir la réponse, demandez la simplement avec l'instruction 0xC0. Les Open Cards sont particulièrement faites pour de telles choses. "Open" signifie que vous pouvez trouver toutes les documentations que vous désirez à ce propos sur Internet (www.opensc.org), donc je ne m'y attarderai pas... Le système de cryptage dans les carte à puces sert surtout à authentifier la carte. Mais toute sa sécurité ne dépend pas seulement des mécanismes cryptographiques à l'intérieur de la carte. Le protocole est généralement la partie faible de l'authentification... --[ 7 - Bande magnétique ]------------------------------------------------- Les bandes magnétiques sont très communes. Comme c'est un moyen complètement passif d'authentification, elle peut facilement être clonée. Cependant, cela signifie aussi que toute la difficulté est l'interprétation des données contenues dans une bande et la compréhension des algorithmes pour crypter des données discrétionnaires [discretionnary data] dans le cas où vous voudriez générer votre propre carte, ou juste changer quelques informations. Vous aurez besoin pour cette partie d'un lecteur de bande magnétique. C'est très cher mais il est également possible de coder son propre pilote et de le faire avec un simple lecteur de cassettes. Vous pouvez essayer cmread http://www.afutgurluk.org/~ender/cmread.tgz pour un pilote en LPT1. Selon votre configuration hardware et software, vous obtiendrez plus ou moins facilement ces informations : la densité de l'encodage et le nombre de bits par caractère.Pour le nombre de bits par caractère, si vous avez lu avec le bon nombre de bits sans erreur, alors vous devez regarder les bits de parité. Normalement, le soft que vous avez utilisé pour lire la bande est à-même de faire une telle chose, sinon la méthode consisté à : - Prendre le premier bit égal à 1 - Regarder la parité sur les 5 premiers bits - Si ce n'est pas OK, alors essayer avec 6, 7, 8, ou 9 - Essayer avec le pack de [5,6,7,8,9] suivant, jusqu'à la fin - Vérifier le LRC Il y a deux moyens de détecter une erreur, le premier est le bit de parité, le second est le LRC, pour Longitudinal Redondancy Check [Véfification de la Redondance Longitudinale]. Le caractère de la piste est égal au XOR de tous les caractères. Il y a trois cas facilement reconnaissables : ----[ 7.1 - ISO ]---------------------------------------------------------- ISO-1 (210 bpi - 7 bits) : la bande est divisée en plusieurs parties : - '%' Start sentinel - 'B' Format code - Primary account number (le numéro de votre compte sur votre carte de crédit par exemple) - '^' Field separator [séparateur de champ] - Name of the owner [nom du propriétaire] - Field separator [séparateur de champ] - Expiration date (4 BCD numbers) - Service Code (101 for VISA, ...) - Discretionnary data - '?' End Sentinel - LRC Example : % B 0123456789012345 ^ MR SMITH JOHN ^ 9910 101 123456789000000123000000 ? Ce n'est pas nécessairement exactement comme ça, mais ça ne peur pas différer de beaucoup. ISO-2/3 (75 bpi - 5 bits): - ';' Start Sentinel - Primary Account Number - '=' Field separator - Expiration date - Service code - Discretionnary data - '?' End Sentinel - LRC Example: ; 01236789012345 = 9910 101 123456789000000123 ? Notez que le PAN (Primary Account Number) doit vérifier l'Algorithme de Lhun. Le standard est le ISO-7811 si vous voulez plus d'information... ----[ 7.2 - ALPHANUMERIQUE ]----------------------------------------------- C'est presque pareil que pour ISO, mais on a un peu moins de renseignements. Vous avez juste la même Start sentinel selon le nombre de pistes (1 : '%', 2 & 3 : ';'), les mêmes séparateurs de champ, et End Sentinel. Entre les Start et End sentinel, vous avez des données codées en BCD ou en ALPHA séparées par le séparateur de champ de la piste dont on parle. ----[ 7.3 - BINAIRE ]------------------------------------------------------ Gardez à l'esprit qu'il n'y a pas nécessairement une structure comme celle-là. Parfois les bits sont mis dans le désordre, comme si le concepteur de la bande était complètement bourré et jouait au dés avec ses potes pour savoir ce qu'il a allait faire... Essayez juste d'utiliser votre carte et tentez de comprendre ce qui a changé. --[ 8 - SmartCards synchrones ]-------------------------------------------- Je ne mets cette partie que juste pour faire un tour complet des carte à puces. Ce type de carte est vraiment nul [lame], elles sont de faible capacité (moins de 1 Kb en général), elles de respectent pas toujours le standard ISO pour les pins. Ce qui est certain c'est que vous avez 2 pins pour le Vcc et la masse, une pin pour l'Horloge, une pin pour le Reset, une pin pour les E/S, et parfois une pin pour le Vpp (programmation du voltage) et une pin pour le Write Enabled. Elles n'ont pas d'ATR. Elles ne réagissent que sur les tranches négatives de la pin de l'horloge en envoyant le bit suivant (ou le premier si elles a été resetée) de sa mémoire dans la pin E/S. Si vous pouvez écrire, vous aurez besoin d'un voltage différent dans la pin Vpp (jusqu'à 21 V) et brancher la pin d'écriture. Générallement, vous pouvez juste mettre un bit de 1 à 0 à cause de la technologie OTP (One Time Programmable) utilisée à l'intérieur (vous grillez un fusible dans le chip). Les cartes de téléphone françaises utilisent cette technologie (Merci, France TeleCom.) ;) [NDT : pour cette dernière remarque, en français dans le texte] --[ 9 - Programmation d'une carte pour du ISO7816 ]------------------------ Si vous pouvez lire cette ligne, c'est parce que Phrack a accepté mon article sans me demander de copier/coller certains de mes codes pour écrire un tutoriel sanglant pour coder votre propre émulateur de carte à puce en utilisant une pic de chez microchip (www.microchip.com) et donc vous devrez penser par vous-même si vous vous intéressez à l'écriture de tels programmes (ce n'est pas très évident ...). Comme je suis doux et attentionné, je vous donne l'architecture la plus commune : - Envoyer le ATR (à chaque reset ça redémarrera d'ici) - Attendre le premier octet (classe ISO) et vérifier que c'est bien le bon - Recevoir le second octet et le comparer avec chaque octet INS que vous avez implémenté, sinon renvoyer une erreur - Sauter à la partie de code écrite pour l'INS demandée et traiter les arguments - Ensuite vous avez deux choix (The Hacker's Choice is the best :p) : * utiliser une eeprom pour sauver toutes vos données, et ensuite les lire et les écrire pour terminer l'instruction demandée par le terminal * utiliser le flash PIC, en écrivant une liste de RETLW 0xXX, déterminer l'offset de l'octet dont on a besoin et ajouter simplement cet offset au compteur programme courant. Quelques conseils : - ISO 7816-3 is your friend ;) - Noubliez jamais le bit de parité pour envoyer les données, et aussi le ACK (ou NACK) lorsque vous recevez. - Attendez un ACK de la part du terminal, si c'est un NACK, envoyer à nouveau et ça fonctionnera. - Ecrivez votre propre code, cela vous évitera des bugs débiles que vous ne comprenez pas, qui pourraient vous mener en prison en cas de problème (Big Brother vous regarde toujours, vous ne pouvez pas vous tromper). - Ne faites pas de mauvaises choses, ne travaillez que sur un terminal émulé sur votre ordinateur :p - Google est votre ami pour trouver des URLs pour pour programmer des carte à puces basées sur des PICs. --[ 10 - Conclusion ]------------------------------------------------------ Nul besoin de travailler dans un laboratoire pour jouer avec la sécurité des carte à puces à un niveau intéressant. Ne croyez pas que S/DPA ou DFA est le seul moyen d'étudier les cartes. Certains articles sur de telles méthodes ont été écrits par des gens qui n'ont jamais vu un générateur de [glitch] de toute leur vie... Vous n'avez éventuellement besoin que d'un vieux 486 et un fer à souder en soldes pour trouver des trous de sécurité dans les protocoles de cartes à puces et ensuite acheter de la nourriture avec une carte de crédit émulée, appeler les amis avec une carte SIM faite main, regarder la télé numérique avec une carte à puce viaccess/seca faite main, et entrer dans la plupart des endroits protégés par carte magnétique ou à puce. Ou la garder rien que pour vous ;) --[ 11 - Remerciements ]--------------------------------------------------- Roland Moreno ;) --[ 12 - Bibliography ]---------------------------------------------------- -PC et Cartes a puce, Patrick Gueule -Ender's Game, Orson Scott Card -The Hitchhiker's Trilogy, Douglas Adams -Discworld, Terry Pratchett --[ Annexe A : log de communication - old_log.txt (uuencodé) ------------- <++> ./old_log.txt.uue begin 744 old_log.txt M("`@("`@("`@("`@("`@(",C(R,C(R,C(R,C(R,C(R,C(R,C(R,C(R,C(R,C M(R,C(R,C#0H@("`@("`@("`@("`@("`@(R`@("`@("`@("`@("`@("`@("`@ M("`@("`@("`@("`@(",-"B`@("`@("`@("`@("`@("`C("!(3U=43R`Z(%!A M>2!7:71H(%9I2`R-3`@.B!F'!O;F5N="!E(#T@,RP@5FES M82!#87)D("@T.32D@9F]R($-!22P@7!H97)I;F<@*$-"0R!-;V1E*0T*("`@(#=&(`T*("`@ M(#X^,C$-"B`@("`W1B`-"B`@("`^/C4T#0H@("`@-T8@#0H@("`@/CXP.0T* M("`@(#=&(`T*("`@(#X^,#`-"B`@("`W1B`-"B`@("`^/C`X#0H@("`@-T8@ M#0H@("`@/CY&-2`@("`-"B`@("`W1B`-"B`@("`^/C`X#0H@("`@-T8@#0H@ M("`@/CY$,"`@("`@("`@("`@("`\+2T@,C$@-30@,#D@,#`@,#@@1C4@6S`X M($0P72`-"B`@("`Y,"`P,"`-"@T*("`@(#X^0D,@0S`@,#`@,#`@,#@@/"TM M(%)E861I;F<@7!H97)I;F<-"B`@("`W1B`-"B`@("`^/C`Y#0H@("`@-T8@#0H@ M("`@/CXR,`T*("`@(#=&(`T*("`@(#X^,4,-"B`@("`W1B`-"B`@("`^/D,S M#0H@("`@-T8@#0H@("`@/CXQ1@T*("`@(#=&(`T*("`@(#X^1C<-"B`@("`W M1B`-"B`@("`^/C`X#0H@("`@-T8@#0H@("`@/CY$,"`@("`@("`@("`@("`\ M+2T@,#D@,C`@,4,@0S,@,48@1C<@6S`X($0P70T*("`@(#DP(#`P(`T*#0H@ M("`@/CY"0R!#,"`P,"`P,"`P."`\+2T@4F5A9&EN9R!R97-U;'0-"B`@("!# M,"`@("`@("`@("`@("`@(`T*("`@(#`Y(#(P(#%#($,S(#%&($8W(#`X($0P M(#PM+2!#04D@*'=H870@:7,@;VX@=&AE(&YO=&4I#0H@("`@.3`@,#`@#0H- M"B\J*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ M*BHJ*BHJ*BHJ*BHJ*BH-"B`J(%)E860@5')A;G-A8W1I;VX@8G5L;&5T:6X@ M86YD('=R:71E('1R86YS86-T:6]N("`@("`@("H-"B`J("HJ*BHJ*BHJ*BHJ M*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHJ*BHO M#0H-"B`@("`^/D)#($(P(#`R($(P($9#(#PM+2!296%D:6YG('1R86YS86-T M:6]N(&)U;&QE=&EN(#H@0414#0H@("`@0C`@(`T*("`@(#,P(#`P(#DY(#$Q M("`@("`@/"TM($1U2`Z(#$X,RP@3&]C871I;VX@,#$L(%!E#7!H97)I;F<@*#-R9"!K97DI M+"!386QT(#T@,#D@-3`-"B`@("`W0B`-"B`@("`^/C(V#0H@("`@-T(@#0H@ M("`@/CY$1@T*("`@(#="(`T*("`@(#X^138-"B`@("`W0B`-"B`@("`^/C)" M#0H@("`@-T(@#0H@("`@/CY&0PT*("`@(#="(`T*("`@(#X^1C$-"B`@("`W M0B`-"B`@("`^/C`Y#0H@("`@-T(@#0H@("`@/CXU,"`@("`@("`@("`@("`\ M+2T@,C8@1$8@138@,D(@1D,@1C$@6S`Y(#4P70T*("`@(#DP(#`P(`T*#0H@ M("`@/CY"0R!#,"`P,"`P,"`P."`\+2T@4F5S=6QT#0H@("`@0S`@(`T*("`@ M(#(V($1&($4V(#)"($9#($8Q(#`Y(#4P(`T*("`@(#DP(#`P(`T*#0H@("`@ M/CY"0R!","`P.2`V."`P-"`-"B`@("!","`-"B`@("`S,2`P,2`Y.2`Q,2`@ M("`@(#PM+2!296%D:6YG(&9A8G)I8V%T:6]N(&1A=&4@9F]R('-A;'0-"B`@ M("`Y,"`P,"`-"@T*("`@(#X^0D,@.#0@,#`@,#`@,#@@/"TM($-Y<&AE