ef93109f42
* Fix accidental buffer free before transfer * Refactored code to eliminate a bunch of warnings * Updated copyright headers
922 lines
24 KiB
C++
922 lines
24 KiB
C++
/**
|
|
* FreeRDP: A Remote Desktop Protocol Implementation
|
|
* Smartcard API test program
|
|
*
|
|
* This simple program can be used to trigger calls for (almose) the
|
|
* entire SCARD API.
|
|
* Compile on windows, connect with FreeRDP via RDP with smartcard
|
|
* redirection enabled and run this test program on the windows
|
|
* machine.
|
|
*
|
|
* Copyright 2020 Armin Novak <armin.novak@thincast.com>
|
|
* Copyright 2020 Thincast Technologies GmbH
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <locale>
|
|
#include <codecvt>
|
|
|
|
#include <comdef.h>
|
|
#include <winscard.h>
|
|
|
|
static const WCHAR* listW[] = { nullptr, L"SCard$AllReaders\000", L"SCard$DefaultReaders\000",
|
|
L"SCard$LocalReaders\000", L"SCard$SystemReaders\000" };
|
|
static const char* listA[] = { nullptr, "SCard$AllReaders\000", "SCard$DefaultReaders\000",
|
|
"SCard$LocalReaders\000", "SCard$SystemReaders\000" };
|
|
|
|
static std::string scope2str(DWORD scope)
|
|
{
|
|
switch (scope)
|
|
{
|
|
case SCARD_SCOPE_USER:
|
|
return "SCARD_SCOPE_USER";
|
|
case SCARD_SCOPE_TERMINAL:
|
|
return "SCARD_SCOPE_TERMINAL";
|
|
case SCARD_SCOPE_SYSTEM:
|
|
return "SCARD_SCOPE_SYSTEM";
|
|
default:
|
|
return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
static std::string err2str(LONG code)
|
|
{
|
|
switch (code)
|
|
{
|
|
case ERROR_BROKEN_PIPE:
|
|
return "ERROR_BROKEN_PIPE";
|
|
case SCARD_E_BAD_SEEK:
|
|
return "SCARD_E_BAD_SEEK";
|
|
case SCARD_E_CANCELLED:
|
|
return "SCARD_E_CANCELLED";
|
|
case SCARD_E_CANT_DISPOSE:
|
|
return "SCARD_E_CANT_DISPOSE";
|
|
case SCARD_E_CARD_UNSUPPORTED:
|
|
return "SCARD_E_CARD_UNSUPPORTED";
|
|
case SCARD_E_CERTIFICATE_UNAVAILABLE:
|
|
return "SCARD_E_CERTIFICATE_UNAVAILABLE";
|
|
case SCARD_E_COMM_DATA_LOST:
|
|
return "SCARD_E_COMM_DATA_LOST";
|
|
case SCARD_E_DIR_NOT_FOUND:
|
|
return "SCARD_E_DIR_NOT_FOUND";
|
|
case SCARD_E_DUPLICATE_READER:
|
|
return "SCARD_E_DUPLICATE_READER";
|
|
case SCARD_E_FILE_NOT_FOUND:
|
|
return "SCARD_E_FILE_NOT_FOUND";
|
|
case SCARD_E_ICC_CREATEORDER:
|
|
return "SCARD_E_ICC_CREATEORDER";
|
|
case SCARD_E_ICC_INSTALLATION:
|
|
return "SCARD_E_ICC_INSTALLATION";
|
|
case SCARD_E_INSUFFICIENT_BUFFER:
|
|
return "SCARD_E_INSUFFICIENT_BUFFER";
|
|
case SCARD_E_INVALID_ATR:
|
|
return "SCARD_E_INVALID_ATR";
|
|
case SCARD_E_INVALID_CHV:
|
|
return "SCARD_E_INVALID_CHV";
|
|
case SCARD_E_INVALID_HANDLE:
|
|
return "SCARD_E_INVALID_HANDLE";
|
|
case SCARD_E_INVALID_PARAMETER:
|
|
return "SCARD_E_INVALID_PARAMETER";
|
|
case SCARD_E_INVALID_TARGET:
|
|
return "SCARD_E_INVALID_TARGET";
|
|
case SCARD_E_INVALID_VALUE:
|
|
return "SCARD_E_INVALID_VALUE";
|
|
case SCARD_E_NO_ACCESS:
|
|
return "SCARD_E_NO_ACCESS";
|
|
case SCARD_E_NO_DIR:
|
|
return "SCARD_E_NO_DIR";
|
|
case SCARD_E_NO_FILE:
|
|
return "SCARD_E_NO_FILE";
|
|
case SCARD_E_NO_KEY_CONTAINER:
|
|
return "SCARD_E_NO_KEY_CONTAINER";
|
|
case SCARD_E_NO_MEMORY:
|
|
return "SCARD_E_NO_MEMORY";
|
|
case SCARD_E_NO_PIN_CACHE:
|
|
return "SCARD_E_NO_PIN_CACHE";
|
|
case SCARD_E_NO_READERS_AVAILABLE:
|
|
return "SCARD_E_NO_READERS_AVAILABLE";
|
|
case SCARD_E_NO_SERVICE:
|
|
return "SCARD_E_NO_SERVICE";
|
|
case SCARD_E_NO_SMARTCARD:
|
|
return "SCARD_E_NO_SMARTCARD";
|
|
case SCARD_E_NO_SUCH_CERTIFICATE:
|
|
return "SCARD_E_NO_SUCH_CERTIFICATE";
|
|
case SCARD_E_NOT_READY:
|
|
return "SCARD_E_NOT_READY";
|
|
case SCARD_E_NOT_TRANSACTED:
|
|
return "SCARD_E_NOT_TRANSACTED";
|
|
case SCARD_E_PCI_TOO_SMALL:
|
|
return "SCARD_E_PCI_TOO_SMALL";
|
|
case SCARD_E_PIN_CACHE_EXPIRED:
|
|
return "SCARD_E_PIN_CACHE_EXPIRED";
|
|
case SCARD_E_PROTO_MISMATCH:
|
|
return "SCARD_E_PROTO_MISMATCH";
|
|
case SCARD_E_READ_ONLY_CARD:
|
|
return "SCARD_E_READ_ONLY_CARD";
|
|
case SCARD_E_READER_UNAVAILABLE:
|
|
return "SCARD_E_READER_UNAVAILABLE";
|
|
case SCARD_E_READER_UNSUPPORTED:
|
|
return "SCARD_E_READER_UNSUPPORTED";
|
|
case SCARD_E_SERVER_TOO_BUSY:
|
|
return "SCARD_E_SERVER_TOO_BUSY";
|
|
case SCARD_E_SERVICE_STOPPED:
|
|
return "SCARD_E_SERVICE_STOPPED";
|
|
case SCARD_E_SHARING_VIOLATION:
|
|
return "SCARD_E_SHARING_VIOLATION";
|
|
case SCARD_E_SYSTEM_CANCELLED:
|
|
return "SCARD_E_SYSTEM_CANCELLED";
|
|
case SCARD_E_TIMEOUT:
|
|
return "SCARD_E_TIMEOUT";
|
|
case SCARD_E_UNEXPECTED:
|
|
return "SCARD_E_UNEXPECTED";
|
|
case SCARD_E_UNKNOWN_CARD:
|
|
return "SCARD_E_UNKNOWN_CARD";
|
|
case SCARD_E_UNKNOWN_READER:
|
|
return "SCARD_E_UNKNOWN_READER";
|
|
case SCARD_E_UNKNOWN_RES_MNG:
|
|
return "SCARD_E_UNKNOWN_RES_MNG";
|
|
case SCARD_E_UNSUPPORTED_FEATURE:
|
|
return "SCARD_E_UNSUPPORTED_FEATURE";
|
|
case SCARD_E_WRITE_TOO_MANY:
|
|
return "SCARD_E_WRITE_TOO_MANY";
|
|
case SCARD_F_COMM_ERROR:
|
|
return "SCARD_F_COMM_ERROR";
|
|
case SCARD_F_INTERNAL_ERROR:
|
|
return "SCARD_F_INTERNAL_ERROR";
|
|
case SCARD_F_UNKNOWN_ERROR:
|
|
return "SCARD_F_UNKNOWN_ERROR";
|
|
case SCARD_F_WAITED_TOO_LONG:
|
|
return "SCARD_F_WAITED_TOO_LONG";
|
|
case SCARD_P_SHUTDOWN:
|
|
return "SCARD_P_SHUTDOWN";
|
|
case SCARD_S_SUCCESS:
|
|
return "SCARD_S_SUCCESS";
|
|
case SCARD_W_CANCELLED_BY_USER:
|
|
return "SCARD_W_CANCELLED_BY_USER";
|
|
case SCARD_W_CACHE_ITEM_NOT_FOUND:
|
|
return "SCARD_W_CACHE_ITEM_NOT_FOUND";
|
|
case SCARD_W_CACHE_ITEM_STALE:
|
|
return "SCARD_W_CACHE_ITEM_STALE";
|
|
case SCARD_W_CACHE_ITEM_TOO_BIG:
|
|
return "SCARD_W_CACHE_ITEM_TOO_BIG";
|
|
case SCARD_W_CARD_NOT_AUTHENTICATED:
|
|
return "SCARD_W_CARD_NOT_AUTHENTICATED";
|
|
case SCARD_W_CHV_BLOCKED:
|
|
return "SCARD_W_CHV_BLOCKED";
|
|
case SCARD_W_EOF:
|
|
return "SCARD_W_EOF";
|
|
case SCARD_W_REMOVED_CARD:
|
|
return "SCARD_W_REMOVED_CARD";
|
|
case SCARD_W_RESET_CARD:
|
|
return "SCARD_W_RESET_CARD";
|
|
case SCARD_W_SECURITY_VIOLATION:
|
|
return "SCARD_W_SECURITY_VIOLATION";
|
|
case SCARD_W_UNPOWERED_CARD:
|
|
return "SCARD_W_UNPOWERED_CARD";
|
|
case SCARD_W_UNRESPONSIVE_CARD:
|
|
return "SCARD_W_UNRESPONSIVE_CARD";
|
|
case SCARD_W_UNSUPPORTED_CARD:
|
|
return "SCARD_W_UNSUPPORTED_CARD";
|
|
case SCARD_W_WRONG_CHV:
|
|
return "SCARD_W_WRONG_CHV";
|
|
default:
|
|
return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
static std::wstring err2wstr(LONG code)
|
|
{
|
|
auto str = err2str(code);
|
|
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
|
|
return converter.from_bytes(str);
|
|
}
|
|
|
|
#if 0
|
|
static bool test_listreadergroups(SCARDCONTEXT hContext) {
|
|
auto rc = SCardListReaderGroupsA(hContext, &groups, &foobar);
|
|
rc = SCardListReaderGroupsW(hContext, &groups, &foobar);
|
|
}
|
|
#endif
|
|
|
|
static bool test_valid(SCARDCONTEXT context)
|
|
{
|
|
auto rc = SCardIsValidContext(context);
|
|
if (rc)
|
|
std::cerr << "SCardIsValidContext failed with " << err2str(rc) << std::endl;
|
|
return true;
|
|
}
|
|
|
|
static bool test_list_readers_a(SCARDCONTEXT context)
|
|
{
|
|
for (auto cur : listA)
|
|
{
|
|
LPSTR mszReaders = nullptr;
|
|
DWORD chReaders = SCARD_AUTOALLOCATE;
|
|
auto rc = SCardListReadersA(context, cur, reinterpret_cast<LPSTR>(&mszReaders), &chReaders);
|
|
if (!cur)
|
|
{
|
|
cur = "NULL";
|
|
}
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardListReadersA [" << cur << "] failed with " << err2str(rc)
|
|
<< std::endl;
|
|
}
|
|
else
|
|
{
|
|
auto start = mszReaders;
|
|
auto end = &mszReaders[chReaders];
|
|
|
|
std::cout << "SCardListReadersA [" << cur << "] " << chReaders << " [";
|
|
while (start < end)
|
|
{
|
|
std::cout << start << ", ";
|
|
start += strnlen(start, chReaders) + 2;
|
|
}
|
|
std::cout << "]" << std::endl;
|
|
}
|
|
SCardFreeMemory(context, mszReaders);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_list_readers_w(SCARDCONTEXT context)
|
|
{
|
|
for (auto cur : listW)
|
|
{
|
|
LPWSTR mszReaders = nullptr;
|
|
DWORD chReaders = SCARD_AUTOALLOCATE;
|
|
auto rc =
|
|
SCardListReadersW(context, cur, reinterpret_cast<LPWSTR>(&mszReaders), &chReaders);
|
|
if (!cur)
|
|
{
|
|
cur = L"NULL";
|
|
}
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::wcerr << L"SCardListReadersW [" << cur << L"] failed with " << err2wstr(rc)
|
|
<< std::endl;
|
|
}
|
|
else
|
|
{
|
|
auto start = mszReaders;
|
|
auto end = &mszReaders[chReaders];
|
|
|
|
std::wcout << L"SCardListReadersW [" << cur << L"] " << chReaders << L" [";
|
|
while (start < end)
|
|
{
|
|
std::wcout << start << L", ";
|
|
start += wcsnlen(start, chReaders) + 2;
|
|
}
|
|
std::wcout << L"]" << std::endl;
|
|
}
|
|
SCardFreeMemory(context, mszReaders);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_list_reader_groups_a(SCARDCONTEXT context)
|
|
{
|
|
LPSTR mszReaders = nullptr;
|
|
DWORD chReaders = SCARD_AUTOALLOCATE;
|
|
auto rc = SCardListReaderGroupsA(context, reinterpret_cast<LPSTR>(&mszReaders), &chReaders);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardListReaderGroupsA failed with " << err2str(rc) << std::endl;
|
|
}
|
|
else
|
|
{
|
|
auto start = mszReaders;
|
|
auto end = &mszReaders[chReaders];
|
|
|
|
std::cout << "SCardListReaderGroupsA " << chReaders << " [";
|
|
while (start < end)
|
|
{
|
|
std::cout << start << ", ";
|
|
start += strnlen(start, chReaders) + 2;
|
|
}
|
|
std::cout << "]" << std::endl;
|
|
}
|
|
SCardFreeMemory(context, mszReaders);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_list_reader_groups_w(SCARDCONTEXT context)
|
|
{
|
|
LPWSTR mszReaders = nullptr;
|
|
DWORD chReaders = SCARD_AUTOALLOCATE;
|
|
auto rc = SCardListReaderGroupsW(context, reinterpret_cast<LPWSTR>(&mszReaders), &chReaders);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::wcerr << L"SCardListReaderGroupsW failed with " << err2wstr(rc) << std::endl;
|
|
}
|
|
else
|
|
{
|
|
auto start = mszReaders;
|
|
auto end = &mszReaders[chReaders];
|
|
|
|
std::wcout << L"SCardListReaderGroupsW " << chReaders << L" [";
|
|
while (start < end)
|
|
{
|
|
std::wcout << start << L", ";
|
|
start += wcsnlen(start, chReaders) + 2;
|
|
}
|
|
std::wcout << L"]" << std::endl;
|
|
}
|
|
SCardFreeMemory(context, mszReaders);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_introduce_forget_reader_groups_a(SCARDCONTEXT context)
|
|
{
|
|
LPSTR group = "somefancygroup";
|
|
|
|
auto rc = SCardIntroduceReaderGroupA(context, group);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardIntroduceReaderGroupA failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
rc = SCardForgetReaderGroupA(context, group);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardForgetReaderGroupA failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static bool test_introduce_forget_reader_groups_w(SCARDCONTEXT context)
|
|
{
|
|
LPWSTR group = L"somefancygroup";
|
|
|
|
auto rc = SCardIntroduceReaderGroupW(context, group);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardIntroduceReaderGroupW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
rc = SCardForgetReaderGroupW(context, group);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardForgetReaderGroupW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static bool test_introduce_forget_reader_a(SCARDCONTEXT context)
|
|
{
|
|
LPSTR reader = "somefancygroup";
|
|
LPSTR device = "otherfancy";
|
|
|
|
auto rc = SCardIntroduceReaderA(context, reader, device);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardIntroduceReaderA failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
rc = SCardForgetReaderA(context, reader);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardForgetReaderA failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static bool test_introduce_forget_reader_w(SCARDCONTEXT context)
|
|
{
|
|
LPWSTR reader = L"somefancygroup";
|
|
LPWSTR device = L"otherfancy";
|
|
|
|
auto rc = SCardIntroduceReaderW(context, reader, device);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardIntroduceReaderW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
rc = SCardForgetReaderW(context, reader);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardForgetReaderW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static bool test_list_cards_a(SCARDCONTEXT context)
|
|
{
|
|
DWORD chCards = SCARD_AUTOALLOCATE;
|
|
LPSTR mszCards = nullptr;
|
|
auto rc =
|
|
SCardListCardsA(context, nullptr, nullptr, 0, reinterpret_cast<LPSTR>(&mszCards), &chCards);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardListCardsA failed with " << err2str(rc) << std::endl;
|
|
}
|
|
else
|
|
{
|
|
auto start = mszCards;
|
|
auto end = &mszCards[chCards];
|
|
std::cout << "SCardListCardsA " << chCards << " [";
|
|
while (start < end)
|
|
{
|
|
std::cout << start << ", ";
|
|
start += strnlen(start, chCards) + 2;
|
|
}
|
|
std::cout << "]" << std::endl;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool test_list_cards_w(SCARDCONTEXT context)
|
|
{
|
|
DWORD chCards = SCARD_AUTOALLOCATE;
|
|
LPWSTR mszCards = nullptr;
|
|
auto rc = SCardListCardsW(context, nullptr, nullptr, 0, reinterpret_cast<LPWSTR>(&mszCards),
|
|
&chCards);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardListCardsW failed with " << err2str(rc) << std::endl;
|
|
}
|
|
else
|
|
{
|
|
auto start = mszCards;
|
|
auto end = &mszCards[chCards];
|
|
std::cout << "SCardListCardsW " << chCards << " [";
|
|
while (start < end)
|
|
{
|
|
std::wcout << start << L", ";
|
|
start += wcsnlen(start, chCards) + 2;
|
|
}
|
|
std::cout << "]" << std::endl;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool test_cache_a(SCARDCONTEXT context)
|
|
{
|
|
BYTE wdata[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
|
|
const DWORD wdatalen = sizeof(wdata);
|
|
BYTE data[32] = {};
|
|
DWORD datalen = sizeof(data);
|
|
LPSTR name = "testdata";
|
|
UUID id = {};
|
|
|
|
auto rc = SCardWriteCacheA(context, &id, 0, name, wdata, wdatalen);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardWriteCacheA failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
rc = SCardReadCacheA(context, &id, 0, name, data, &datalen);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardReadCacheA failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (wdatalen != datalen)
|
|
{
|
|
std::cerr << "SCardWriteCacheA wrote " << wdatalen << "bytes, SCardReadCacheA read "
|
|
<< datalen << "bytes" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (memcmp(wdata, data, wdatalen) != 0)
|
|
{
|
|
std::cerr << "SCardWriteCacheA / SCardReadCacheA data corruption detected" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_cache_w(SCARDCONTEXT context)
|
|
{
|
|
BYTE wdata[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
|
|
const DWORD wdatalen = sizeof(wdata);
|
|
BYTE data[32] = {};
|
|
DWORD datalen = sizeof(data);
|
|
LPWSTR name = L"testdata";
|
|
UUID id = {};
|
|
|
|
auto rc = SCardWriteCacheW(context, &id, 0, name, wdata, wdatalen);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardWriteCacheW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
rc = SCardReadCacheW(context, &id, 0, name, data, &datalen);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardReadCacheW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (wdatalen != datalen)
|
|
{
|
|
std::cerr << "SCardReadCacheW wrote " << wdatalen << "bytes, SCardReadCacheW read "
|
|
<< datalen << "bytes" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (memcmp(wdata, data, wdatalen) != 0)
|
|
{
|
|
std::cerr << "SCardReadCacheW / SCardReadCacheW data corruption detected" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_reader_icon_a(SCARDCONTEXT context)
|
|
{
|
|
LPSTR name = "Gemalto PC Twin Reader 00 00\0\0";
|
|
LPBYTE pbIcon = nullptr;
|
|
DWORD cbIcon = SCARD_AUTOALLOCATE;
|
|
|
|
auto rc = SCardGetReaderIconA(context, name, reinterpret_cast<LPBYTE>(&pbIcon), &cbIcon);
|
|
SCardFreeMemory(context, pbIcon);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardGetReaderIconA failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_reader_icon_w(SCARDCONTEXT context)
|
|
{
|
|
LPWSTR name = L"Gemalto PC Twin Reader 00 00\0\0";
|
|
LPBYTE pbIcon = nullptr;
|
|
DWORD cbIcon = SCARD_AUTOALLOCATE;
|
|
|
|
auto rc = SCardGetReaderIconW(context, name, reinterpret_cast<LPBYTE>(&pbIcon), &cbIcon);
|
|
SCardFreeMemory(context, pbIcon);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardGetReaderIconW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_locate_cards_a(SCARDCONTEXT context)
|
|
{
|
|
LPSTR name = "Gemalto PC Twin Reader 00 00\0\0";
|
|
SCARD_READERSTATEA rgReaderStates[16] = {};
|
|
|
|
auto rc = SCardLocateCardsA(context, name, rgReaderStates, ARRAYSIZE(rgReaderStates));
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardLocateCardsA failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_locate_cards_w(SCARDCONTEXT context)
|
|
{
|
|
LPWSTR name = L"Gemalto PC Twin Reader 00 00\0\0";
|
|
SCARD_READERSTATEW rgReaderStates[16] = {};
|
|
|
|
auto rc = SCardLocateCardsW(context, name, rgReaderStates, ARRAYSIZE(rgReaderStates));
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardLocateCardsW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_locate_cards_by_atr_a(SCARDCONTEXT context)
|
|
{
|
|
SCARD_READERSTATEA rgReaderStates[16] = {};
|
|
SCARD_ATRMASK rgAtrMasks[16] = {};
|
|
|
|
auto rc = SCardLocateCardsByATRA(context, rgAtrMasks, ARRAYSIZE(rgAtrMasks), rgReaderStates,
|
|
ARRAYSIZE(rgReaderStates));
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardLocateCardsByATRA failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_locate_cards_by_atr_w(SCARDCONTEXT context)
|
|
{
|
|
SCARD_READERSTATEW rgReaderStates[16] = {};
|
|
SCARD_ATRMASK rgAtrMasks[16] = {};
|
|
|
|
auto rc = SCardLocateCardsByATRW(context, rgAtrMasks, ARRAYSIZE(rgAtrMasks), rgReaderStates,
|
|
ARRAYSIZE(rgReaderStates));
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardLocateCardsByATRW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_devicetype_id_a(SCARDCONTEXT context)
|
|
{
|
|
BYTE data[32] = {};
|
|
LPSTR name = "testdata";
|
|
DWORD type;
|
|
|
|
auto rc = SCardGetDeviceTypeIdA(context, name, &type);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardGetDeviceTypeIdA failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_devicetype_id_w(SCARDCONTEXT context)
|
|
{
|
|
BYTE data[32] = {};
|
|
LPWSTR name = L"testdata";
|
|
DWORD type;
|
|
|
|
auto rc = SCardGetDeviceTypeIdW(context, name, &type);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardGetDeviceTypeIdW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_transmitcount(SCARDHANDLE handle)
|
|
{
|
|
BYTE data[32] = {};
|
|
LPWSTR name = L"testdata";
|
|
DWORD count;
|
|
|
|
auto rc = SCardGetTransmitCount(handle, &count);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardGetTransmitCount failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
std::cout << "SCardGetTransmitCount() " << count << std::endl;
|
|
return true;
|
|
}
|
|
|
|
static bool test_status_a(SCARDHANDLE handle)
|
|
{
|
|
BYTE data[32] = {};
|
|
LPWSTR name = L"testdata";
|
|
DWORD count;
|
|
/*
|
|
auto rc = SCardStatusA(handle, names, len, &state, &protocol, attr, &attrlen);
|
|
if (rc != SCARD_S_SUCCESS) {
|
|
std::cerr << "SCardGetDeviceTypeIdW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
*/
|
|
return true;
|
|
}
|
|
|
|
static bool test_status_w(SCARDHANDLE handle)
|
|
{
|
|
BYTE data[32] = {};
|
|
LPWSTR name = L"testdata";
|
|
DWORD count;
|
|
/*
|
|
auto rc = SCardStatusA(handle, names, len, &state, &protocol, attr, &attrlen);
|
|
if (rc != SCARD_S_SUCCESS) {
|
|
std::cerr << "SCardGetDeviceTypeIdW failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
*/
|
|
return true;
|
|
}
|
|
|
|
static bool test_get_attrib(SCARDCONTEXT context, SCARDHANDLE handle)
|
|
{
|
|
DWORD attrlen = SCARD_AUTOALLOCATE;
|
|
LPBYTE attr = nullptr;
|
|
|
|
auto rc =
|
|
SCardGetAttrib(handle, SCARD_ATTR_ATR_STRING, reinterpret_cast<LPBYTE>(&attr), &attrlen);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardGetAttrib failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
std::cout << "SCardGetAttrib [" << attrlen << "]: " << (char*)attr << std::endl;
|
|
SCardFreeMemory(context, attr);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool test_set_attrib(SCARDCONTEXT context, SCARDHANDLE handle)
|
|
{
|
|
DWORD attrlen = SCARD_AUTOALLOCATE;
|
|
BYTE attr[] = "0123456789";
|
|
|
|
auto rc = SCardSetAttrib(handle, SCARD_ATTR_SUPRESS_T1_IFS_REQUEST, attr, ARRAYSIZE(attr));
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardSetAttrib failed with " << err2str(rc) << std::endl;
|
|
return false;
|
|
}
|
|
std::cout << "SCardSetAttrib [" << attrlen << "]: " << (char*)attr << std::endl;
|
|
SCardFreeMemory(context, attr);
|
|
|
|
return true;
|
|
}
|
|
|
|
int main()
|
|
{
|
|
std::cout << "Hello World!" << std::endl;
|
|
try
|
|
{
|
|
auto scopes = { SCARD_SCOPE_USER, SCARD_SCOPE_SYSTEM };
|
|
for (auto scope : scopes)
|
|
{
|
|
SCARDCONTEXT context;
|
|
auto rc = SCardEstablishContext(scope, nullptr, nullptr, &context);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardEstablishContext [" << scope2str(scope) << "] failed with "
|
|
<< err2str(rc) << std::endl;
|
|
}
|
|
else
|
|
{
|
|
std::cerr << "SCardEstablishContext [" << scope2str(scope) << "] success"
|
|
<< std::endl;
|
|
|
|
test_valid(context);
|
|
|
|
test_list_reader_groups_a(context);
|
|
test_list_reader_groups_w(context);
|
|
|
|
test_list_readers_a(context);
|
|
test_list_readers_w(context);
|
|
|
|
test_list_cards_a(context);
|
|
test_list_cards_w(context);
|
|
|
|
test_introduce_forget_reader_groups_a(context);
|
|
test_introduce_forget_reader_groups_w(context);
|
|
|
|
test_introduce_forget_reader_a(context);
|
|
test_introduce_forget_reader_w(context);
|
|
|
|
// TODO: Introduce/Remove reader to group
|
|
test_locate_cards_a(context);
|
|
test_locate_cards_w(context);
|
|
|
|
test_locate_cards_by_atr_a(context);
|
|
test_locate_cards_by_atr_w(context);
|
|
|
|
test_cache_a(context);
|
|
test_cache_w(context);
|
|
|
|
test_reader_icon_a(context);
|
|
test_reader_icon_w(context);
|
|
|
|
test_devicetype_id_a(context);
|
|
test_devicetype_id_w(context);
|
|
|
|
// TODO: statuschange
|
|
// TODO: begin/end transaction
|
|
// TODO: state
|
|
// TODO: transmit
|
|
// TODO: control
|
|
|
|
{
|
|
DWORD protocol;
|
|
SCARDHANDLE handle = 0;
|
|
LPSTR mszReaders;
|
|
DWORD chReaders = SCARD_AUTOALLOCATE;
|
|
|
|
LONG status = SCardListReadersA(
|
|
context, nullptr, reinterpret_cast<LPSTR>(&mszReaders), &chReaders);
|
|
if (status == SCARD_S_SUCCESS)
|
|
status = SCardConnectA(context, mszReaders, SCARD_SHARE_SHARED,
|
|
SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1 |
|
|
SCARD_PROTOCOL_Tx | SCARD_PROTOCOL_RAW,
|
|
&handle, &protocol);
|
|
SCardFreeMemory(context, mszReaders);
|
|
if (status != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardConnectA ["
|
|
<< "] failed with " << err2str(status) << std::endl;
|
|
}
|
|
else
|
|
{
|
|
test_status_a(handle);
|
|
test_status_w(handle);
|
|
test_get_attrib(context, handle);
|
|
test_set_attrib(context, handle);
|
|
test_transmitcount(handle);
|
|
|
|
status = SCardDisconnect(handle, 0);
|
|
if (status)
|
|
{
|
|
std::cerr << "SCardDisconnect ["
|
|
<< "] failed with " << err2str(status) << std::endl;
|
|
}
|
|
}
|
|
}
|
|
{
|
|
DWORD protocol;
|
|
SCARDHANDLE handle = 0;
|
|
LPWSTR mszReaders;
|
|
DWORD chReaders = SCARD_AUTOALLOCATE;
|
|
|
|
LONG status = SCardListReadersW(
|
|
context, nullptr, reinterpret_cast<LPWSTR>(&mszReaders), &chReaders);
|
|
if (status == SCARD_S_SUCCESS)
|
|
status = SCardConnectW(context, mszReaders, SCARD_SHARE_SHARED,
|
|
SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1 |
|
|
SCARD_PROTOCOL_Tx | SCARD_PROTOCOL_RAW,
|
|
&handle, &protocol);
|
|
SCardFreeMemory(context, mszReaders);
|
|
|
|
if (status != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardConnectW ["
|
|
<< "] failed with " << err2str(status) << std::endl;
|
|
}
|
|
else
|
|
{
|
|
test_status_a(handle);
|
|
test_status_w(handle);
|
|
test_get_attrib(context, handle);
|
|
test_set_attrib(context, handle);
|
|
test_transmitcount(handle);
|
|
|
|
status = SCardDisconnect(handle, 0);
|
|
if (status)
|
|
{
|
|
std::cerr << "SCardDisconnect ["
|
|
<< "] failed with " << err2str(status) << std::endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
rc = SCardReleaseContext(context);
|
|
if (rc != SCARD_S_SUCCESS)
|
|
{
|
|
std::cerr << "SCardReleaseContext [" << scope2str(scope) << "] failed with "
|
|
<< err2str(rc) << std::endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
std::cerr << "exception!!!!" << std::endl;
|
|
}
|
|
|
|
return 0;
|
|
}
|