Carte à puce : Support matériel d'authentification, sécurité et pratique avec Python

La carte à puce, ou Smart Card, est un dispositif électronique miniaturisé qui intègre un circuit capable de mémoriser des informations et, dans le cas d'une carte à microprocesseur, d'exécuter des instructions. Elle intervient dans de nombreux systèmes d'authentification : cartes bancaires, cartes SIM, cartes professionnelles, titres d'identité électroniques et solutions de signature numérique. Son intérêt ne réside pas uniquement dans le stockage : certaines cartes peuvent effectuer des opérations cryptographiques à l'intérieur d'un composant protégé, de sorte qu'une application utilise une clé privée sans pouvoir la lire directement. Ce tutoriel explique les principes techniques, les usages, les risques et les manipulations possibles avec Python, en distinguant soigneusement les simulations logicielles des opérations nécessitant du matériel.

1. À propos des cartes à puce en cybersécurité

Définition d'une carte à puce

Une carte à puce est un support matériel contenant un ou plusieurs circuits intégrés. Selon le modèle, le circuit permet de stocker des données, de vérifier des conditions d'accès, d'exécuter des programmes ou de réaliser des opérations cryptographiques. Il faut distinguer les simples cartes à mémoire, dont les possibilités sont limitées, des cartes à microprocesseur qui disposent d'un environnement d'exécution et de fonctions de sécurité plus élaborées. Toutes les cartes à puce n'offrent donc pas le même niveau de protection.

Pourquoi les cartes à puce sont-elles importantes ?

Lorsqu'un mot de passe ou une clé secrète est conservé uniquement dans un fichier de l'ordinateur, un logiciel malveillant disposant de privilèges suffisants peut parfois le récupérer. Une carte cryptographique cherche à réduire ce risque en isolant certaines informations sensibles dans un composant distinct. L'ordinateur transmet une demande, par exemple signer un défi, et la carte renvoie le résultat de l'opération sans révéler nécessairement la clé privée. Cette séparation renforce la sécurité, mais elle ne protège pas automatiquement contre toutes les attaques provenant d'un ordinateur compromis.

Carte à puce et identité numérique

L'identité numérique représente un ensemble d'informations permettant d'identifier ou d'authentifier une personne ou une entité dans un système informatique. Une carte à puce peut contenir un identifiant, un certificat numérique et une clé cryptographique associée à cette identité. Lors d'une connexion à un service, la carte peut contribuer à prouver la possession de la clé. L'application doit toutefois vérifier les autorisations et la validité des certificats : posséder une carte ne signifie pas automatiquement avoir accès à toutes les ressources.

Facteur de possession et authentification multifacteur

Les mécanismes d'authentification reposent souvent sur trois grandes catégories de facteurs : quelque chose que l'on connaît (un code PIN), quelque chose que l'on possède (une carte) et quelque chose que l'on est (une caractéristique biométrique). Une carte cryptographique peut jouer le rôle de facteur de possession. Lorsqu'une opération exige également un code PIN indépendant, le système peut combiner possession et connaissance. Pour obtenir une authentification multifacteur efficace, les deux facteurs doivent être vérifiés correctement et ne pas être neutralisés par une mauvaise configuration.

Différence entre carte à puce et carte magnétique

Une carte à bande magnétique conserve des données sur une piste magnétique qui peut être lue par un lecteur adapté. La bande n'exécute pas de programme cryptographique. À l'inverse, une carte à microprocesseur peut appliquer des règles d'accès et produire des réponses cryptographiques dépendant de secrets internes. Cette différence explique pourquoi les cartes à puce sont privilégiées dans de nombreux systèmes d'authentification et de paiement modernes, même si leur sécurité dépend toujours du protocole utilisé et de sa mise en œuvre.

Avantages et limites

Les avantages principaux sont la portabilité, l'isolation de certaines clés, la possibilité d'une authentification matérielle et l'intégration à des infrastructures de certificats. Les limites comprennent la perte ou le vol du support, les coûts de lecteurs et de gestion, les problèmes de compatibilité, les risques de blocage du PIN et la dépendance à la sécurité du poste hôte. Une organisation doit donc prévoir des procédures d'enrôlement, de remplacement, de révocation et de récupération d'accès.

2. Architecture matérielle et fonctionnement

Circuit intégré et microprocesseur

Le circuit intégré constitue le cœur électronique de la carte. Dans une carte à microprocesseur, le processeur exécute les instructions du système embarqué, interprète les commandes reçues et vérifie les permissions avant d'effectuer certaines opérations. Ses ressources sont généralement plus limitées que celles d'un ordinateur classique : capacité mémoire réduite, puissance de calcul adaptée aux tâches prévues et interfaces de communication spécifiques. Cette architecture spécialisée contribue à limiter la surface d'attaque, sans la supprimer.

ROM, RAM et mémoire non volatile

La ROM peut contenir des composants installés lors de la fabrication. La RAM conserve temporairement les données nécessaires aux calculs et perd son contenu lorsque l'alimentation est interrompue. Une mémoire non volatile, telle que l'EEPROM ou la Flash, conserve des paramètres, des applications ou des objets de données après extinction. Les caractéristiques d'écriture, d'endurance et de protection varient selon les fabricants. Les données sensibles ne sont pas nécessairement accessibles par de simples commandes de lecture, même lorsqu'elles sont stockées en mémoire non volatile.

Coprocesseur cryptographique

Une carte cryptographique peut intégrer un coprocesseur cryptographique optimisé pour des opérations telles que RSA, les courbes elliptiques ou certains algorithmes symétriques. Ce composant permet à la carte de signer un message, de participer à une authentification ou de traiter une opération de chiffrement selon ses capacités. Le bénéfice majeur est de pouvoir exécuter certaines opérations sur des clés protégées à l'intérieur du support. La disponibilité des algorithmes et des tailles de clés doit être vérifiée dans la documentation du modèle.

Génération de nombres aléatoires

Les protocoles cryptographiques ont besoin de valeurs imprévisibles, notamment pour générer des clés ou répondre à des défis. Certaines cartes disposent d'un générateur matériel de nombres aléatoires et de mécanismes de contrôle de qualité. Une mauvaise source d'aléa peut affaiblir des clés ou rendre certaines réponses prévisibles. Dans une simulation Python, le module secrets permet d'obtenir des valeurs adaptées aux usages cryptographiques ordinaires, mais il ne reproduit pas à lui seul les protections d'un composant matériel sécurisé.

Système d'exploitation embarqué

Le système d'exploitation de carte à puce organise les applications et contrôle les échanges avec le lecteur. Il peut gérer des fichiers, des objets cryptographiques, des compteurs d'essais et des conditions d'accès. Certaines plateformes, comme Java Card, permettent d'exécuter des applications spécialisées. D'autres cartes utilisent un système fermé dédié à un usage précis, comme les télécommunications ou le paiement. Il n'existe pas de système de fichiers ou de jeu de commandes universellement identique sur toutes les cartes.

Interface avec le lecteur

Une carte à contact reçoit son alimentation et échange des signaux au moyen de contacts électriques. Une carte sans contact communique par radio avec un lecteur compatible. Le lecteur sert d'intermédiaire entre le logiciel de l'ordinateur et la carte. Dans les applications de bureau, l'interface PC/SC permet souvent d'accéder au lecteur sans devoir gérer directement les détails électriques du protocole. Les étapes d'initialisation et les données retournées peuvent différer selon le type de carte et de lecteur.

Cycle d'une opération sécurisée

Lorsqu'un utilisateur souhaite s'authentifier, l'application identifie la carte et sélectionne éventuellement l'application embarquée appropriée. La carte peut demander une vérification du PIN avant d'autoriser une opération. Le serveur transmet ensuite un défi imprévisible, que la carte signe avec une clé protégée. Le serveur vérifie la signature avec la clé publique correspondante et applique ses propres règles d'autorisation. Ce cycle illustre pourquoi l'authentification matérielle repose sur plusieurs composants et non sur le seul stockage d'un identifiant.

3. Types de cartes à puce et applications

Cartes à mémoire et cartes à microprocesseur

Une carte à mémoire sert principalement à conserver des informations, parfois avec des protections d'accès simples. Elle convient à des usages où le stockage est la fonction principale. Une carte à microprocesseur exécute des instructions et peut appliquer des règles de sécurité plus élaborées. Cette dernière catégorie est particulièrement importante pour l'authentification cryptographique, car elle peut produire une signature ou une réponse sans communiquer directement certains secrets au lecteur.

Cartes à contact, sans contact et à double interface

Les cartes à contact nécessitent une insertion physique dans un lecteur, ce qui établit une connexion électrique. Les cartes sans contact échangent des données à courte distance par radio et sont appréciées pour la rapidité d'utilisation dans les transports, le contrôle d'accès ou certains paiements. Les cartes à double interface proposent les deux modes. Le choix dépend de l'usage, des exigences de sécurité, de l'ergonomie et de la compatibilité avec les lecteurs existants.

Cartes bancaires EMV

Les cartes bancaires utilisant les spécifications EMV participent à des protocoles de paiement qui peuvent produire des données cryptographiques propres à une transaction. Cette capacité aide à limiter certains risques associés à la simple copie de données statiques. Le fonctionnement exact dépend de l'application de paiement, du terminal, du mode de transaction et des règles de l'émetteur. Une carte EMV ne doit pas être assimilée à une carte de laboratoire générique acceptant librement toutes les commandes APDU.

Cartes SIM et USIM

Les cartes SIM et USIM hébergent des informations et des applications participant à l'identification de l'abonné dans les réseaux mobiles. Elles prennent part à des mécanismes d'authentification utilisant des secrets et des protocoles propres aux réseaux cellulaires. Leur rôle dépasse le simple stockage d'un numéro de téléphone. L'accès aux informations sensibles est strictement contrôlé et les commandes disponibles dépendent des spécifications et des droits accordés.

Cartes d'identité électroniques

Une carte d'identité électronique peut intégrer des informations d'identification, des certificats ou des fonctionnalités de signature et d'authentification. Les services disponibles diffèrent selon les pays et les générations de documents. Certaines données sont publiques, d'autres nécessitent une autorisation ou un protocole d'accès spécifique. L'existence d'une puce ne signifie donc pas que toutes les données du document peuvent être librement lues avec un lecteur ordinaire.

Badges professionnels et cartes PIV

Dans une organisation, un badge à puce peut être utilisé pour ouvrir des portes, accéder à un poste de travail ou s'authentifier auprès d'un réseau. Les cartes PIV constituent un exemple de système structuré autour d'identifiants, de certificats et de clés. Une même carte peut ainsi soutenir plusieurs usages, à condition que les applications et les politiques de sécurité soient correctement configurées. La désactivation des droits doit être rapide lorsqu'un collaborateur quitte l'organisation.

OpenPGP Card et Java Card

Une OpenPGP Card peut conserver des clés utilisées pour la signature, le déchiffrement ou l'authentification selon son profil. La technologie Java Card fournit, quant à elle, un environnement permettant de développer des applications embarquées adaptées aux contraintes des cartes à puce. Ces deux notions ne désignent pas la même chose : la première correspond à une famille d'applications et de fonctions cryptographiques, tandis que la seconde désigne une plateforme de développement et d'exécution.

4. Stockage des informations et authentification

Quelles informations une carte peut-elle conserver ?

Selon son modèle, une carte peut contenir un identifiant, des objets de données, des certificats numériques, des clés cryptographiques et des paramètres de sécurité. Certaines informations servent à décrire le titulaire, d'autres à réaliser des opérations d'authentification. Il faut distinguer les données accessibles au logiciel hôte des secrets conservés dans un espace protégé. Une clé privée non exportable, par exemple, peut être utilisée par la carte sans être lisible par l'application qui demande une signature.

Code PIN : définition et fonctionnement détaillé

Le Personal Identification Number, ou PIN, est un code secret généralement connu du titulaire de la carte. Il sert à autoriser certaines opérations sensibles : déverrouiller une fonction cryptographique, accéder à une application ou confirmer une opération. Lorsqu'un utilisateur saisit son PIN, le logiciel ou le lecteur transmet la demande de vérification selon le protocole prévu. Dans de nombreuses cartes sécurisées, la comparaison avec la référence protégée est réalisée à l'intérieur de la carte. L'application reçoit alors un statut de réussite ou d'échec, sans nécessairement connaître la valeur de référence.

Le PIN est souvent soumis à un nombre limité de tentatives. Par exemple, un profil de carte peut prévoir trois essais avant blocage, mais ce seuil n'est pas universel. Cette restriction réduit le risque d'essais répétés de codes. Une carte peut aussi imposer une longueur minimale, une politique de changement de PIN ou une vérification distincte pour différentes fonctions. Le PIN ne doit jamais être enregistré en clair dans un script de production, dans un journal applicatif ou dans un fichier de configuration non protégé.

Code PUK : déblocage et précautions

Le Personal Unblocking Key, ou PUK, est un code de déblocage présent dans certains systèmes, notamment les cartes SIM et certaines cartes cryptographiques. Lorsqu'un PIN est bloqué après plusieurs erreurs, une procédure autorisée peut permettre de définir un nouveau PIN au moyen d'un PUK ou d'une autre information d'administration. Le PUK ne constitue pas simplement un second PIN : il correspond à une fonction de récupération ou de déblocage, généralement soumise à des règles de sécurité spécifiques.

Le nombre d'essais du PUK peut lui aussi être limité. Des erreurs répétées peuvent conduire à un blocage durable ou définitif de certaines fonctions, selon le support. Certaines cartes professionnelles ne proposent d'ailleurs pas de PUK utilisable par le titulaire : le déblocage peut nécessiter l'intervention d'un administrateur ou le remplacement de la carte. Il est donc essentiel de consulter la documentation officielle et de ne jamais expérimenter des codes sur une carte personnelle, bancaire ou professionnelle.

Clé privée et clé publique

Dans la cryptographie asymétrique, une paire de clés comprend une clé privée et une clé publique mathématiquement liées. La clé privée doit rester confidentielle, tandis que la clé publique peut être distribuée aux systèmes chargés de vérifier certaines opérations. Une carte cryptographique peut générer une clé privée en interne et empêcher son exportation. Lors d'une authentification, la carte signe un défi et le serveur vérifie la signature avec la clé publique correspondante. Ce mécanisme est plus robuste qu'une simple comparaison d'identifiants copiables lorsque les paramètres et les protocoles sont correctement choisis.

Certificat numérique et PKI

Un certificat numérique associe une clé publique à une identité ou à une entité et comporte des informations comme l'émetteur, la période de validité et les usages autorisés. Une infrastructure à clés publiques, ou PKI, organise la délivrance, la gestion et la révocation des certificats. Lorsqu'une carte présente un certificat, le serveur doit notamment vérifier la chaîne de confiance, la validité temporelle, les usages autorisés et, lorsque cela est requis, l'état de révocation. Le certificat seul ne prouve pas la possession de la clé privée : cette preuve intervient lors de l'opération cryptographique.

Authentification par défi-réponse

Le protocole Challenge-Response consiste à envoyer une valeur imprévisible appelée défi à un composant qui détient un secret. La carte calcule une réponse cryptographique liée à ce défi. Le vérificateur contrôle ensuite la réponse. L'utilisation d'un défi nouveau à chaque session permet de réduire les risques de rejeu, c'est-à-dire la réutilisation d'une ancienne réponse capturée. Dans un système asymétrique, le vérificateur peut utiliser une clé publique ; dans un système symétrique, il doit disposer d'un secret partagé ou d'un mécanisme de vérification approprié.

Non-exportabilité et limites de protection

La non-exportabilité signifie qu'une clé est conçue pour rester à l'intérieur du composant sécurisé. L'ordinateur peut demander à la carte d'utiliser cette clé, mais ne dispose pas d'une commande normale pour en récupérer la valeur. Cette propriété réduit le risque de copie directe du secret. Toutefois, un poste compromis peut parfois tenter de déclencher des opérations non souhaitées tant que la carte est accessible et déverrouillée. La sécurité doit donc inclure la protection du poste, les confirmations d'opération, les politiques de session et les contrôles côté serveur.

5. Normes, protocoles et commandes APDU

ISO/IEC 7816 et ISO/IEC 14443

La famille ISO/IEC 7816 décrit plusieurs aspects des cartes à circuit intégré, notamment des interfaces et des structures de commandes. La famille ISO/IEC 14443 concerne les cartes de proximité et leurs communications sans contact. Ces normes fournissent un cadre d'interopérabilité, mais ne signifient pas que toutes les cartes exposent les mêmes applications, fichiers ou commandes. Le développeur doit toujours identifier le profil précis de la carte utilisée.

PC/SC : communication entre ordinateur et lecteur

Le standard PC/SC fournit une interface logicielle permettant aux applications de détecter des lecteurs, de se connecter à une carte et d'échanger des données. Sur Windows, cette interface s'appuie notamment sur le service de carte à puce du système. Sous Linux, elle est couramment fournie par une pile comprenant pcsc-lite et les pilotes appropriés. La bibliothèque Python pyscard exploite cette interface. PC/SC n'est pas une méthode d'authentification en soi : c'est un moyen de communication avec le matériel.

ATR et initialisation

L'Answer To Reset, ou ATR, est une réponse d'initialisation associée aux cartes à contact. Elle renseigne le lecteur sur certaines caractéristiques de communication. Dans des environnements sans contact, le lecteur et la couche PC/SC peuvent présenter des informations d'initialisation adaptées à leur fonctionnement ; il faut éviter d'interpréter systématiquement toute valeur retournée comme un ATR physique identique à celui d'une carte à contact. La valeur dépend du support, de son protocole et parfois du lecteur.

Structure d'une commande APDU

Une Application Protocol Data Unit, ou APDU, est un message échangé avec une application de carte compatible. Une commande comprend généralement les champs CLA (classe), INS (instruction), P1 et P2 (paramètres). Selon la commande, elle peut aussi contenir Lc (longueur des données), Data (données) et Le (longueur attendue de la réponse). Les formats courts et étendus ainsi que les règles d'encodage dépendent du protocole et des capacités de la carte.

ChampSignificationRôle
CLAClasseIdentifie une catégorie de commande ou un contexte.
INSInstructionIndique l'opération demandée.
P1 et P2ParamètresPrécisent le mode de traitement.
LcLongueurIndique la quantité de données envoyées, si applicable.
DataDonnéesTransporte les paramètres ou objets de la commande.
LeLongueur attendueIndique la taille de réponse souhaitée, si applicable.

Réponse APDU et octets de statut

Une réponse APDU peut contenir des données suivies de deux octets de statut, SW1 et SW2. Le code 90 00 indique généralement une exécution normale dans de nombreuses applications ISO 7816. D'autres codes peuvent signaler un paramètre incorrect, une fonction non prise en charge ou une condition de sécurité non satisfaite. Il est dangereux de conclure au succès ou à l'échec d'une opération en ignorant la documentation de l'application.

Commandes SELECT, READ BINARY, VERIFY et GET DATA

SELECT permet notamment de sélectionner une application ou un fichier. READ BINARY peut lire des données dans certains fichiers accessibles. VERIFY sert à vérifier une référence d'authentification, par exemple un PIN, lorsqu'une application le prévoit. GET DATA peut demander des objets de données identifiés. Ces instructions ne sont pas universellement disponibles et leurs paramètres varient. En particulier, une commande VERIFY peut diminuer un compteur d'essais : elle ne doit pas être testée au hasard sur une carte réelle.

Pourquoi documenter chaque commande ?

Une commande APDU mal construite peut être refusée, sélectionner un mauvais contexte ou déclencher une opération inattendue. Un laboratoire sérieux doit identifier le modèle de carte, les applications installées, les identifiants AID, les commandes autorisées et leurs réponses possibles. Les exemples matériels de ce tutoriel restent limités à des opérations de découverte et de lecture sur un support de test expressément autorisé.

6. Sécurité, vulnérabilités et bonnes pratiques

Vol, perte et utilisation abusive

La perte d'une carte peut empêcher son titulaire de s'authentifier et créer un risque d'utilisation abusive si un tiers la récupère. La protection par PIN, les compteurs d'essais et la désactivation des droits réduisent ce risque, mais ne remplacent pas une procédure de signalement. Une organisation doit pouvoir suspendre rapidement les accès associés à une carte perdue et délivrer un nouveau support lorsque cela est nécessaire.

Attaques par canaux auxiliaires

Les attaques par canaux auxiliaires cherchent à déduire des informations sensibles à partir de phénomènes indirects, tels que les variations de temps, de consommation électrique ou d'émissions électromagnétiques. Elles ne consistent pas nécessairement à lire directement la mémoire. Les fabricants de composants sécurisés peuvent utiliser des contre-mesures matérielles et logicielles pour limiter ces fuites. Leur efficacité dépend du produit, de l'algorithme et des conditions d'utilisation.

Injection de fautes

Les attaques par injection de fautes visent à perturber temporairement le fonctionnement d'un circuit afin de provoquer un comportement incorrect. Une carte sécurisée peut disposer de mécanismes de surveillance, de vérification d'intégrité ou d'arrêt lorsqu'une anomalie est détectée. L'évaluation de telles protections relève de laboratoires spécialisés. Pour l'apprentissage courant, il est préférable de se concentrer sur la documentation des mécanismes et sur des simulations logicielles sans intervention physique sur le composant.

Ordinateur ou lecteur compromis

Même si une clé privée reste à l'intérieur de la carte, un logiciel malveillant présent sur l'ordinateur peut tenter d'intercepter des informations affichées, de modifier une opération avant sa signature ou d'abuser d'une session déjà déverrouillée. La carte protège certains secrets, mais ne garantit pas à elle seule l'intégrité de l'ensemble de l'opération. Il faut donc protéger les postes, utiliser des logiciels fiables et, lorsque le contexte le justifie, des lecteurs disposant de mécanismes de saisie ou de confirmation sécurisés.

Révocation, expiration et remplacement

La révocation d'un certificat consiste à signaler qu'il ne doit plus être considéré comme valide avant sa date normale d'expiration. La désactivation d'une carte et la révocation de ses certificats sont des opérations distinctes. Une carte perdue peut nécessiter la suspension de comptes, la révocation de certificats, la suppression de droits physiques et la délivrance d'un nouveau support. La politique de gestion doit préciser qui est autorisé à effectuer ces actions et comment les événements sont journalisés.

Bonnes pratiques opérationnelles

Il est recommandé d'utiliser des cartes et lecteurs provenant de fournisseurs fiables, de choisir des algorithmes adaptés, de protéger le PIN, de limiter les tentatives, de vérifier la chaîne de confiance des certificats et de mettre à jour les composants logiciels. Les organisations doivent aussi former les utilisateurs à la perte de carte, à la confidentialité du PIN et aux demandes d'authentification inhabituelles. Les essais techniques doivent être réalisés sur des cartes de laboratoire et jamais sur des supports bancaires ou d'identité sans autorisation explicite.

7. Simulations de cartes à puce avec Python

Les exemples de cette section sont entièrement locaux et ne nécessitent ni lecteur ni carte réelle. Ils servent à comprendre les notions de données d'identification, de PIN, de permissions, de défi-réponse et de révocation. Une simulation Python ne bénéficie pas des propriétés d'isolation d'une véritable carte cryptographique.

Exemple 1 : représenter une carte à puce

Ce programme crée un dictionnaire décrivant une carte fictive. Il montre comment structurer les informations d'inventaire d'un support sans enregistrer de secret. Cette approche peut servir de point de départ à un outil pédagogique de gestion des cartes.

Output :

Exemple 2 : simuler le stockage de métadonnées

Une carte peut contenir des objets de nature différente. Dans cette simulation, seules des métadonnées sont représentées : un identifiant, une référence de certificat et une indication de protection de clé. La valeur réelle d'une clé privée n'est jamais placée dans le dictionnaire.

Output :

Exemple 3 : vérifier un PIN fictif

Ce programme compare deux chaînes de caractères pour illustrer le principe d'une vérification de PIN. La comparaison est volontairement simplifiée : sur une carte sécurisée, la référence du PIN peut être protégée et la vérification effectuée à l'intérieur du composant. Il ne faut pas conserver de PIN réel en clair dans le code source.

Output :

Exemple 4 : refuser un PIN incorrect

Ce second exemple montre le comportement inverse : une valeur différente de celle attendue conduit à un refus. Le mécanisme illustre une règle d'accès, mais n'intègre pas encore le suivi des échecs ni la protection matérielle.

Output :

Exemple 5 : simuler un blocage après trois échecs

Les compteurs d'essais empêchent qu'un PIN puisse être essayé indéfiniment. Le programme suivant simule trois réponses incorrectes et bloque la carte fictive. Dans une véritable carte, le compteur est généralement géré par le composant et ne doit pas pouvoir être remis à zéro par le simple redémarrage de l'application.

Output :

Exemple 6 : gérer des permissions

Une carte peut autoriser certaines opérations tout en interdisant l'accès direct à des objets sensibles. Ce dictionnaire représente une politique fictive : la lecture d'un identifiant est permise, tandis que la lecture d'une clé privée est refusée. Les vraies politiques d'accès peuvent dépendre du PIN, de l'application sélectionnée et de l'état de sécurité de la carte.

Output :

Exemple 7 : refuser l'exportation d'une clé

Ce programme représente une règle de non-exportabilité. Il n'effectue aucun calcul cryptographique, mais distingue clairement le droit d'utiliser une clé du droit de la lire. Une carte réelle doit faire appliquer cette restriction par son matériel ou son système embarqué.

Output :

Exemple 8 : authentification par HMAC

La fonction HMAC calcule un code d'authentification à partir d'un secret partagé et d'un message. Cet exemple reproduit le principe d'un défi-réponse symétrique : les deux parties utilisent le même secret fictif pour calculer et vérifier une réponse. Il ne reproduit pas la signature asymétrique d'une carte PIV et ne doit pas être confondu avec un système matériel de production.

Output :

Exemple 9 : rejeter une réponse associée à un autre défi

Une réponse cryptographique doit être liée au défi transmis pour la session en cours. Le programme suivant calcule deux HMAC avec la même clé, mais avec des défis différents. Les réponses ne correspondent pas, ce qui illustre l'importance de lier l'authentification à un échange précis.

Output :

Exemple 10 : générer un défi imprévisible

Le module secrets produit des octets aléatoires adaptés aux besoins cryptographiques usuels. Ici, le défi comporte seize octets, soit 128 bits. Sa valeur change à chaque exécution et ne doit pas être réutilisée dans des sessions indépendantes. Le programme affiche seulement sa longueur pour garantir une sortie reproductible.

Output :

Exemple 11 : représenter un certificat

Un certificat réel est une structure signée contenant une clé publique et des attributs précis. Le dictionnaire suivant n'est qu'une fiche descriptive fictive permettant d'identifier les notions de sujet, d'émetteur et de numéro de série. Il ne permet ni de vérifier une signature ni de construire une chaîne de confiance X.509.

Output :

Exemple 12 : simuler la révocation d'une carte

Lorsqu'une carte est déclarée perdue, une organisation peut désactiver ses droits et révoquer les certificats concernés. Cet exemple utilise une liste locale d'identifiants révoqués pour illustrer une décision d'accès. Dans un véritable système, la révocation de la carte et celle de ses certificats doivent être coordonnées avec les services responsables.

Output :

8. Utilisation d'un lecteur PC/SC avec Python

Matériel et prérequis

Pour communiquer avec une véritable carte, il faut un lecteur compatible PC/SC, une carte de test appropriée, des pilotes fonctionnels et un environnement Python. Sous Windows, le service de carte à puce doit être disponible ; sous Linux, une installation PC/SC peut être nécessaire. Il faut aussi connaître les commandes prises en charge par la carte. Un lecteur détecté ne garantit pas qu'une carte soit présente, et une carte présente ne garantit pas qu'elle accepte une commande donnée.

Installation de pyscard

La bibliothèque pyscard fournit une interface Python vers les fonctions PC/SC. Son installation s'effectue dans un terminal avec pip. Selon le système, des dépendances ou outils de compilation peuvent être requis. La commande ci-dessous est une commande de terminal, présentée dans le format de code demandé pour le tutoriel.

Output possible :

Le message exact et le numéro de version dépendent de l'environnement.

Exemple 13 : détecter les lecteurs

Avant d'établir une connexion, il faut vérifier qu'un lecteur est reconnu. La fonction readers() renvoie la liste des lecteurs accessibles par PC/SC. Le programme affiche leur nombre et leur nom. Si la liste est vide, il faut vérifier la connexion physique, les pilotes et le service de carte à puce.

Output possible :

Le nom affiché ici est illustratif : il dépend du matériel installé.

Exemple 14 : se connecter à une carte de test

Une fois le lecteur identifié, createConnection() crée un objet de connexion et connect() tente d'établir la communication avec la carte. Une exception peut survenir si la carte est absente ou incompatible. Le bloc finally permet de libérer la connexion lorsque cela est possible.

Output possible :

Exemple 15 : lire l'ATR

Après la connexion, la méthode getATR() retourne les octets d'initialisation exposés par l'interface PC/SC. La fonction toHexString() facilite leur affichage en hexadécimal. Cette lecture ne demande pas de PIN et sert principalement au diagnostic de communication. L'interprétation des octets nécessite néanmoins de connaître le type de carte et les particularités éventuelles du lecteur.

Output possible :

Cette valeur est illustrative ; l'ATR réel varie selon la carte.

Exemple 16 : construire une APDU sans l'envoyer

Pour comprendre la structure d'une commande, on peut commencer par manipuler une liste d'octets. Ici, 00 A4 04 00 00 représente une forme de commande SELECT avec champ de données vide. Elle est affichée localement et n'est envoyée à aucune carte. Cette construction ne signifie pas que la commande serait acceptée par un support réel.

Output :

Exemple 17 : interpréter les octets de statut

Une réponse APDU comporte souvent deux octets finaux indiquant le résultat du traitement. Dans cet exemple fictif, le statut 90 00 est reconnu comme une exécution normale. Les autres codes ne doivent pas être interprétés à l'aveugle : leur sens exact dépend de la norme et de l'application concernée.

Output :

Exemple 18 : analyser une réponse APDU fictive

Le programme suivant sépare les données retournées par une carte des octets de statut. Cette distinction est essentielle : les données peuvent être absentes même lorsque la commande est correctement exécutée, et une réponse contenant des données peut nécessiter une analyse complémentaire du statut.

Output :

Exemple 19 : sélectionner une application de laboratoire documentée

Dans une carte compatible ISO 7816, une application peut être sélectionnée au moyen de son Application Identifier, ou AID. L'exemple ci-dessous construit une commande SELECT avec un AID fictif de laboratoire. Il n'effectue aucune transmission : l'objectif est de montrer le placement des octets CLA, INS, P1, P2, Lc et Data. Pour communiquer réellement, il faut remplacer cet AID par celui d'une application explicitement documentée et autorisée.

Output :

Exemple 20 : envoyer une APDU documentée à une carte de test

Ce dernier exemple illustre la transmission effective d'une commande avec connexion.transmit(). Il doit être adapté à une carte de laboratoire dont la documentation autorise explicitement la sélection de l'AID choisi. La valeur fictive ci-dessous ne correspond pas à une application garantie présente ; la commande sera donc souvent rejetée. Aucune commande de vérification de PIN, de modification de données ou de suppression n'est utilisée.

Output possible :

Le statut est illustratif. Selon la carte, le lecteur et les applications présentes, la réponse peut être différente.

Mini projet pédagogique

Pour consolider les connaissances, on peut développer une application Python de gestion de cartes fictives : inventaire des supports, état actif ou révoqué, simulation de PIN, compteurs d'échecs, génération de défis, contrôle des permissions et journal des authentifications. Dans une seconde étape, un lecteur PC/SC et une carte de laboratoire peuvent être ajoutés pour afficher les lecteurs, lire les données d'initialisation et tester uniquement des commandes documentées. Ce projet associe la programmation Python, la cryptographie appliquée, les protocoles et la gestion des identités.

9. À retenir

Une carte à puce est un support matériel capable de conserver des données et, pour les cartes à microprocesseur, d'exécuter des opérations. Les cartes cryptographiques peuvent contribuer à l'authentification en protégeant certaines clés privées et en réalisant des opérations sans les exporter. Le PIN sert à autoriser des fonctions, tandis que le PUK, lorsqu'il existe, peut intervenir dans une procédure de déblocage. Les certificats numériques et les infrastructures PKI permettent d'associer une clé publique à une identité et d'en vérifier la confiance.

Les échanges avec les cartes utilisent notamment des APDU, et les applications Python peuvent communiquer avec des lecteurs grâce à PC/SC et à la bibliothèque pyscard. Il est essentiel de distinguer les simulations logicielles des protections réelles d'un composant sécurisé. La sécurité dépend également du poste de travail, des politiques d'accès, de la protection du PIN, de la gestion des certificats et des procédures de révocation. Toute manipulation matérielle doit être effectuée sur une carte de test autorisée et avec des commandes documentées.

 




Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/


loader-image
Le prix initial était : € 11,00.Le prix actuel est : € 10,00.
Le prix initial était : € 6,00.Le prix actuel est : € 5,00.



Leave a Reply

Your email address will not be published. Required fields are marked *