it-swarm.com.de

Wie schreibe/lese ich auf eine Smartcard?

Gibt es eine Open Source-Bibliothek zum Schreiben und Lesen von Daten in C # von einer Smartcard mithilfe eines Smartcard-Lesegeräts? Mein Smartcard-Modell ist mifare1k und mein Lesegerät ist ucr122u.

14
xyrus the virus

Schauen Sie sich Daniel Müllers Artikel an, https://github.com/danm-de/pcsc-sharp

funktioniert bei mir sehr gut auf windows und mono.

8
IanNorton

Ich weiß, das ist eine alte Frage, aber Sie möchten vielleicht PCSC-Sharp, das ist

PC/SC-Wrapper-Klassen für .NET, geschrieben in C #. Das Paket enthält Klassen für den Zugriff auf Personal Computer/Smart Card Resource Manager über die systemeigene PC/SC-API. Implementiert teilweise ISO7816-Unterstützung. Die Bibliothek ist so geschrieben, dass sie sowohl unter Windows als auch unter Unix (Linux mit Mono unter PCSC Lite) ausgeführt werden kann.

Das Projekt ist auf GitHub: https://github.com/danm-de/pcsc-sharp

Sie können die Dokumentation auch hier überprüfen: https://danm.de/docs/pcsc-sharp/index.html

1
Maxime

für acr1252u

Ich habe die Lösung in einem C++ - Code gefunden: Nur im Linker müssen wir winscard.h hinzufügen

#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <cstdint>
#include <cstring>
#include <winscard.h>

std::wstring s2ws(const std::string& s);

int main(int argc, char* argv[]) {
    SCARDCONTEXT context = 0;
    LONG ret = SCardEstablishContext(SCARD_SCOPE_SYSTEM, nullptr, nullptr, &context);

    if (ret != SCARD_S_SUCCESS) {
        std::cout << "SCardEstablishContext: " << ret<< std::endl;
    }
    else {
        LPTSTR allReaderNames = nullptr;
        DWORD readerCount = SCARD_AUTOALLOCATE;

        ret = SCardListReaders(context, nullptr, reinterpret_cast<LPTSTR>(&allReaderNames), &readerCount);

        if (ret != SCARD_S_SUCCESS) {
            std::cout << "SCardListReaders: " << ret << std::endl;
        }
        else {
            std::string readerName("ACS ACR1252 1S CL Reader PICC 0");
            std::wstring stemp = s2ws(readerName);
            LPCWSTR result = stemp.c_str();
            DWORD activeProtocol = 0;
            SCARDHANDLE card = 0;

            ret = SCardConnect(context, result, SCARD_SHARE_DIRECT, 0, &card, &activeProtocol);

            if (ret != SCARD_S_SUCCESS) {
                std::cout << "SCardConnect: " << ret << std::endl;
            }
            else {
                std::vector<std::uint8_t> outputBuffer{ 0xE0, 0x0, 0x0, 0x21, 0x01, 0x71 };
                std::vector<std::uint8_t> inputBuffer(64, 0);
                DWORD bytesReturned = 0;

                DWORD controlcode = SCARD_CTL_CODE(3500);
                ret = SCardControl(card, controlcode, outputBuffer.data(), outputBuffer.size(), inputBuffer.data(), inputBuffer.size(), &bytesReturned);

                if (ret != SCARD_S_SUCCESS) {
                    std::cout << "SCardControl: " << ret << std::endl;
                }
                else {
                    std::cout << "Response: " << std::hex << std::setfill('0');
                    for (std::size_t i = 0; i < bytesReturned; ++i) {
                        std::cout << std::setw(2) << static_cast<std::uint32_t>(inputBuffer[i]) << " ";
                    }
                    std::cout << std::dec << std::endl;

                    SCardDisconnect(card, SCARD_LEAVE_CARD);
                }
            }

            // Release the memory that SCardListReaders allocated for us
            SCardFreeMemory(context, allReaderNames);
        }

        ret = SCardReleaseContext(context);

        if (ret != SCARD_S_SUCCESS) {
            std::cout << "SCardReleaseContext: " << ret << std::endl;
        }
        std::getchar();
    }

    return 0;
}

std::wstring s2ws(const std::string& s)
{
    int len;
    int slength = (int)s.length() + 1;
    len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0);
    wchar_t* buf = new wchar_t[len];
    MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, buf, len);
    std::wstring r(buf);
    delete[] buf;
    return r;
}