Biblioteca swICC

O projeto precisa ser clonado recursivamente. Baixar o ZIP não é suficiente.

O ICC por software (ou swICC) é um framework que fornece uma maneira fácil e flexível de desenvolver a maioria dos tipos de cartões inteligentes. Ele também permite que qualquer cartão baseado em swICC seja conectado ao PC por meio da interface PC/SC (usando o leitor PC/SC do swICC), que é o padrão de facto para conectar cartões inteligentes a PCs.

Escopo

• Framework para desenvolver cartões inteligentes em software, sem dependências de hardware.
• Qualquer cartão baseado em swICC pode se conectar ao PC via PC/SC usando o leitor PC/SC do swICC.
• O sistema de arquivos do cartão inteligente pode ser definido usando JSON, com exemplos presentes em ./test/data/disk. O FS pode ser salvo em disco como um arquivo .swiccfs e carregado de volta para o cartão.
• Muitos utilitários de depuração.
• Inclui uma implementação de BER-TLV fácil de usar.

Instalação

• Você precisa de make, cmake e gcc para compilar o projeto. Sem dependências adicionais em tempo de execução.

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 mais informações sobre a compilação, consulte ./doc/install.md).
5. Vincule com ./build/libswicc.a (ex.: -Llib/swicc/build -lswicc) e adicione ./include ao caminho de inclusão (ex.: -Ilib/swicc/include).
6. No seu projeto, adicione #include <swicc/swicc.h> para incluir todos os cabeçalhos.

Uso

Para criar um cartão inteligente mínimo, faça o seguinte:

1. Certifique-se de seguir as instruções de instalação primeiro e garanta que ./build/libswicc.a exista.
2. mkdir card
3. cd card
4. Copie o código a seguir em um arquivo main.c dentro do diretório ./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 o cartão.
6. Para interagir com o cartão via PC/SC, você precisará iniciar um servidor de cartão swICC, ex.: o leitor PC/SC do swICC.
7. ./card.elf que conectará o cartão ao leitor de cartões.
8. O pcsc_scan (parte do pacote pcsc-tools) mostrará alguns detalhes do cartão.
9. Você pode começar a interagir com o cartão por meio do PC/SC como faria com um cartão real.

Para implementar um cartão personalizado, é necessário registrar um demuxer de APDU (antes de executar o cliente de rede) por meio de swicc_apduh_pro_register, bem como manipuladores de APDU que são chamados pelo demuxer dependendo do comando recebido. Um bom exemplo de uso do framework de maneira mais avançada é o projeto swSIM, que implementa um cartão SIM usando swICC.