TPM tests

0x01 Création d'un owner

jtt take_owner -o passOwner  
 11:06:49:519 [INFO] TakeOwnership::execute (113):    TPM ownership command is disabled  

0x02 Génération d'une clé

Gestion des commandes

0x01 Établir un propriétaire TPM

Dans cette partie, nous allons définir les différentes commandes qui sont directement liées à la mise en place d'un propriétaire d'un module de plateforme sécurisée (TPM). Certaines commandes décrites dans cette partie sont considérées sont obligatoires, la mise en place d'un propriétaire TPM ne serait pas possible en leur absence.
Trois commandes seront définies en détails: « TPM_CreateEndorsementKeyPair », « TPM_ReadPubek », et « TPM_TakeOwnership ».
Les deux premières sont directement liées à la troisième dans le sens où le EK (Endorsement Key) est utilisé pour chiffrer le Owner et la clé racine de stockage (SRK)  durant le processus de création du propriétaire via la commande « TPM_TakeOwnership ».

• La commande « TPM_CreateEndorsementKeyPair »

→ Cette commande crée la paire de clés de type EK (Endorsement Key) du module de plateforme sécurisée, si cette clé n’existe pas déjà.

La création d'une paire de clé de type EK doit être fait qu'une seule fois par périphérique TPM, et toute tentative d'exécuter cette commande après qu'un EK a été crée entraîne un code de retour: TCG_FAIL.
La première chose à tester, est si l'EK doit être établi dans n'importe quel périphérique TPM donné. Pour faire cela, on exécute la commande « TPM_ReadPubek ». En se basant sur le résultat de cette commande, soit on procède à la création d'un propriétaire TPM, soit valider la paire de clé EK.

• La commande « TPM_ReadPubek »

→ Cette commande renvoie la partie publique de la paire de clés de type EK du TPM. Cette commande est désactivée lors d’une acquisition de propriété du TPM utilisant la commande « TPM_TakeOwnership ».

• La commande « TPM_TakeOwnership »

→ Cette commande prend la propriété du TPM avec une nouvelle valeur d’autorisation, dérivée du mot de passe du propriétaire. Outre d’autres conditions devant être satisfaites avant que cette commande puisse s’exécuter, le TPM doit être autorisé et activé.

Trusted Platform Module

0x01 Introduction
    Le module de plateforme sécurisée (TPM) est une puce matérielle conçue pour permettre aux ordinateurs d'atteindre des niveaux plus élevés de sécurité. 

Il existe actuellement 100 millions de TPM, principalement dans les ordinateurs portables professionnels faits par HP, Dell, Sony, Lenovo, Toshiba etc. Des applications logicielles utilisent le TPM, tel que BitLocker de Microsoft qui est une spécification de protection des données et permet de chiffrer l'intégralité d'un lecteur.

     Les TPM sont fabriqués par les constructeurs de puces, tel que Atmel, Broadcom, Infineon, Sinosun, STMicroelectronics, et Winbond et ils sont spécifiés par le Trusted Computing Group qui est est un consortium d'entreprises d'informatique (Compaq, HP, IBM, Intel, Microsoft, AMD, etc.) visant à sécuriser les équipements et communications informatiques.


0x02 Les fonctionnalités du TPM

Le module de plateforme sécurisée propose trois types de fonctionnalités: 

• Stockage sécurisée: Les processus de l'utilisateurs peuvent stoker des données chiffrées par une clé. Cette clé est disponible que pour le TPM et personne d'autre ne peut la voir.
• Mesure et reporting: une plateforme permettant de créer des rapports de l'état de configuration. Par exemple, considérons une application web qui comprend un serveur web et un serveur de base de données qui s'exécutent sur différents compartiments mais sur la même hôte physique, le fonctionnement de cette application dépend du bon fonctionnement de chaque composant qui s'exécute dans son propre environnement.
• Authentification: une plateforme peut obtenir des clés par lesquelles elle peut s'authentifier de manière fiable.

0x03 Stockage sécurisée

Pour stocker des données à l'aide d'un module TPM, la première étape consiste à créer des clés TPM afin de les utiliser pour chiffrer les données. Les clés TPM sont organisées en une structure arborescente, comme le montre la figure ci-dessous. 

Structure des clés TPM

    Après l'initialisation du TPM, un processus appelé «TPM_TakeOwnership» est invoqué. Cette commande permet de créer la clé racine de stockage (SRK: Storage Root Key). Ce dernier est utilisé pour protéger les clés TPM crées par les applications, de sorte que ces clés ne peuvent pas être utilisées sans le TPM. Le SRK est défini par le Trusted Computing Group.
    Par la suite, un processus utilisateur peut appeler «TPM_CreateWrapKey» pour créer une clé fils d'une clé existante. Une fois la clé est crée, elle peut être chargée à l'aide de la commande «TPM_LoadKey2», et peut être ensuite utilisée dans des opérations nécessitants une clé (par exemple : TPM_Seal).
    Pour chaque clé TPM est associée une chaîne de 160 bits appelée authdata, créée lors de la création de la clé et spécifiée par le processus utilisateur, et est considérée comme un mot de passe autorisant l'utilisation de la clé. Elle contrôle les capacités du module: lire, écrire, utilisation des objets stockés dans le TPM et l'exécution des commande TPM. 

    La commande «TPM_CreateWrapKey» prends comme arguments: la clé parent de la clé à créer, une nouvelle valeur de authdat de la clé qui va être créée, type de clé (sealing: clé de chiffrement relative à RSA, Binding, Signature, etc. ) et l'autorisation HMAC basée sur le authdata de la clé parent.
    Cette fonction retourne un blob (binary large object) constitué de la partie publique de la nouvelle clé et un package chiffré, ce package contient la clé privée et le authdata de la nouvelle clé, et est chiffré avec la clé parent.
Ainsi, cette commande crée la clé, mais sans la stocker, elle la retourne chiffrée au processus utilisateur. La clé nouvellement créée n'est pas encore disponible pour l'utilisation par la TPM.

    Pour pouvoir utiliser une clé TPM, cette dernière doit être chargée avec «TPM_LoadKey2». Cette commande prend comme argument le blob retourné par la commande «TPM_CreateWrapKey», et retourne un handle (un numéro qui permet d'identifier un objet sous Windows), c'est un pointeur vers la clé stockée dans la mémoire TPM. Les commandes qui utilisent la clé chargée l'identifie par le handle. Étant donnée que «TPM_LoadKey2» utilise un déchiffrement par la clé parent, il faut que cette clé soit chargée et ça nécessite une autorisation HMAC basée sur le authdata de la clé parent.
La clé racine de stockage (SRK) est chargée en permanence et sa valeur de handle est bien connue, et par conséquent elle ne nécessite jamais d'être chargé.

    Une fois la clé est chargée, une commande de chiffrement telle que «TPM_Seal» peut être utilisée. Elle prend comme argument le handle de la clé de chiffrement, les données à chiffrer , des informations sur les PCR (Platform Configuration Registers) à lesquels le Seal doit être lié, et les données chiffrés. Ça nécessite une autorisation HMAC basée sur le authdata de la clé de chiffrement. 
    
0x04 Session d'autorisation
    Toutes les commandes vues précédemment doivent être exécutées dans une session d'autorisation. Il existe deux types de session: 

• OIAP: (Object Independent Authorisation Protocol) qui permet de créer une session manipulant n'importe quel objet, mais ne fonctionne que pour certaines commandes.
• OSAP: (Object Specific Authorisation Protocol) qui permet une session manipulant un objet spécifique spécifié lors de la mise en place de la session.

Une session d'autorisation commence au moment où la commande «TPM_OIAP» ou «TPM_OSAP» est exécutée avec succès.

0x05 Plateforme de mesure et de reporting

    Le TPM contient un certain nombre de registres appelé Registres de Configuration de la Plateforme (PCR) qui sont des portions de mémoire volatiles de 160 bits (pour stocker des condensats SHA-1) permettant de stocker l'état d'une plateforme. Un registre de ce type peut, par exemple, mémoriser le fabricant de la carte mère, le fabricant du processeur, la version de micro-logiciel de la plateforme, etc.

0x06 Plateforme d'authentification

    Chaque TPM possède une unique paire de clés publique/privée appelé EK (Endorsement Key), définie au moment de la fabrication et habituellement certifiée par le fabricant. Cette partie privée de la clé de type EK n'est jamais accessible à l'extérieur du TPM. La partie publique de la clé de type EK aide à reconnaître un TPM authentique. Elle peut être changée par le propriétaire de la plateforme. EK est destinée à être une clé à long terme et peut être considérée comme l'identité du TPM.
    TPM génère, lors de l'utilisation de la commande «TPM_TakeOwnership», une paire de clés publique/privée appelée la clé racine de stockage (SRK) qui est utilisée pour protéger les clés du module créées par applications, pour que ces clés ne puissent être utilisées sans le TPM.

          1x06 Confidentialité de l'autorité de certification

                                                        /** to do */

          2x06 Attestation anonyme directe 
    Direct Anonymous Attestation (DAA) est un protocole cryptographique qui permet l'authentification à distance d'une plateforme de confiance, tout en préservant la confidentialité de l'utilisateur. En DAA, il y a quatre parties:

• L'hôte qui consite en une plateforme exécutant un système d'exploitation et une application logicielle,
• Le TPM à l'intérieur de la hôte,
• L'émetteur, il vérifie le certificat EK, et délivre des informations d'identification qui peuvent être utilisées pour signer le AIK (Attestation Identity Keys).
• Le vérificateur qui va vérifier le certificat dans l'AIK.

PKCS#15 init Options

 Usage: pkcs15-init [OPTIONS]  
 Options:  
  -E, --erase-card       Erase the smart card  
  -C, --create-pkcs15      Creates a new PKCS #15 structure  
  -P, --store-pin        Store a new PIN/PUK on the card  
  -G, --generate-key <arg>   Generate a new key and store it on the card  
  -S, --store-private-key <arg>  
                 Store private key  
    --store-public-key <arg> Store public key  
  -X, --store-certificate <arg>  
                 Store an X.509 certificate  
  -U, --update-certificate <arg>  
                 Update an X.509 certificate (carefull with mail decryption certs!!)  
  -W, --store-data <arg>    Store a data object  
  -D, --delete-objects <arg>  Delete object(s) (use "help" for more information)  
  -A, --change-attributes <arg>  
                 Change attribute(s) (use "help" for more information)  
    --sanity-check      Card specific sanity check and possibly update procedure  
    --erase-application <arg>  
                 Erase application with AID <arg>  
  -r, --reader <arg>      Specify which reader to use  
    --pin <arg>        Specify PIN  
    --puk <arg>        Specify unblock PIN  
    --so-pin <arg>      Specify security officer (SO) PIN  
    --so-puk <arg>      Specify unblock PIN for SO PIN  
    --no-so-pin        Do not install a SO PIN, and do not prompt for it  
    --serial <arg>      Specify the serial number of the card  
  -a, --auth-id <arg>      Specify ID of PIN to use/create  
    --puk-id <arg>      Specify ID of PUK to use/create  
    --verify-pin       Verify PIN after card binding (use with --auth-id)  
  -i, --id <arg>        Specify ID of key/certificate  
  -l, --label <arg>       Specify label of PIN/key  
    --puk-label <arg>     Specify label of PUK  
    --public-key-label <arg> Specify public key label (use with --generate-key)  
    --cert-label <arg>    Specify user cert label (use with --store-private-key)  
    --application-name <arg> Specify application name of data object (use with --store-data-object)  
    --application-id <arg>  Specify application id of data object (use with--store-data-object)  
    --aid <arg>        Specify AID of the on-card PKCS#15 application to be binded to (in hexadecimal form)  
  -o, --output-file <arg>    Output public portion of generated key to file  
  -f, --format <arg>      Specify key/cert file format: PEM (=default), DER or PKCS12  
    --passphrase <arg>    Specify passphrase for unlocking secret key  
    --authority        Mark certificate as a CA certificate  
  -u, --key-usage <arg>     Specify X.509 key usage (use "--key-usage help" for more information)  
  -F, --finalize        Finish initialization phase of the smart card  
    --update-last-update   Update 'lastUpdate' attribut of tokenInfo  
    --ignore-ca-certificates When storing PKCS#12 ignore CA certificates  
    --extractable       Private key stored as an extractable key  
    --insecure        Insecure mode: do not require a PIN for private key  
  -T, --use-default-transport-keys  
                 Do not ask for transport keys if the driver thinks it knows the key  
    --no-prompt        Do not prompt the user; if no PINs supplied, pin pad will be used  
  -p, --profile <arg>      Specify the general profile to use  
  -c, --card-profile <arg>   Specify the card profile to use  
    --options-file <arg>   Read additional command line options from file  
  -w, --wait          Wait for card insertion  
  -h, --help          Display this message  
  -v, --verbose         Verbose operation. Use several times to enable debug output.  

PKCS#15 tool Options

 Usage: pkcs15-tool [OPTIONS]  
 Options:  
  -L, --learn-card       Stores card info to cache  
    --list-applications    List the on-card PKCS#15 applications  
  -r, --read-certificate <arg> Reads certificate with ID <arg>  
  -c, --list-certificates    Lists certificates  
  -R, --read-data-object <arg> Reads data object with OID, applicationName or label <arg>  
  -C, --list-data-objects    Lists data objects  
    --list-pins        Lists PIN codes  
    --list-secret-keys    Lists secret keys  
  -D, --dump          Dump card objects  
  -u, --unblock-pin       Unblock PIN code  
    --change-pin       Change PIN or PUK code  
  -k, --list-keys        Lists private keys  
    --list-public-keys    Lists public keys  
    --read-public-key <arg>  Reads public key with ID <arg>  
    --read-ssh-key <arg>   Reads public key with ID <arg>, outputs ssh format  
  -T, --test-update       Test if the card needs a security update  
  -U, --update         Update the card with a security update  
    --reader <arg>      Uses reader number <arg>  
    --pin <arg>        Specify PIN  
    --new-pin <arg>      Specify New PIN (when changing or unblocking)  
    --puk <arg>        Specify Unblock PIN  
    --verify-pin       Verify PIN after card binding (without 'auth-id' the first non-SO, non-Unblock PIN will be verified)  
  -o, --output <arg>      Outputs to file <arg>  
    --no-cache        Disable card caching  
  -a, --auth-id <arg>      The auth ID of the PIN to use  
    --aid <arg>        Specify AID of the on-card PKCS#15 application to bind to (in hexadecimal form)  
  -w, --wait          Wait for card insertion  
  -v, --verbose         Verbose operation. Use several times to enable debug output.  

PKCS#15 crypt Options

 Usage: pkcs15-crypt [OPTIONS]  
 Options:  
  -s, --sign          Performs digital signature operation  
  -c, --decipher        Decipher operation  
  -k, --key <arg>        Selects the private key ID to use  
  -r, --reader <arg>      Uses reader number <arg>  
  -i, --input <arg>       Selects the input file to use  
  -o, --output <arg>      Outputs to file <arg>  
  -R, --raw           Outputs raw 8 bit data  
    --sha-1          Input file is a SHA-1 hash  
    --sha-256         Input file is a SHA-256 hash  
    --sha-384         Input file is a SHA-384 hash  
    --sha-512         Input file is a SHA-512 hash  
    --sha-224         Input file is a SHA-224 hash  
    --md5           Input file is a MD5 hash  
    --pkcs1          Use PKCS #1 v1.5 padding  
  -p, --pin <arg>        Uses password (PIN) <arg> (use - for reading PIN from STDIN)  
    --aid <arg>        Specify AID of the on-card PKCS#15 application to be binded to (in hexadecimal form)  
  -w, --wait          Wait for card insertion  
  -v, --verbose         Verbose operation. Use several times to enable debug output.  

PKCS#11 tool Options

 Usage: pkcs11-tool [OPTIONS]  
 Options:  
    --module <arg>      Specify the module to load (mandatory)  
  -I, --show-info        Show global token information  
  -L, --list-slots       List available slots  
  -T, --list-token-slots    List slots with tokens  
  -M, --list-mechanisms     List mechanisms supported by the token  
  -O, --list-objects      Show objects on token  
  -s, --sign          Sign some data  
  -h, --hash          Hash some data  
    --derive         Derive a secret key using another key and some data  
  -m, --mechanism <arg>     Specify mechanism (use -M for a list of supported mechanisms)  
  -l, --login          Log into the token first  
    --login-type <arg>    Specify login type ('so', 'user', 'context-specific'; default:'user')  
  -p, --pin <arg>        Supply User PIN on the command line (if used inscripts: careful!)  
    --puk <arg>        Supply User PUK on the command line  
    --new-pin <arg>      Supply new User PIN on the command line  
    --so-pin <arg>      Supply SO PIN on the command line (if used in scripts: careful!)  
    --init-token       Initialize the token, its label and its SO PIN (use with --label and --so-pin)  
    --init-pin        Initialize the User PIN (use with --pin and --login)  
  -c, --change-pin       Change User PIN  
    --unlock-pin       Unlock User PIN (without '--login' unlock in logged in session; otherwise '--login-type' has to be 'context-specific')  
  -k, --keypairgen       Key pair generation  
    --key-type <arg>     Specify the type and length of the key to create, for example rsa:1024 or EC:prime256v1  
    --usage-sign       Specify 'sign' key usage flag  
    --usage-decrypt      Specify 'decrypt' key usage flag  
    --usage-nonrepudiation  Specify 'nonrepudiation' key usage flag  
  -w, --write-object <arg>   Write an object (key, cert, data) to the card  
  -r, --read-object       Get object's CKA_VALUE attribute (use with --type)  
  -b, --delete-object      Delete an object  
    --application-label <arg>  
                 Specify the application label of the data object(use with --type data)  
    --application-id <arg>  Specify the application ID of the data object (use with --type data)  
    --issuer <arg>      Specify the issuer in hexadecimal format (use with --type cert)  
    --subject <arg>      Specify the subject in hexadecimal format (use with --type cert/privkey/pubkey)  
  -y, --type <arg>       Specify the type of object (e.g. cert, privkey,pubkey, data)  
  -d, --id <arg>        Specify the ID of the object  
  -a, --label <arg>       Specify the label of the object  
    --slot <arg>       Specify the ID of the slot to use  
    --slot-description <arg> Specify the description of the slot to use  
    --slot-index <arg>    Specify the index of the slot to use  
    --token-label <arg>    Specify the token label of the slot to use  
  -e, --set-id <arg>      Set the CKA_ID of an object, <args>= the (new) CKA_ID  
    --attr-from <arg>     Use <arg> to create some attributes when writing an object  
  -i, --input-file <arg>    Specify the input file  
  -o, --output-file <arg>    Specify the output file  
  -t, --test          Test (best used with the --login or --pin option)  
    --test-hotplug      Test hotplug capabilities (C_GetSlotList + C_WaitForSlotEvent)  
  -z, --moz-cert <arg>     Test Mozilla-like keypair gen and cert req, <arg>=certfile  
  -v, --verbose         Verbose operation. (Set OPENSC_DEBUG to enable OpenSC specific debugging)  
    --private         Set the CKA_PRIVATE attribute (object is only viewable after a login)  
    --test-ec         Test EC (best used with the --login or --pin option)  

Smart card PKCS#15

Dans cette étape, j'utilise la carte à puce: Oberthur AuthentIC v5.

Cette commande est utilisée pour vérifier les lecteurs disponibles et les pilotes installés

 $ opensc-tool --list-readers  
 # Detected readers (pcsc)  
 Nr. Card Features Name  
 0   Yes           USB CCID Smart Card Reader 0  

La prochaine étape est de s'assurer si c'est la carte est connectée :

 $ opensc-tool -reader 0 --name  
 Using reader with a card: USB CCID Smart Card Reader 0  
 Failed to connect to card: Card not present  

Après l'insertion de la carte:

 $ opensc-tool -reader 0 --name  
 Using reader with a card: USB CCID Smart Card Reader 0  
 AuthentIC v5  

Pour lister les codes PIN existants :

 $ pkcs15-tool --list-pins  
 Using reader with a card: USB CCID Smart Card Reader 0  
 PIN [SO PIN]  
     Object Flags  : [0x3], private, modifiable  
     ID       : ff  
     Flags     : [0xB1], case-sensitive, initialized, needs-padding, soPin  
     Length     : min_len:4, max_len:64, stored_len:64  
     Pad char    : 0xFF  
     Reference   : 132 (0x84)  
     Type      : ascii-numeric  
     Tries left   : 3  
 PIN [SCM]  
     Object Flags  : [0x3], private, modifiable  
     ID       : 53434d  
     Flags     : [0x33], case-sensitive, local, initialized, needs-padding  
     Length     : min_len:4, max_len:64, stored_len:64  
     Pad char    : 0xFF  
     Reference   : 129 (0x81)  
     Type      : ascii-numeric  
     Path      : 3f005011  
     Tries left   : 1  

Il existe déjà un SO PIN (Security Officer PIN) d'une taille de 8 octets, pas de User PIN.

______________________________________________________________________________

Remarque :
Unless stated otherwise, a SmartCard-HSM is usually shipped uninitialized, meaning that no SO-PIN is set. You will first need to perform an initialization to set the SO-PIN and initial user PIN. See section Initialize the Device below.

______________________________________________________________________________

La prochaine commande consiste à initialiser la carte et de créer une structure PKI.

PKCS#15 réalisé par OpenSC est utilisé pour accèder à la carte.

 $ pkcs15-init -C --label "FirasCard"  
 Using reader with a card: USB CCID Smart Card Reader 0  
 New Security Officer PIN (Optional - press return for no PIN).  
 Please enter Security Officer PIN: Failed to create PKCS #15 meta structure: Sec  
 urity status not satisfied  

 $ pkcs15-init -C --label "FirasCard"  
 Using reader with a card: USB CCID Smart Card Reader 0  
 New Security Officer PIN (Optional - press return for no PIN).  
 Please enter Security Officer PIN: Please type again to verify: Failed to create  
  PKCS #15 meta structure: Security status not satisfied  

*** En cours ***

Smart card PKCS#11

Introduction

Ce blog va expliquer comment accéder, générer des clés, utiliser les algorithmes cryptographiques (chiffrer / signer des données) contenus dans la carte en utilisant le standard de cryptographie à clé publique PKCS#11.
Nous allons utiliser une carte PKI, un lecteur de carte, d’autres utilitaires qui seront nécessaires pour le bon fonctionnement.

C'est quoi une carte cryptographique ?
Une carte cryptographique est une carte à puce contenant un microprocesseur à mémoire supportant les opérations cryptographiques (signature numérique, cryptage). Elles ont été conçues pour permettre un stockage sécurisé des clés privées et des certificats. Ces cartes peuvent exécuter des fonctions cryptographiques sur la carte à puce elle-même. Elles permettent donc de conserver et gérer des informations sensibles telles que :

- Les clés privées, 

- Les numéros de compte,

- Les mots de passe,

- …

PKCS#11 Définition: 
PKCS#11 aussi appelé Cryptoki, appartient à une famille de standard appelée standard cryptographique à clé publique (PKCS : Public-Key Cryptography Standard), publié par les laboratoires RSA. PKCS#11 définit une API multiplateforme pour discuter et interagir avec les jetons cryptographiques, tel que les module de sécurité matérielle (HSM : Hardware Security Module), ces derniers peuvent être sous plusieurs formes : cartes à puce, jetons USB, etc. Le but est d’accélérer les opérations cryptographiques et conserver les clés en toute sécurité.
PKCS#11 fournit une interface à un ou plusieurs dispositifs cryptographiques, qui seront actifs dans le système à travers un certain nombre de « slot ». Chaque « slot »  correspond à un lecteur physique (ex. Lecteur de carte).

PKCS#11 Module: 
Le module PKCS#11 est un programme qui est responsable de gérer les opérations cryptographique comme le chiffrement et le déchiffrement et utilisant le standard PKCS#11.

Outils 

Dans cette étape, je vais présenter de quelques outils open-source qui vont nous servir de manipuler et utiliser les données sur les cartes à puce avec le PKCS#11. 

Pour utiliser le PKCS#11, nous pouvons écrire notre propre wrapper java (enveloppeurs) qui utilise la JNI (Java Native Interface) ce qui permet au code java s’exécutant à l’intérieur de la JVM d’appeler et d’être appelé par des applications natives.

Pour la suite du travail, j’ai opté à utiliser le wrapper open source : « iaik PKCS#11 Wrappers ».

Ce que nous aurons besoin :

- Une carte à puce PKI,

- Un wrapper PKCS#11 pour java,

- Un module PKCS#11.

La première étape est de télécharger l’iaik PKCS#11 Wrappers, la bibliothèque est gratuite, mais il est nécessaire de procéder à un enregistrement. Après la décompression, nous aurons besoin du fichier de « iaikPkcs11Wrapper.jar » pour l’intégrer au projet java.

Nous aurons besoin aussi d’un module qui va nous fournir des informations sur les cartes connectées que nous pourrons y accéder.

Pour notre module, qui est normalement en « .dll » pour Windows et en « .so » pour linux, on doit installer « OpenSC » qui est un ensemble de librairies et de pilotes pour les cartes à puce. Il est conçu pour fonctionner avec les cartes supportant PKCS#11.

Pour la version de « OpenSC » choisie sous Windows 32/64 bit, il est recommandé d’installer la version 32 bits de ce logiciel, et ce pour des problèmes de compatibilité, mais aussi les pilotes intégrés dans « OpenSC » ne sont pas signés et peuvent ne pas fonctionner avec d’autres logiciels signés.

Après l’installation, on doit modifier la variable %PATH% pour inclure le répertoire de OpenSC, et aussi nous permettre d’exécuter nos commandes depuis le terminal.

 C:\Program Files (x86)\OpenSC Project\OpenSC\tools  

Partie 1 : OpenSC 

Quelques tests ont été effectués pour exploiter la carte et essayer d’utiliser les algorithmes implémentés.

Tout d’abord, on va essayer de lister les lecteurs de cartes disponibles :

 $ opensc-tool --list-readers  

On remarque qu’on a deux lecteurs, le premier avec une carte insérée le deuxième est vide. On vérifie après si une carte a été bien détectée. Chaque carte possède un ATR (Answer To Reset), sous forme d’une chaîne hexadécimale utilisée pour identifier le type de la carte. 

 $ opensc-tool --reader 0 --atr  

On vérifie aussi si la carte est bien reconnue par OpenSC :

 $ opensc-tool --reader 0 --name  

La carte a été bien reconnue, et donc on peut utiliser la commande « opensc-explorer » cette commande nous permet par exemple de supprimer/créer des fichiers EF (fichiers élémentaires) et DF (répertoire), de changer le code PIN, de lister tous les fichiers du répertoire courant.

 $ pkcs11-tool --module=c:\Windows\System32\opensc-pkcs11.dll -l -O  

L’option ‘-l’ permet d’interroger la carte pour la vérification du code PIN et se connecter à la carte et l’option ‘-O’ permet de lister les objets contenus dans la carte et afficher quelques informations.

Partie 2 : Java Class

(en cours)