Librería swICC

El proyecto debe clonarse de forma recursiva. Descargar el ZIP no es suficiente.

Software ICC (o swICC) es un framework que proporciona una forma fácil y flexible de desarrollar la mayoría de los tipos de tarjetas inteligentes. También permite que cualquier tarjeta basada en swICC se conecte al PC a través de la interfaz PC/SC (usando el lector PC/SC de swICC), que es el estándar de facto para conectar tarjetas inteligentes a los PC.

Alcance

• Framework para desarrollar tarjetas inteligentes en software, sin dependencias de hardware.
• Cualquier tarjeta basada en swICC puede conectarse al PC vía PC/SC usando el lector PC/SC de swICC.
• El sistema de archivos de la tarjeta inteligente puede definirse usando JSON; hay ejemplos en ./test/data/disk. El FS puede guardarse en disco como un archivo .swiccfs y cargarse de nuevo en la tarjeta.
• Muchas utilidades de depuración.
• Incluye una implementación BER-TLV fácil de usar.

Instalación

• Necesitas make, cmake y gcc para compilar el proyecto. No hay dependencias adicionales en tiempo de ejecución.

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 (para más información sobre la compilación, echa un vistazo a ./doc/install.md).
5. Enlaza con ./build/libswicc.a (p. ej. -Llib/swicc/build -lswicc) y añade ./include a la ruta de inclusión (p. ej. -Ilib/swicc/include).
6. En tu proyecto, añade #include <swicc/swicc.h> para incluir todos los archivos de cabecera.

Uso

Para crear una tarjeta inteligente mínima, haz lo siguiente:

1. Asegúrate de seguir primero las instrucciones de instalación y de que ./build/libswicc.a existe.
2. mkdir card
3. cd card
4. Copia el siguiente código en un archivo main.c dentro del directorio ./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 para compilar la tarjeta.
6. Para interactuar con la tarjeta a través de PC/SC, necesitarás iniciar un servidor de tarjetas swICC, p. ej., el lector PC/SC de swICC.
7. ./card.elf, que conectará la tarjeta al lector de tarjetas.
8. pcsc_scan (parte del paquete pcsc-tools) mostrará algunos detalles de la tarjeta.
9. Puedes comenzar a interactuar con la tarjeta a través de PC/SC como lo harías con una tarjeta real.

Para implementar una tarjeta personalizada, es necesario registrar un demultiplexor de APDU (antes de ejecutar el cliente de red) mediante swicc_apduh_pro_register, así como manejadores de APDU que el demultiplexor invoca en función del comando recibido. Un buen ejemplo de uso más avanzado del framework es el proyecto swSIM, que implementa una tarjeta SIM usando swICC.