Come si scrive/legge su una smartcard?

Question

Esiste una libreria Open Source per scrivere e leggere dati in C# da una smartcard utilizzando un lettore di smart card? Il mio modello di smart card è mifare1k e il mio lettore è ucr122u.

Answer 1

Partenza di Daniel Müller PCSC-sharp, https://github.com/danm-de/pcsc-sharp

funziona molto bene per me su finestre e mono.

Answer 2

So che questa è una vecchia questione, ma si potrebbe desiderare di PCCS-Sharp, che è classi wrapper/SC

PC per .NET, scritto in C#. Il pacchetto contiene le classi per accedere al Personal Computer/Smart Card Resource Manager utilizzando l'API PC/SC nativa del sistema . Implementa il supporto parziale ISO7816. La libreria è scritta per funzionare su entrambi, Windows e Unix (Linux con Mono utilizzando PCSC Lite).

Il progetto è su GitHub: https://github.com/danm-de/pcsc-sharp

è anche possibile controllare la documentazione qui: https://danm.de/docs/pcsc-sharp/index.html

Answer 3

per acr1252u

ho trovato la soluzione in un codice C++: solo nel linker dobbiamo aggiungere 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; 
}