Jak pisać/czytać na karcie inteligentnej?

Question

Czy istnieje biblioteka Open Source do zapisu i odczytu danych w języku C# z karty elektronicznej za pomocą czytnika kart inteligentnych? Mój model karty inteligentnej to mifare1k, a mój czytnik to ucr122u.

Answer 1

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

działa bardzo dobrze dla mnie na okna i mono.

Answer 2

wiem, że to jest stare pytanie, ale może chcesz PCSC ostre która

PC klasy otoki/SC dla .NET, napisany w C#. Pakiet zawiera klasy do uzyskiwania dostępu do Menedżera zasobów komputera osobistego/karty inteligentnej przy użyciu macierzystego interfejsu PC/SC API systemu . Implementuje częściową obsługę standardu ISO7816. Biblioteka jest napisana do działania zarówno w systemie Windows, jak i Unix (Linux z Mono przy użyciu PCSC Lite).

Projekt jest na GitHub: https://github.com/danm-de/pcsc-sharp

Można również sprawdzić dokumentację tutaj: https://danm.de/docs/pcsc-sharp/index.html

Answer 3

dla acr1252u

Znalazłem rozwiązanie w C++ Kod: w linkerze musimy dodać 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; 
}