आप स्मार्टकार्ड को कैसे लिखते/पढ़ते हैं?

Question

क्या स्मार्टकार्ड रीडर का उपयोग कर स्मार्टकार्ड से सी # में डेटा लिखने और पढ़ने के लिए ओपन सोर्स लाइब्रेरी है? मेरा स्मार्टकार्ड मॉडल mifare1k है और मेरा पाठक ucr122u है।

Answer 1

डैनियल मुलर के PcSC-तेज बाहर की जाँच करें, https://github.com/danm-de/pcsc-sharp

काम करता है बहुत अच्छी तरह से मेरे लिए पर खिड़कियों और मोनो।

Answer 2

मैं जानता हूँ कि यह एक पुराने सवाल है, लेकिन आप PCSC-तीव्र जो सी # में लिखा नेट के लिए

पीसी/एससी आवरण कक्षाएं, है सकते हैं। पैकेज में कक्षाओं में सिस्टम के देशी पीसी/एससी एपीआई का उपयोग कर व्यक्तिगत कंप्यूटर/स्मार्ट कार्ड संसाधन प्रबंधक तक पहुंच है। आंशिक ISO7816 समर्थन लागू करता है। लाइब्रेरी को विंडोज और यूनिक्स दोनों पर चलाने के लिए लिखा गया है ( पीसीएससी लाइट का उपयोग कर मोनो के साथ लिनक्स)।

परियोजना GitHub पर है: https://github.com/danm-de/pcsc-sharp

तुम भी प्रलेखन यहाँ देख सकते हैं: acr1252u

के लिए https://danm.de/docs/pcsc-sharp/index.html

Answer 3

मैं कोड एक C++ समाधान पाया है: केवल लिंकर में हमें 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; 
} 

जोड़ने की आवश्यकता है