swICC-Bibliothek

Das Projekt muss rekursiv geklont werden. Das Herunterladen des ZIP reicht nicht.

Software ICC (oder swICC) ist ein Framework, das eine einfache und flexible Möglichkeit bietet, die meisten Arten von Smartcards zu entwickeln. Es erlaubt außerdem, jede auf swICC basierende Karte über die PC/SC-Schnittstelle mit dem PC zu verbinden (unter Verwendung des swICC-PC/SC-Lesegeräts), die der De-facto-Standard für die Verbindung von Smartcards mit PCs ist.

Umfang

• Framework zur Entwicklung von Smartcards in Software, ohne Hardware-Abhängigkeiten.
• Jede auf swICC basierende Karte kann über PC/SC unter Verwendung des swICC-PC/SC-Lesegeräts mit dem PC verbunden werden.
• Das Dateisystem der Smartcard kann mithilfe von JSON definiert werden; Beispiele befinden sich in ./test/data/disk. Das Dateisystem kann als .swiccfs-Datei auf dem Datenträger gespeichert und in die Karte zurückgeladen werden.
• Zahlreiche Debug-Dienstprogramme.
• Enthält eine einfach zu verwendende BER-TLV-Implementierung.

Installation

• Du benötigst make, cmake und gcc, um das Projekt zu kompilieren. Keine zusätzlichen Laufzeit-Abhängigkeiten.

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 (weitere Informationen zum Erstellen siehe ./doc/install.md).
5. Verknüpfe mit ./build/libswicc.a (z. B. -Llib/swicc/build -lswicc) und füge ./include zum Include-Pfad hinzu (z. B. -Ilib/swicc/include).
6. Füge in deinem Projekt #include <swicc/swicc.h> hinzu, um alle Header einzubinden.

Verwendung

Um eine minimale Smartcard zu erstellen, gehe wie folgt vor:

1. Stelle sicher, dass du zuerst die Installationsanweisungen befolgt hast und dass ./build/libswicc.a vorhanden ist.
2. mkdir card
3. cd card
4. Kopiere den folgenden Code in eine Datei main.c im Verzeichnis ./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, um die Karte zu erstellen.
6. Um mit der Karte über PC/SC zu interagieren, musst du einen swICC-Kartenserver starten, z. B. das swICC-PC/SC-Lesegerät.
7. ./card.elf, das die Karte mit dem Kartenlesegerät verbindet.
8. pcsc_scan (Teil des Pakets pcsc-tools) zeigt einige Details der Karte an.
9. Du kannst beginnen, über PC/SC mit der Karte zu interagieren, wie du es mit einer echten Karte tun würdest.

Um eine eigene Karte zu implementieren, muss man einen APDU-Demuxer (vor dem Ausführen des Netzwerk-Clients) über swicc_apduh_pro_register registrieren sowie APDU-Handler, die vom Demuxer in Abhängigkeit von dem empfangenen Befehl aufgerufen werden. Ein gutes Beispiel für die fortgeschrittenere Nutzung des Frameworks ist das Projekt swSIM, das eine SIM-Karte mit swICC implementiert.