Existe-t-il une bibliothèque Open Source pour écrire et lire des données en C # à partir d'une carte à puce utilisant un lecteur de carte à puce? Mon modèle de carte à puce est mifare1k
et mon lecteur est ucr122u
.
Découvrez pcsc-sharp, https://github.com/danm-de/pcsc-sharp de Daniel Müller - /
fonctionne très bien pour moi sur windows et mono.
Je sais que c’est une vieille question, mais vous voudrez peut-être PCSC-Sharp, qui est
Classes de wrapper PC/SC pour .NET, écrites en C #. Le package contient des classes permettant d'accéder au gestionnaire de ressources pour ordinateurs personnels/cartes à puce à l'aide de l'API PC/SC native du système. Implémente la prise en charge partielle d'ISO7816. La bibliothèque est conçue pour fonctionner sous Windows et Unix (Linux avec Mono utilisant PCSC Lite).
Le projet est sur GitHub: https://github.com/danm-de/pcsc-sharp
Vous pouvez également consulter la documentation ici: https://danm.de/docs/pcsc-sharp/index.html
pour acr1252u
J'ai trouvé la solution dans un code c ++: uniquement dans l'éditeur de liens, nous devons ajouter 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;
}