Libreria swICC

Il progetto deve essere clonato in modo ricorsivo. Scaricare lo ZIP non è sufficiente.

Software ICC (o swICC) è un framework che fornisce un modo semplice e flessibile per sviluppare la maggior parte dei tipi di smart card. Consente inoltre a qualsiasi card basata su swICC di essere collegata al PC tramite l'interfaccia PC/SC (utilizzando il lettore PC/SC swICC), che è lo standard de facto per collegare le smart card ai PC.

Scopo

• Framework per lo sviluppo di smart card in software, senza dipendenze hardware.
• Qualsiasi card basata su swICC può connettersi al PC tramite PC/SC utilizzando il lettore PC/SC swICC.
• Il file system della smart card può essere definito utilizzando JSON; esempi presenti in ./test/data/disk. L'FS può essere salvato su disco come file .swiccfs e ricaricato nella card.
• Numerose utility di debug.
• Include un'implementazione BER-TLV di facile utilizzo.

Installazione

• Per compilare il progetto servono make, cmake e gcc. Nessuna dipendenza runtime aggiuntiva.

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 (per maggiori informazioni sulla compilazione, dai un'occhiata a ./doc/install.md).
5. Collega con ./build/libswicc.a (ad es. -Llib/swicc/build -lswicc) e aggiungi ./include al percorso di inclusione (ad es. -Ilib/swicc/include).
6. Nel tuo progetto aggiungi #include <swicc/swicc.h> per includere tutte le intestazioni.

Utilizzo

Per creare una smart card minima, procedi come segue:

1. Assicurati innanzitutto di aver seguito le istruzioni di installazione e che ./build/libswicc.a esista.
2. mkdir card
3. cd card
4. Copia il seguente codice in un file main.c all'interno della directory ./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 per compilare la card.
6. Per interagire con la card tramite PC/SC, dovrai avviare un server di card swICC, ad es. il lettore PC/SC swICC.
7. ./card.elf che collegherà la card al lettore di card.
8. pcsc_scan (parte del pacchetto pcsc-tools) mostrerà alcuni dettagli della card.
9. Puoi iniziare a interagire con la card tramite PC/SC come faresti con una card reale.

Per implementare una card personalizzata, è necessario registrare un demuxer APDU (prima di eseguire il client di rete) tramite swicc_apduh_pro_register, nonché gestori APDU che vengono chiamati dal demuxer a seconda del comando ricevuto. Un buon esempio di utilizzo più avanzato del framework è il progetto swSIM, che implementa una SIM card utilizzando swICC.