Wie schreibt/liest man auf eine Smartcard?

Question

Gibt es eine Open Source-Bibliothek zum Schreiben und Lesen von Daten in C# von einer Smartcard mit einem Smartcard-Leser? Mein Smartcard-Modell ist mifare1k und mein Leser ist ucr122u.

Answer 1

Check out Daniel Müller pcsc scharf, https://github.com/danm-de/pcsc-sharp

funktioniert sehr gut für mich an Fenstern und Mono.

Answer 2

Ich weiß, dass dies eine alte Frage, aber Sie könnten zu PCSC-Sharp wollen, das ist

PC/SC-Wrapper-Klassen für .NET in C# geschrieben. Das Paket enthält Klassen für Zugriff auf den Personalcomputer/Smartcard-Ressourcenmanager unter Verwendung der systemeigenen nativen PC/SC-API. Implementiert teilweise ISO7816-Unterstützung. Die Bibliothek ist so geschrieben, dass sie auf Windows und Unix läuft (Linux mit Mono unter Verwendung von PCSC Lite).

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

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

Answer 3

für acr1252u

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

#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; 
}