Bibliothèque swICC

Le projet doit être cloné de manière récursive. Télécharger le ZIP ne suffit pas.

Le logiciel ICC (ou swICC) est un framework offrant un moyen simple et flexible de développer la plupart des types de cartes à puce. Il permet également à toute carte basée sur swICC d'être connectée au PC via l'interface PC/SC (en utilisant le lecteur PC/SC swICC) qui est la norme de facto pour connecter des cartes à puce à des PC.

Portée

• Framework pour développer des cartes à puce en logiciel, sans dépendance matérielle.
• Toute carte basée sur swICC peut se connecter au PC via PC/SC en utilisant le lecteur PC/SC swICC.
• Le système de fichiers de la carte à puce peut être défini en JSON, avec des exemples dans ./test/data/disk. Le FS peut être enregistré sur disque sous forme de fichier .swiccfs, puis rechargé dans la carte.
• De nombreux utilitaires de débogage.
• Inclut une implémentation BER-TLV facile à utiliser.

Installation

• Vous avez besoin de make, cmake et gcc pour compiler le projet. Aucune dépendance d'exécution supplémentaire.

1. sudo apt-get install make cmake gcc
2. git clone --recurse-submodules [email protected]:tomasz-lisowski/swicc.git
3. cd swicc
4. make main-dbg (pour plus d'informations sur la compilation, consultez ./doc/install.md).
5. Liez avec ./build/libswicc.a (par exemple -Llib/swicc/build -lswicc) et ajoutez ./include au chemin d'inclusion (par exemple -Ilib/swicc/include).
6. Dans votre projet, ajoutez #include <swicc/swicc.h> pour inclure tous les en-têtes.

Utilisation

Pour créer une carte à puce minimale, procédez comme suit :

1. Assurez-vous d'abord de suivre les instructions d'installation et vérifiez que ./build/libswicc.a existe.
2. mkdir card
3. cd card
4. Copiez le code suivant dans un fichier main.c dans le répertoire ./card.

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <swicc/swicc.h>

swicc_net_client_st client_ctx = {0U};

static void sig_exit_handler(__attribute__((unused)) int signum)
{
    fprintf(stderr, "Shutting down...\n");
    swicc_net_client_destroy(&client_ctx);
    fflush(NULL);
    exit(0);
}

int32_t main(int32_t const argc, char const *const argv[const argc])
{
    swicc_disk_st disk = {0U};
    swicc_ret_et ret = swicc_diskjs_disk_create(&disk, "../test/data/disk/006-in.json");
    if (ret == SWICC_RET_SUCCESS)
    {
        swicc_st swicc_ctx = {0U};
        ret = swicc_fs_disk_mount(&swicc_ctx, &disk);
        if (ret == SWICC_RET_SUCCESS)
        {
            ret = swicc_net_client_sig_register(sig_exit_handler);
            if (ret == SWICC_RET_SUCCESS)
            {
                ret =
                    swicc_net_client_create(&client_ctx, "127.0.0.1", "37324");
                if (ret == SWICC_RET_SUCCESS)
                {
                    ret = swicc_net_client(&swicc_ctx, &client_ctx);
                    if (ret != SWICC_RET_SUCCESS)
                    {
                        fprintf(stderr, "Failed to run network client.\n");
                    }
                    swicc_net_client_destroy(&client_ctx);
                }
                else
                {
                    fprintf(stderr, "Failed to create a client.\n");
                }
            }
            else
            {
                fprintf(stderr, "Failed to register signal handler.\n");
            }
            swicc_terminate(&swicc_ctx);
        }
        else
        {
            fprintf(stderr, "Failed to mount disk.\n");
            swicc_disk_unload(&disk);
        }
    }
    else
    {
        fprintf(stderr, "Failed to create disk.\n");
    }

    return 0;
}

5. gcc main.c -I../include -L../build -lswicc -o card.elf pour compiler la carte.
6. Pour interagir avec la carte via PC/SC, vous aurez besoin de démarrer un serveur de carte swICC, par exemple le lecteur PC/SC swICC.
7. ./card.elf qui connectera la carte au lecteur de carte.
8. pcsc_scan (faisant partie du paquet pcsc-tools) affichera quelques détails de la carte.
9. Vous pouvez commencer à interagir avec la carte via PC/SC comme vous le feriez avec une vraie carte.

Pour implémenter une carte personnalisée, il faut enregistrer un démultiplexeur APDU (avant d'exécuter le client réseau) via swicc_apduh_pro_register, ainsi que des gestionnaires APDU appelés par le démultiplexeur selon la commande reçue. Un bon exemple d'utilisation plus avancée du framework est le projet swSIM qui implémente une carte SIM utilisant swICC.