diff --git a/.github/workflows/cmake-linux-ubuntu.yml b/.github/workflows/cmake-linux-ubuntu.yml index e31fca7..47d9f3b 100644 --- a/.github/workflows/cmake-linux-ubuntu.yml +++ b/.github/workflows/cmake-linux-ubuntu.yml @@ -11,21 +11,13 @@ jobs: container: mrts/qt-cmake-gtest-valgrind-ubuntu:v1.8 steps: - - uses: actions/checkout@v2 - with: - submodules: recursive - - - name: Create build directory - run: mkdir build + - uses: actions/checkout@v4 - name: Configure CMake - working-directory: ${{github.workspace}}/build - run: cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE .. + run: cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -S . -B build - name: Build - working-directory: ${{github.workspace}}/build - run: cmake --build . --config $BUILD_TYPE + run: cmake --build build --config $BUILD_TYPE - name: Test - working-directory: ${{github.workspace}}/build - run: ctest -V -C $BUILD_TYPE + run: ctest -V -C $BUILD_TYPE --test-dir build diff --git a/.github/workflows/cmake-macos.yml b/.github/workflows/cmake-macos.yml index e3370a4..0a6d8ae 100644 --- a/.github/workflows/cmake-macos.yml +++ b/.github/workflows/cmake-macos.yml @@ -12,26 +12,16 @@ jobs: steps: - name: Checkout code - uses: actions/checkout@v2 - with: - submodules: recursive + uses: actions/checkout@v4 - name: Install libraries - run: | - brew install web-eid/gtest/gtest - ln -sf /usr/local/Cellar/openssl@1.1/1.1.1* /usr/local/opt/openssl - - - name: Create build directory - run: mkdir build + run: brew install web-eid/gtest/gtest - name: Configure CMake - working-directory: ${{github.workspace}}/build - run: cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE} .. + run: cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -B build -S . - name: Build - working-directory: ${{github.workspace}}/build - run: cmake --build . --config ${BUILD_TYPE} + run: cmake --build build --config ${BUILD_TYPE} - name: Test - working-directory: ${{github.workspace}}/build - run: ctest -V -C ${BUILD_TYPE} + run: ctest -V -C ${BUILD_TYPE} --test-dir build diff --git a/.github/workflows/cmake-windows.yml b/.github/workflows/cmake-windows.yml index 597e280..1cb7c00 100644 --- a/.github/workflows/cmake-windows.yml +++ b/.github/workflows/cmake-windows.yml @@ -11,29 +11,20 @@ jobs: steps: - name: Checkout code - uses: actions/checkout@v2 - with: - submodules: recursive + uses: actions/checkout@v4 - name: Prepare vcpkg and libraries - uses: lukka/run-vcpkg@v6 + uses: lukka/run-vcpkg@v7 with: vcpkgArguments: gtest:x64-windows openssl:x64-windows vcpkgTriplet: x64-windows - vcpkgDirectory: ${{runner.workspace}}/vcpkg/ - vcpkgGitCommitId: 9b064ff07b987c8f213fdbf4358122fd4fe38ef1 - - - name: Create build directory - run: mkdir build + vcpkgGitCommitId: 1f619be01b436b796dab797dd1e1721c5676f8ac - name: Configure CMake - working-directory: ${{github.workspace}}/build - run: cmake -A x64 "-DCMAKE_TOOLCHAIN_FILE=${{runner.workspace}}/vcpkg/scripts/buildsystems/vcpkg.cmake" "-DCMAKE_BUILD_TYPE=${env:BUILD_TYPE}" .. + run: cmake -A x64 "-DCMAKE_TOOLCHAIN_FILE=${env:VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake" "-DCMAKE_BUILD_TYPE=${env:BUILD_TYPE}" -S . -B build - name: Build - working-directory: ${{github.workspace}}/build - run: cmake --build . --config ${env:BUILD_TYPE} + run: cmake --build build --config ${env:BUILD_TYPE} - name: Test - working-directory: ${{github.workspace}}/build - run: ctest -V -C ${env:BUILD_TYPE} + run: ctest -V -C ${env:BUILD_TYPE}--test-dir build diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index 9538fb1..b4e38c9 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -19,9 +19,7 @@ jobs: steps: - name: Checkout repository - uses: actions/checkout@v3 - with: - submodules: recursive + uses: actions/checkout@v4 - name: Initialize CodeQL uses: github/codeql-action/init@v2 diff --git a/.gitmodules b/.gitmodules index 151a171..e69de29 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +0,0 @@ -[submodule "lib/libpcsc-cpp"] - path = lib/libpcsc-cpp - url = ../libpcsc-cpp diff --git a/lib/libpcsc-cpp b/lib/libpcsc-cpp deleted file mode 160000 index fd79af3..0000000 --- a/lib/libpcsc-cpp +++ /dev/null @@ -1 +0,0 @@ -Subproject commit fd79af3ed4aa4b36dccaea26fd5c23dc1216134a diff --git a/lib/libpcsc-cpp/CMakeLists.txt b/lib/libpcsc-cpp/CMakeLists.txt new file mode 100644 index 0000000..7b728a1 --- /dev/null +++ b/lib/libpcsc-cpp/CMakeLists.txt @@ -0,0 +1,96 @@ +cmake_minimum_required(VERSION 3.16) + +project(pcsc-cpp) + +# The libpcsc-cpp library itself. + +add_library(${PROJECT_NAME} + STATIC + include/${PROJECT_NAME}/${PROJECT_NAME}.hpp + include/${PROJECT_NAME}/${PROJECT_NAME}-utils.hpp + include/${PROJECT_NAME}/comp_winscard.hpp + include/flag-set-cpp/flag_set.hpp + include/magic_enum/magic_enum.hpp + src/Context.hpp + src/Reader.cpp + src/SCardCall.hpp + src/SmartCard.cpp + src/listReaders.cpp + src/utils.cpp +) + +target_include_directories(${PROJECT_NAME} + PUBLIC + include +) + +target_compile_features(${PROJECT_NAME} + PUBLIC + cxx_std_17 +) + +target_compile_options(${PROJECT_NAME} PUBLIC + $<$:/W4 /WX> + $<$>:-Wall -Wextra -pedantic -Werror> +) + +target_compile_definitions(${PROJECT_NAME} PUBLIC + $<$:WIN32_LEAN_AND_MEAN;UNICODE;_CRT_SECURE_NO_WARNINGS> +) + +target_link_libraries(${PROJECT_NAME} PRIVATE + $<$:Ws2_32> +) + +# PC/SC API dependencies. + +add_library(pcsc INTERFACE) +if(MSVC) + target_link_libraries(pcsc INTERFACE winscard) +elseif(APPLE) + target_link_libraries(pcsc INTERFACE "-framework PCSC") +else() + find_package(PkgConfig REQUIRED) + pkg_check_modules(PCSC libpcsclite REQUIRED IMPORTED_TARGET) + target_include_directories(${PROJECT_NAME} PRIVATE ${PCSC_INCLUDE_DIRS}) + target_link_libraries(pcsc INTERFACE PkgConfig::PCSC) +endif() + +# Common testing options. + +enable_testing() + +find_package(GTest REQUIRED) + +# Mock tests that use libpcsc-mock to mock PC/SC API calls. + +set(MOCK_TEST_EXE lib${PROJECT_NAME}-test-mock) + +add_subdirectory(tests/lib/libpcsc-mock) + +add_executable(${MOCK_TEST_EXE} + tests/mock/test-select-card-reader-and-card.cpp + tests/mock/test-connect-to-card-transmit-apdus.cpp +) + +target_link_libraries(${MOCK_TEST_EXE} + ${PROJECT_NAME} + pcsc-mock + GTest::Main +) + +add_test(${MOCK_TEST_EXE} ${MOCK_TEST_EXE}) + +# Integration tests that use the real operating system PC/SC service. + +set(INTEGRATION_TEST_EXE lib${PROJECT_NAME}-test-integration) + +add_executable(${INTEGRATION_TEST_EXE} + tests/integration/test-${PROJECT_NAME}.cpp +) + +target_link_libraries(${INTEGRATION_TEST_EXE} + ${PROJECT_NAME} + pcsc + GTest::Main +) diff --git a/lib/libpcsc-cpp/LICENSE b/lib/libpcsc-cpp/LICENSE new file mode 100644 index 0000000..326ac32 --- /dev/null +++ b/lib/libpcsc-cpp/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020-2023 Estonian Information System Authority + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/lib/libpcsc-cpp/README.md b/lib/libpcsc-cpp/README.md new file mode 100644 index 0000000..33329fc --- /dev/null +++ b/lib/libpcsc-cpp/README.md @@ -0,0 +1,48 @@ +# libpcsc-cpp + +![European Regional Development Fund](https://github.com/open-eid/DigiDoc4-Client/blob/master/client/images/EL_Regionaalarengu_Fond.png) + +C++ library for accessing smart cards using the PC/SC API. + +## Usage + +Example how to list available readers, connect to the smart card in first +reader and transmit an APDU: + + auto readers = listReaders(); + auto card = readers[0].connectToCard(); + auto command = CommandApdu::fromBytes({0x2, 0x1, 0x3, 0x4}); + + auto transactionGuard = card->beginTransaction(); + auto response = card->transmit(command); + +See more examples in [tests](tests). + +## Building + +In Ubuntu: + + apt install build-essential pkg-config cmake libgtest-dev valgrind libpcsclite-dev + sudo bash -c 'cd /usr/src/googletest && cmake . && cmake --build . --target install' + + cd build + cmake .. # optionally with -DCMAKE_BUILD_TYPE=Debug + cmake --build . # optionally with VERBOSE=1 + +## Testing + +Build as described above, then, inside the `build` directory, run: + + ctest # or 'valgrind --leak-check=full ctest' + +`ctest` runs tests that use the _libscard-mock_ library to mock PC/SC API calls. + +There are also integration tests that use the real operating system PC/SC +service, run them inside `build` directory with: + + ./libpcsc-cpp-test-integration + +## Development guidelines + +- Format code with `scripts/clang-format.sh` before committing +- See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) diff --git a/lib/libpcsc-cpp/docs/DEVELOPMENT.md b/lib/libpcsc-cpp/docs/DEVELOPMENT.md new file mode 100644 index 0000000..aee7cee --- /dev/null +++ b/lib/libpcsc-cpp/docs/DEVELOPMENT.md @@ -0,0 +1,8 @@ +TODO: + +- coding conventions - Qt coding style and conventions +- gtest and winscard-mock usage +- API +- architecture +- technical design + - describe PIMPL (we don't want to leak `winscard.h` to clients) diff --git a/lib/libpcsc-cpp/include/flag-set-cpp/flag_set.hpp b/lib/libpcsc-cpp/include/flag-set-cpp/flag_set.hpp new file mode 100644 index 0000000..cfb9293 --- /dev/null +++ b/lib/libpcsc-cpp/include/flag-set-cpp/flag_set.hpp @@ -0,0 +1,175 @@ +/* + * Copyright (c) 2019 Arnaud Kapp (Xaqq), Barry Revzin, Mart Somermaa + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +// flag_set is a type-safe class for using enums as flags in C++14 with an underlying std::bitset. +// See https://github.com/mrts/flag-set-cpp + +#pragma once + +#include +#include +#include +#include + +template +class flag_set +{ +public: + flag_set() = default; + + explicit flag_set(const T& val) { flags.set(static_cast(val)); } + + // Binary operations. + + flag_set& operator&=(const T& val) noexcept + { + bool tmp = flags.test(static_cast(val)); + flags.reset(); + flags.set(static_cast(val), tmp); + return *this; + } + + flag_set& operator&=(const flag_set& o) noexcept + { + flags &= o.flags; + return *this; + } + + flag_set& operator|=(const T& val) noexcept + { + flags.set(static_cast(val)); + return *this; + } + + flag_set& operator|=(const flag_set& o) noexcept + { + flags |= o.flags; + return *this; + } + + // The resulting bitset can contain at most 1 bit. + flag_set operator&(const T& val) const + { + flag_set ret(*this); + ret &= val; + + assert(ret.flags.count() <= 1); + return ret; + } + + flag_set operator&(const flag_set& val) const + { + flag_set ret(*this); + ret.flags &= val.flags; + + return ret; + } + + // The resulting bitset contains at least 1 bit. + flag_set operator|(const T& val) const + { + flag_set ret(*this); + ret |= val; + + assert(ret.flags.count() >= 1); + return ret; + } + + flag_set operator|(const flag_set& val) const + { + flag_set ret(*this); + ret.flags |= val.flags; + + return ret; + } + + flag_set operator~() const + { + flag_set cp(*this); + cp.flags.flip(); + + return cp; + } + + // The bitset evaluates to true if any bit is set. + explicit operator bool() const { return flags.any(); } + + // Methods from std::bitset. + + bool operator==(const flag_set& o) const { return flags == o.flags; } + + std::size_t size() const { return flags.size(); } + + std::size_t count() const { return flags.count(); } + + flag_set& set() + { + flags.set(); + return *this; + } + + flag_set& reset() + { + flags.reset(); + return *this; + } + + flag_set& flip() + { + flags.flip(); + return *this; + } + + flag_set& set(const T& val, bool value = true) + { + flags.set(static_cast(val), value); + return *this; + } + + flag_set& reset(const T& val) + { + flags.reset(static_cast(val)); + return *this; + } + + flag_set& flip(const T& val) + { + flags.flip(static_cast(val)); + return *this; + } + + constexpr bool operator[](const T& val) const { return flags[static_cast(val)]; } + + std::string to_string() const { return flags.to_string(); } + + // Operator for outputting to stream. + friend std::ostream& operator<<(std::ostream& stream, const flag_set& self) + { + return stream << self.flags; + } + +private: + using u_type = std::underlying_type_t; + + // _ is last value sentinel and must be present in enum T. + std::bitset(T::_)> flags; +}; diff --git a/lib/libpcsc-cpp/include/magic_enum/magic_enum.hpp b/lib/libpcsc-cpp/include/magic_enum/magic_enum.hpp new file mode 100644 index 0000000..3769be1 --- /dev/null +++ b/lib/libpcsc-cpp/include/magic_enum/magic_enum.hpp @@ -0,0 +1,1438 @@ +// __ __ _ ______ _____ +// | \/ | (_) | ____| / ____|_ _ +// | \ / | __ _ __ _ _ ___ | |__ _ __ _ _ _ __ ___ | | _| |_ _| |_ +// | |\/| |/ _` |/ _` | |/ __| | __| | '_ \| | | | '_ ` _ \ | | |_ _|_ _| +// | | | | (_| | (_| | | (__ | |____| | | | |_| | | | | | | | |____|_| |_| +// |_| |_|\__,_|\__, |_|\___| |______|_| |_|\__,_|_| |_| |_| \_____| +// __/ | https://github.com/Neargye/magic_enum +// |___/ version 0.9.3 +// +// Licensed under the MIT License . +// SPDX-License-Identifier: MIT +// Copyright (c) 2019 - 2023 Daniil Goncharov . +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +#ifndef NEARGYE_MAGIC_ENUM_HPP +#define NEARGYE_MAGIC_ENUM_HPP + +#define MAGIC_ENUM_VERSION_MAJOR 0 +#define MAGIC_ENUM_VERSION_MINOR 9 +#define MAGIC_ENUM_VERSION_PATCH 3 + +#include +#include +#include +#include +#include +#include +#include + +#if defined(MAGIC_ENUM_CONFIG_FILE) +# include MAGIC_ENUM_CONFIG_FILE +#endif + +#if !defined(MAGIC_ENUM_USING_ALIAS_OPTIONAL) +# include +#endif +#if !defined(MAGIC_ENUM_USING_ALIAS_STRING) +# include +#endif +#if !defined(MAGIC_ENUM_USING_ALIAS_STRING_VIEW) +# include +#endif + +#if defined(MAGIC_ENUM_NO_ASSERT) +# define MAGIC_ENUM_ASSERT(...) static_cast(0) +#else +# include +# define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__)) +#endif + +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# pragma clang diagnostic ignored "-Wenum-constexpr-conversion" +#elif defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // May be used uninitialized 'return {};'. +#elif defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 26495) // Variable 'static_str::chars_' is uninitialized. +# pragma warning(disable : 28020) // Arithmetic overflow: Using operator '-' on a 4 byte value and then casting the result to a 8 byte value. +# pragma warning(disable : 26451) // The expression '0<=_Param_(1)&&_Param_(1)<=1-1' is not true at this call. +# pragma warning(disable : 4514) // Unreferenced inline function has been removed. +#endif + +// Checks magic_enum compiler compatibility. +#if defined(__clang__) && __clang_major__ >= 5 || defined(__GNUC__) && __GNUC__ >= 9 || defined(_MSC_VER) && _MSC_VER >= 1910 || defined(__RESHARPER__) +# undef MAGIC_ENUM_SUPPORTED +# define MAGIC_ENUM_SUPPORTED 1 +#endif + +// Checks magic_enum compiler aliases compatibility. +#if defined(__clang__) && __clang_major__ >= 5 || defined(__GNUC__) && __GNUC__ >= 9 || defined(_MSC_VER) && _MSC_VER >= 1920 +# undef MAGIC_ENUM_SUPPORTED_ALIASES +# define MAGIC_ENUM_SUPPORTED_ALIASES 1 +#endif + +// Enum value must be greater or equals than MAGIC_ENUM_RANGE_MIN. By default MAGIC_ENUM_RANGE_MIN = -128. +// If need another min range for all enum types by default, redefine the macro MAGIC_ENUM_RANGE_MIN. +#if !defined(MAGIC_ENUM_RANGE_MIN) +# define MAGIC_ENUM_RANGE_MIN -128 +#endif + +// Enum value must be less or equals than MAGIC_ENUM_RANGE_MAX. By default MAGIC_ENUM_RANGE_MAX = 128. +// If need another max range for all enum types by default, redefine the macro MAGIC_ENUM_RANGE_MAX. +#if !defined(MAGIC_ENUM_RANGE_MAX) +# define MAGIC_ENUM_RANGE_MAX 127 +#endif + +// Improve ReSharper C++ intellisense performance with builtins, avoiding unnecessary template instantiations. +#if defined(__RESHARPER__) +# undef MAGIC_ENUM_GET_ENUM_NAME_BUILTIN +# undef MAGIC_ENUM_GET_TYPE_NAME_BUILTIN +# if __RESHARPER__ >= 20230100 +# define MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V) __rscpp_enumerator_name(V) +# define MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(T) __rscpp_type_name() +# else +# define MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V) nullptr +# define MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(T) nullptr +# endif +#endif + +namespace magic_enum { + +// If need another optional type, define the macro MAGIC_ENUM_USING_ALIAS_OPTIONAL. +#if defined(MAGIC_ENUM_USING_ALIAS_OPTIONAL) +MAGIC_ENUM_USING_ALIAS_OPTIONAL +#else +using std::optional; +#endif + +// If need another string_view type, define the macro MAGIC_ENUM_USING_ALIAS_STRING_VIEW. +#if defined(MAGIC_ENUM_USING_ALIAS_STRING_VIEW) +MAGIC_ENUM_USING_ALIAS_STRING_VIEW +#else +using std::string_view; +#endif + +// If need another string type, define the macro MAGIC_ENUM_USING_ALIAS_STRING. +#if defined(MAGIC_ENUM_USING_ALIAS_STRING) +MAGIC_ENUM_USING_ALIAS_STRING +#else +using std::string; +#endif + +using char_type = string_view::value_type; +static_assert(std::is_same_v, "magic_enum::customize requires same string_view::value_type and string::value_type"); +static_assert([] { + if constexpr (std::is_same_v) { + constexpr const char c[] = "abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789|"; + constexpr const wchar_t wc[] = L"abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789|"; + static_assert(std::size(c) == std::size(wc), "magic_enum::customize identifier characters are multichars in wchar_t."); + + for (std::size_t i = 0; i < std::size(c); ++i) { + if (c[i] != wc[i]) { + return false; + } + } + } + return true; +} (), "magic_enum::customize wchar_t is not compatible with ASCII."); + +namespace customize { + +// Enum value must be in range [MAGIC_ENUM_RANGE_MIN, MAGIC_ENUM_RANGE_MAX]. By default MAGIC_ENUM_RANGE_MIN = -128, MAGIC_ENUM_RANGE_MAX = 128. +// If need another range for all enum types by default, redefine the macro MAGIC_ENUM_RANGE_MIN and MAGIC_ENUM_RANGE_MAX. +// If need another range for specific enum type, add specialization enum_range for necessary enum type. +template +struct enum_range { + static_assert(std::is_enum_v, "magic_enum::customize::enum_range requires enum type."); + static constexpr int min = MAGIC_ENUM_RANGE_MIN; + static constexpr int max = MAGIC_ENUM_RANGE_MAX; + static_assert(max > min, "magic_enum::customize::enum_range requires max > min."); +}; + +static_assert(MAGIC_ENUM_RANGE_MAX > MAGIC_ENUM_RANGE_MIN, "MAGIC_ENUM_RANGE_MAX must be greater than MAGIC_ENUM_RANGE_MIN."); +static_assert((MAGIC_ENUM_RANGE_MAX - MAGIC_ENUM_RANGE_MIN) < (std::numeric_limits::max)(), "MAGIC_ENUM_RANGE must be less than UINT16_MAX."); + +namespace detail { + +enum class customize_tag { + default_tag, + invalid_tag, + custom_tag +}; + +} // namespace magic_enum::customize::detail + +class customize_t : public std::pair { + public: + constexpr customize_t(string_view srt) : std::pair{detail::customize_tag::custom_tag, srt} {} + constexpr customize_t(const char_type* srt) : customize_t{string_view{srt}} {} + constexpr customize_t(detail::customize_tag tag) : std::pair{tag, string_view{}} { + MAGIC_ENUM_ASSERT(tag != detail::customize_tag::custom_tag); + } +}; + +// Default customize. +inline constexpr auto default_tag = customize_t{detail::customize_tag::default_tag}; +// Invalid customize. +inline constexpr auto invalid_tag = customize_t{detail::customize_tag::invalid_tag}; + +// If need custom names for enum, add specialization enum_name for necessary enum type. +template +constexpr customize_t enum_name(E) noexcept { + return default_tag; +} + +// If need custom type name for enum, add specialization enum_type_name for necessary enum type. +template +constexpr customize_t enum_type_name() noexcept { + return default_tag; +} + +} // namespace magic_enum::customize + +namespace detail { + +template +struct supported +#if defined(MAGIC_ENUM_SUPPORTED) && MAGIC_ENUM_SUPPORTED || defined(MAGIC_ENUM_NO_CHECK_SUPPORT) + : std::true_type {}; +#else + : std::false_type {}; +#endif + +template , std::enable_if_t, int> = 0> +using enum_constant = std::integral_constant; + +template +inline constexpr bool always_false_v = false; + +template +struct has_is_flags : std::false_type {}; + +template +struct has_is_flags::is_flags)>> : std::bool_constant::is_flags)>>> {}; + +template +struct range_min : std::integral_constant {}; + +template +struct range_min::min)>> : std::integral_constant::min), customize::enum_range::min> {}; + +template +struct range_max : std::integral_constant {}; + +template +struct range_max::max)>> : std::integral_constant::max), customize::enum_range::max> {}; + +struct str_view { + const char* str_ = nullptr; + std::size_t size_ = 0; +}; + +template +class static_str { + public: + constexpr explicit static_str(str_view str) noexcept : static_str{str.str_, std::make_integer_sequence{}} { + MAGIC_ENUM_ASSERT(str.size_ == N); + } + + constexpr explicit static_str(string_view str) noexcept : static_str{str.data(), std::make_integer_sequence{}} { + MAGIC_ENUM_ASSERT(str.size() == N); + } + + constexpr const char_type* data() const noexcept { return chars_; } + + constexpr std::uint16_t size() const noexcept { return N; } + + constexpr operator string_view() const noexcept { return {data(), size()}; } + + private: + template + constexpr static_str(const char* str, std::integer_sequence) noexcept : chars_{static_cast(str[I])..., static_cast('\0')} {} + + template + constexpr static_str(string_view str, std::integer_sequence) noexcept : chars_{str[I]..., static_cast('\0')} {} + + char_type chars_[static_cast(N) + 1]; +}; + +template <> +class static_str<0> { + public: + constexpr explicit static_str() = default; + + constexpr explicit static_str(str_view) noexcept {} + + constexpr explicit static_str(string_view) noexcept {} + + constexpr const char_type* data() const noexcept { return nullptr; } + + constexpr std::uint16_t size() const noexcept { return 0; } + + constexpr operator string_view() const noexcept { return {}; } +}; + +template > +class case_insensitive { + static constexpr char_type to_lower(char_type c) noexcept { + return (c >= static_cast('A') && c <= static_cast('Z')) ? static_cast(c + (static_cast('a') - static_cast('A'))) : c; + } + + public: + template + constexpr auto operator()(L lhs,R rhs) const noexcept -> std::enable_if_t, char_type> && std::is_same_v, char_type>, bool> { + return Op{}(to_lower(lhs), to_lower(rhs)); + } +}; + +constexpr std::size_t find(string_view str, char_type c) noexcept { +#if defined(__clang__) && __clang_major__ < 9 && defined(__GLIBCXX__) || defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__) +// https://stackoverflow.com/questions/56484834/constexpr-stdstring-viewfind-last-of-doesnt-work-on-clang-8-with-libstdc +// https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html + constexpr bool workaround = true; +#else + constexpr bool workaround = false; +#endif + + if constexpr (workaround) { + for (std::size_t i = 0; i < str.size(); ++i) { + if (str[i] == c) { + return i; + } + } + + return string_view::npos; + } else { + return str.find(c); + } +} + +template +constexpr bool is_default_predicate() noexcept { + return std::is_same_v, std::equal_to> || + std::is_same_v, std::equal_to<>>; +} + +template +constexpr bool is_nothrow_invocable() { + return is_default_predicate() || + std::is_nothrow_invocable_r_v; +} + +template +constexpr bool cmp_equal(string_view lhs, string_view rhs, [[maybe_unused]] BinaryPredicate&& p) noexcept(is_nothrow_invocable()) { +#if defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__) + // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html + // https://developercommunity.visualstudio.com/content/problem/232218/c-constexpr-string-view.html + constexpr bool workaround = true; +#else + constexpr bool workaround = false; +#endif + + if constexpr (!is_default_predicate() || workaround) { + if (lhs.size() != rhs.size()) { + return false; + } + + const auto size = lhs.size(); + for (std::size_t i = 0; i < size; ++i) { + if (!p(lhs[i], rhs[i])) { + return false; + } + } + + return true; + } else { + return lhs == rhs; + } +} + +template +constexpr bool cmp_less(L lhs, R rhs) noexcept { + static_assert(std::is_integral_v && std::is_integral_v, "magic_enum::detail::cmp_less requires integral type."); + + if constexpr (std::is_signed_v == std::is_signed_v) { + // If same signedness (both signed or both unsigned). + return lhs < rhs; + } else if constexpr (std::is_same_v) { // bool special case + return static_cast(lhs) < rhs; + } else if constexpr (std::is_same_v) { // bool special case + return lhs < static_cast(rhs); + } else if constexpr (std::is_signed_v) { + // If 'right' is negative, then result is 'false', otherwise cast & compare. + return rhs > 0 && lhs < static_cast>(rhs); + } else { + // If 'left' is negative, then result is 'true', otherwise cast & compare. + return lhs < 0 || static_cast>(lhs) < rhs; + } +} + +template +constexpr I log2(I value) noexcept { + static_assert(std::is_integral_v, "magic_enum::detail::log2 requires integral type."); + + if constexpr (std::is_same_v) { // bool special case + return MAGIC_ENUM_ASSERT(false), value; + } else { + auto ret = I{0}; + for (; value > I{1}; value >>= I{1}, ++ret) {} + + return ret; + } +} + +#if defined(__cpp_lib_array_constexpr) && __cpp_lib_array_constexpr >= 201603L +# define MAGIC_ENUM_ARRAY_CONSTEXPR 1 +#else +template +constexpr std::array, N> to_array(T (&a)[N], std::index_sequence) noexcept { + return {{a[I]...}}; +} +#endif + +template +inline constexpr bool is_enum_v = std::is_enum_v && std::is_same_v>; + +template +constexpr auto n() noexcept { + static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); + + if constexpr (supported::value) { +#if defined(MAGIC_ENUM_GET_TYPE_NAME_BUILTIN) + constexpr auto name_ptr = MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(E); + constexpr auto name = name_ptr ? str_view{name_ptr, std::char_traits::length(name_ptr)} : str_view{}; +#elif defined(__clang__) + auto name = str_view{__PRETTY_FUNCTION__ + 34, sizeof(__PRETTY_FUNCTION__) - 36}; +#elif defined(__GNUC__) + auto name = str_view{__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1}; + if (name.str_[name.size_ - 1] == ']') { + name.size_ -= 50; + name.str_ += 49; + } else { + name.size_ -= 40; + name.str_ += 37; + } +#elif defined(_MSC_VER) + auto name = str_view{__FUNCSIG__ + 40, sizeof(__FUNCSIG__) - 57}; +#else + auto name = str_view{}; +#endif + std::size_t p = 0; + for (std::size_t i = name.size_; i > 0; --i) { + if (name.str_[i] == ':') { + p = i + 1; + break; + } + } + if (p > 0) { + name.size_ -= p; + name.str_ += p; + } + return name; + } else { + return str_view{}; // Unsupported compiler or Invalid customize. + } +} + +template +constexpr auto type_name() noexcept { + [[maybe_unused]] constexpr auto custom = customize::enum_type_name(); + static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); + if constexpr (custom.first == customize::detail::customize_tag::custom_tag) { + constexpr auto name = custom.second; + static_assert(!name.empty(), "magic_enum::customize requires not empty string."); + return static_str{name}; + } else if constexpr (custom.first == customize::detail::customize_tag::invalid_tag) { + return static_str<0>{}; + } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) { + constexpr auto name = n(); + return static_str{name}; + } else { + static_assert(always_false_v, "magic_enum::customize invalid."); + } +} + +template +inline constexpr auto type_name_v = type_name(); + +template +constexpr auto n() noexcept { + static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); + + if constexpr (supported::value) { +#if defined(MAGIC_ENUM_GET_ENUM_NAME_BUILTIN) + constexpr auto name_ptr = MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V); + auto name = name_ptr ? str_view{name_ptr, std::char_traits::length(name_ptr)} : str_view{}; +#elif defined(__clang__) + auto name = str_view{__PRETTY_FUNCTION__ + 34, sizeof(__PRETTY_FUNCTION__) - 36}; + if (name.size_ > 22 && name.str_[0] == '(' && name.str_[1] == 'a' && name.str_[10] == ' ' && name.str_[22] == ':') { + name.size_ -= 23; + name.str_ += 23; + } + if (name.str_[0] == '(' || name.str_[0] == '-' || (name.str_[0] >= '0' && name.str_[0] <= '9')) { + name = str_view{}; + } +#elif defined(__GNUC__) + auto name = str_view{__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1}; + if (name.str_[name.size_ - 1] == ']') { + name.size_ -= 55; + name.str_ += 54; + } else { + name.size_ -= 40; + name.str_ += 37; + } + if (name.str_[0] == '(') { + name = str_view{}; + } +#elif defined(_MSC_VER) + str_view name; + if ((__FUNCSIG__[5] == '_' && __FUNCSIG__[35] != '(') || (__FUNCSIG__[5] == 'c' && __FUNCSIG__[41] != '(')) { + name = str_view{__FUNCSIG__ + 35, sizeof(__FUNCSIG__) - 52}; + } +#else + auto name = str_view{}; +#endif + std::size_t p = 0; + for (std::size_t i = name.size_; i > 0; --i) { + if (name.str_[i] == ':') { + p = i + 1; + break; + } + } + if (p > 0) { + name.size_ -= p; + name.str_ += p; + } + return name; + } else { + return str_view{}; // Unsupported compiler or Invalid customize. + } +} + +#if defined(_MSC_VER) && !defined(__clang__) && _MSC_VER < 1920 +# define MAGIC_ENUM_VS_2017_WORKAROUND 1 +#endif + +#if defined(MAGIC_ENUM_VS_2017_WORKAROUND) +template +constexpr auto n() noexcept { + static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); + +# if defined(MAGIC_ENUM_GET_ENUM_NAME_BUILTIN) + constexpr auto name_ptr = MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V); + auto name = name_ptr ? str_view{name_ptr, std::char_traits::length(name_ptr)} : str_view{}; +# else + str_view name = str_view{__FUNCSIG__, sizeof(__FUNCSIG__) - 17}; + std::size_t p = 0; + for (std::size_t i = name.size_; i > 0; --i) { + if (name.str_[i] == ',' || name.str_[i] == ':') { + p = i + 1; + break; + } + } + if (p > 0) { + name.size_ -= p; + name.str_ += p; + } + if (name.str_[0] == '(' || name.str_[0] == '-' || (name.str_[0] >= '0' && name.str_[0] <= '9')) { + name = str_view{}; + } + return name; +# endif +} +#endif + +template +constexpr auto enum_name() noexcept { + [[maybe_unused]] constexpr auto custom = customize::enum_name(V); + static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); + if constexpr (custom.first == customize::detail::customize_tag::custom_tag) { + constexpr auto name = custom.second; + static_assert(!name.empty(), "magic_enum::customize requires not empty string."); + return static_str{name}; + } else if constexpr (custom.first == customize::detail::customize_tag::invalid_tag) { + return static_str<0>{}; + } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) { +#if defined(MAGIC_ENUM_VS_2017_WORKAROUND) + constexpr auto name = n(); +#else + constexpr auto name = n(); +#endif + return static_str{name}; + } else { + static_assert(always_false_v, "magic_enum::customize invalid."); + } +} + +template +inline constexpr auto enum_name_v = enum_name(); + +template +constexpr bool is_valid() noexcept { +#if defined(__clang__) && __clang_major__ >= 16 + // https://reviews.llvm.org/D130058, https://reviews.llvm.org/D131307 + constexpr E v = __builtin_bit_cast(E, V); +#else + constexpr E v = static_cast(V); +#endif + [[maybe_unused]] constexpr auto custom = customize::enum_name(v); + static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); + if constexpr (custom.first == customize::detail::customize_tag::custom_tag) { + constexpr auto name = custom.second; + static_assert(!name.empty(), "magic_enum::customize requires not empty string."); + return name.size() != 0; + } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) { +#if defined(MAGIC_ENUM_VS_2017_WORKAROUND) + return n().size_ != 0; +#else + return n().size_ != 0; +#endif + } else { + return false; + } +} + +enum class enum_subtype { + common, + flags +}; + +template > +constexpr U ualue(std::size_t i) noexcept { + if constexpr (std::is_same_v) { // bool special case + static_assert(O == 0, "magic_enum::detail::ualue requires valid offset."); + + return static_cast(i); + } else if constexpr (S == enum_subtype::flags) { + return static_cast(U{1} << static_cast(static_cast(i) + O)); + } else { + return static_cast(static_cast(i) + O); + } +} + +template > +constexpr E value(std::size_t i) noexcept { + return static_cast(ualue(i)); +} + +template > +constexpr int reflected_min() noexcept { + if constexpr (S == enum_subtype::flags) { + return 0; + } else { + constexpr auto lhs = range_min::value; + constexpr auto rhs = (std::numeric_limits::min)(); + + if constexpr (cmp_less(rhs, lhs)) { + return lhs; + } else { + return rhs; + } + } +} + +template > +constexpr int reflected_max() noexcept { + if constexpr (S == enum_subtype::flags) { + return std::numeric_limits::digits - 1; + } else { + constexpr auto lhs = range_max::value; + constexpr auto rhs = (std::numeric_limits::max)(); + + if constexpr (cmp_less(lhs, rhs)) { + return lhs; + } else { + return rhs; + } + } +} + +#define MAGIC_ENUM_FOR_EACH_256(T) \ + T( 0)T( 1)T( 2)T( 3)T( 4)T( 5)T( 6)T( 7)T( 8)T( 9)T( 10)T( 11)T( 12)T( 13)T( 14)T( 15)T( 16)T( 17)T( 18)T( 19)T( 20)T( 21)T( 22)T( 23)T( 24)T( 25)T( 26)T( 27)T( 28)T( 29)T( 30)T( 31) \ + T( 32)T( 33)T( 34)T( 35)T( 36)T( 37)T( 38)T( 39)T( 40)T( 41)T( 42)T( 43)T( 44)T( 45)T( 46)T( 47)T( 48)T( 49)T( 50)T( 51)T( 52)T( 53)T( 54)T( 55)T( 56)T( 57)T( 58)T( 59)T( 60)T( 61)T( 62)T( 63) \ + T( 64)T( 65)T( 66)T( 67)T( 68)T( 69)T( 70)T( 71)T( 72)T( 73)T( 74)T( 75)T( 76)T( 77)T( 78)T( 79)T( 80)T( 81)T( 82)T( 83)T( 84)T( 85)T( 86)T( 87)T( 88)T( 89)T( 90)T( 91)T( 92)T( 93)T( 94)T( 95) \ + T( 96)T( 97)T( 98)T( 99)T(100)T(101)T(102)T(103)T(104)T(105)T(106)T(107)T(108)T(109)T(110)T(111)T(112)T(113)T(114)T(115)T(116)T(117)T(118)T(119)T(120)T(121)T(122)T(123)T(124)T(125)T(126)T(127) \ + T(128)T(129)T(130)T(131)T(132)T(133)T(134)T(135)T(136)T(137)T(138)T(139)T(140)T(141)T(142)T(143)T(144)T(145)T(146)T(147)T(148)T(149)T(150)T(151)T(152)T(153)T(154)T(155)T(156)T(157)T(158)T(159) \ + T(160)T(161)T(162)T(163)T(164)T(165)T(166)T(167)T(168)T(169)T(170)T(171)T(172)T(173)T(174)T(175)T(176)T(177)T(178)T(179)T(180)T(181)T(182)T(183)T(184)T(185)T(186)T(187)T(188)T(189)T(190)T(191) \ + T(192)T(193)T(194)T(195)T(196)T(197)T(198)T(199)T(200)T(201)T(202)T(203)T(204)T(205)T(206)T(207)T(208)T(209)T(210)T(211)T(212)T(213)T(214)T(215)T(216)T(217)T(218)T(219)T(220)T(221)T(222)T(223) \ + T(224)T(225)T(226)T(227)T(228)T(229)T(230)T(231)T(232)T(233)T(234)T(235)T(236)T(237)T(238)T(239)T(240)T(241)T(242)T(243)T(244)T(245)T(246)T(247)T(248)T(249)T(250)T(251)T(252)T(253)T(254)T(255) + +template +constexpr void valid_count(bool* valid, std::size_t& count) noexcept { +#define MAGIC_ENUM_V(O) \ + if constexpr ((I + O) < Size) { \ + if constexpr (is_valid(I + O)>()) { \ + valid[I + O] = true; \ + ++count; \ + } \ + } + + MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_V); + + if constexpr ((I + 256) < Size) { + valid_count(valid, count); + } +#undef MAGIC_ENUM_V +} + +template +struct valid_count_t { + std::size_t count = 0; + bool valid[N] = {}; +}; + +template +constexpr auto valid_count() noexcept { + valid_count_t vc; + valid_count(vc.valid, vc.count); + return vc; +} + +template +constexpr auto values() noexcept { + constexpr auto vc = valid_count(); + + if constexpr (vc.count > 0) { +#if defined(MAGIC_ENUM_ARRAY_CONSTEXPR) + std::array values = {}; +#else + E values[vc.count] = {}; +#endif + for (std::size_t i = 0, v = 0; v < vc.count; ++i) { + if (vc.valid[i]) { + values[v++] = value(i); + } + } +#if defined(MAGIC_ENUM_ARRAY_CONSTEXPR) + return values; +#else + return to_array(values, std::make_index_sequence{}); +#endif + } else { + return std::array{}; + } +} + +template > +constexpr auto values() noexcept { + constexpr auto min = reflected_min(); + constexpr auto max = reflected_max(); + constexpr auto range_size = max - min + 1; + static_assert(range_size > 0, "magic_enum::enum_range requires valid size."); + static_assert(range_size < (std::numeric_limits::max)(), "magic_enum::enum_range requires valid size."); + + return values(); +} + +template > +constexpr enum_subtype subtype(std::true_type) noexcept { + if constexpr (std::is_same_v) { // bool special case + return enum_subtype::common; + } else if constexpr (has_is_flags::value) { + return customize::enum_range::is_flags ? enum_subtype::flags : enum_subtype::common; + } else { +#if defined(MAGIC_ENUM_AUTO_IS_FLAGS) + constexpr auto flags_values = values(); + constexpr auto default_values = values(); + if (flags_values.size() == 0 || default_values.size() > flags_values.size()) { + return enum_subtype::common; + } + for (std::size_t i = 0; i < default_values.size(); ++i) { + const auto v = static_cast(default_values[i]); + if (v != 0 && (v & (v - 1)) != 0) { + return enum_subtype::common; + } + } + return enum_subtype::flags; +#else + return enum_subtype::common; +#endif + } +} + +template +constexpr enum_subtype subtype(std::false_type) noexcept { + // For non-enum type return default common subtype. + return enum_subtype::common; +} + +template > +inline constexpr auto subtype_v = subtype(std::is_enum{}); + +template +inline constexpr auto values_v = values(); + +template > +using values_t = decltype((values_v)); + +template +inline constexpr auto count_v = values_v.size(); + +template > +inline constexpr auto min_v = (count_v > 0) ? static_cast(values_v.front()) : U{0}; + +template > +inline constexpr auto max_v = (count_v > 0) ? static_cast(values_v.back()) : U{0}; + +template +constexpr auto names(std::index_sequence) noexcept { + return std::array{{enum_name_v[I]>...}}; +} + +template +inline constexpr auto names_v = names(std::make_index_sequence>{}); + +template > +using names_t = decltype((names_v)); + +template +constexpr auto entries(std::index_sequence) noexcept { + return std::array, sizeof...(I)>{{{values_v[I], enum_name_v[I]>}...}}; +} + +template +inline constexpr auto entries_v = entries(std::make_index_sequence>{}); + +template > +using entries_t = decltype((entries_v)); + +template > +constexpr bool is_sparse() noexcept { + if constexpr (count_v == 0) { + return false; + } else if constexpr (std::is_same_v) { // bool special case + return false; + } else { + constexpr auto max = (S == enum_subtype::flags) ? log2(max_v) : max_v; + constexpr auto min = (S == enum_subtype::flags) ? log2(min_v) : min_v; + constexpr auto range_size = max - min + 1; + + return range_size != count_v; + } +} + +template > +inline constexpr bool is_sparse_v = is_sparse(); + +template > +constexpr U values_ors() noexcept { + static_assert(S == enum_subtype::flags, "magic_enum::detail::values_ors requires valid subtype."); + + auto ors = U{0}; + for (std::size_t i = 0; i < count_v; ++i) { + ors |= static_cast(values_v[i]); + } + + return ors; +} + +template +struct enable_if_enum {}; + +template +struct enable_if_enum { + using type = R; + static_assert(supported::value, "magic_enum unsupported compiler (https://github.com/Neargye/magic_enum#compiler-compatibility)."); +}; + +template , typename D = std::decay_t> +using enable_if_t = typename enable_if_enum && std::is_invocable_r_v, R>::type; + +template >, int> = 0> +using enum_concept = T; + +template > +struct is_scoped_enum : std::false_type {}; + +template +struct is_scoped_enum : std::bool_constant>> {}; + +template > +struct is_unscoped_enum : std::false_type {}; + +template +struct is_unscoped_enum : std::bool_constant>> {}; + +template >> +struct underlying_type {}; + +template +struct underlying_type : std::underlying_type> {}; + +#if defined(MAGIC_ENUM_ENABLE_HASH) || defined(MAGIC_ENUM_ENABLE_HASH_SWITCH) + +template +struct constexpr_hash_t; + +template +struct constexpr_hash_t>> { + constexpr auto operator()(Value value) const noexcept { + using U = typename underlying_type::type; + if constexpr (std::is_same_v) { // bool special case + return static_cast(value); + } else { + return static_cast(value); + } + } + using secondary_hash = constexpr_hash_t; +}; + +template +struct constexpr_hash_t>> { + static constexpr std::uint32_t crc_table[256] { + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L, + 0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L, + 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, + 0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L, + 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, + 0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL, + 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, + 0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L, + 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, + 0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L, + 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, + 0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L, + 0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, + 0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L, + 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, + 0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L, + 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, + 0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L, + 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, + 0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL, + 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, + 0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L, + 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, + 0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL, + 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL, + 0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL + }; + constexpr std::uint32_t operator()(string_view value) const noexcept { + auto crc = static_cast(0xffffffffL); + for (const auto c : value) { + crc = (crc >> 8) ^ crc_table[(crc ^ static_cast(c)) & 0xff]; + } + return crc ^ 0xffffffffL; + } + + struct secondary_hash { + constexpr std::uint32_t operator()(string_view value) const noexcept { + auto acc = static_cast(2166136261ULL); + for (const auto c : value) { + acc = ((acc ^ static_cast(c)) * static_cast(16777619ULL)) & (std::numeric_limits::max)(); + } + return static_cast(acc); + } + }; +}; + +template +inline constexpr Hash hash_v{}; + +template +constexpr auto calculate_cases(std::size_t Page) noexcept { + constexpr std::array values = *GlobValues; + constexpr std::size_t size = values.size(); + + using switch_t = std::invoke_result_t; + static_assert(std::is_integral_v && !std::is_same_v); + const std::size_t values_to = (std::min)(static_cast(256), size - Page); + + std::array result{}; + auto fill = result.begin(); + { + auto first = values.begin() + static_cast(Page); + auto last = values.begin() + static_cast(Page + values_to); + while (first != last) { + *fill++ = hash_v(*first++); + } + } + + // dead cases, try to avoid case collisions + for (switch_t last_value = result[values_to - 1]; fill != result.end() && last_value != (std::numeric_limits::max)(); *fill++ = ++last_value) { + } + + { + auto it = result.begin(); + auto last_value = (std::numeric_limits::min)(); + for (; fill != result.end(); *fill++ = last_value++) { + while (last_value == *it) { + ++last_value, ++it; + } + } + } + + return result; +} + +template +constexpr R invoke_r(F&& f, Args&&... args) noexcept(std::is_nothrow_invocable_r_v) { + if constexpr (std::is_void_v) { + std::forward(f)(std::forward(args)...); + } else { + return static_cast(std::forward(f)(std::forward(args)...)); + } +} + +enum class case_call_t { + index, + value +}; + +template +inline constexpr auto default_result_type_lambda = []() noexcept(std::is_nothrow_default_constructible_v) { return T{}; }; + +template <> +inline constexpr auto default_result_type_lambda = []() noexcept {}; + +template +constexpr bool has_duplicate() noexcept { + using value_t = std::decay_t; + using hash_value_t = std::invoke_result_t; + std::arraysize()> hashes{}; + std::size_t size = 0; + for (auto elem : *Arr) { + hashes[size] = hash_v(elem); + for (auto i = size++; i > 0; --i) { + if (hashes[i] < hashes[i - 1]) { + auto tmp = hashes[i]; + hashes[i] = hashes[i - 1]; + hashes[i - 1] = tmp; + } else if (hashes[i] == hashes[i - 1]) { + return false; + } else { + break; + } + } + } + return true; +} + +#define MAGIC_ENUM_CASE(val) \ + case cases[val]: \ + if constexpr ((val) + Page < size) { \ + if (!pred(values[val + Page], searched)) { \ + break; \ + } \ + if constexpr (CallValue == case_call_t::index) { \ + if constexpr (std::is_invocable_r_v>) { \ + return detail::invoke_r(std::forward(lambda), std::integral_constant{}); \ + } else if constexpr (std::is_invocable_v>) { \ + MAGIC_ENUM_ASSERT(false && "magic_enum::detail::constexpr_switch wrong result type."); \ + } \ + } else if constexpr (CallValue == case_call_t::value) { \ + if constexpr (std::is_invocable_r_v>) { \ + return detail::invoke_r(std::forward(lambda), enum_constant{}); \ + } else if constexpr (std::is_invocable_r_v>) { \ + MAGIC_ENUM_ASSERT(false && "magic_enum::detail::constexpr_switch wrong result type."); \ + } \ + } \ + break; \ + } else [[fallthrough]]; + +template ::value_type>, + typename BinaryPredicate = std::equal_to<>, + typename Lambda, + typename ResultGetterType> +constexpr decltype(auto) constexpr_switch( + Lambda&& lambda, + typename std::decay_t::value_type searched, + ResultGetterType&& def, + BinaryPredicate&& pred = {}) { + using result_t = std::invoke_result_t; + using hash_t = std::conditional_t(), Hash, typename Hash::secondary_hash>; + static_assert(has_duplicate(), "magic_enum::detail::constexpr_switch duplicated hash found, please report it: https://github.com/Neargye/magic_enum/issues."); + constexpr std::array values = *GlobValues; + constexpr std::size_t size = values.size(); + constexpr std::array cases = calculate_cases(Page); + + switch (hash_v(searched)) { + MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_CASE) + default: + if constexpr (size > 256 + Page) { + return constexpr_switch(std::forward(lambda), searched, std::forward(def)); + } + break; + } + return def(); +} + +#undef MAGIC_ENUM_CASE + +#endif + +} // namespace magic_enum::detail + +// Checks is magic_enum supported compiler. +inline constexpr bool is_magic_enum_supported = detail::supported::value; + +template +using Enum = detail::enum_concept; + +// Checks whether T is an Unscoped enumeration type. +// Provides the member constant value which is equal to true, if T is an [Unscoped enumeration](https://en.cppreference.com/w/cpp/language/enum#Unscoped_enumeration) type. Otherwise, value is equal to false. +template +struct is_unscoped_enum : detail::is_unscoped_enum {}; + +template +inline constexpr bool is_unscoped_enum_v = is_unscoped_enum::value; + +// Checks whether T is an Scoped enumeration type. +// Provides the member constant value which is equal to true, if T is an [Scoped enumeration](https://en.cppreference.com/w/cpp/language/enum#Scoped_enumerations) type. Otherwise, value is equal to false. +template +struct is_scoped_enum : detail::is_scoped_enum {}; + +template +inline constexpr bool is_scoped_enum_v = is_scoped_enum::value; + +// If T is a complete enumeration type, provides a member typedef type that names the underlying type of T. +// Otherwise, if T is not an enumeration type, there is no member type. Otherwise (T is an incomplete enumeration type), the program is ill-formed. +template +struct underlying_type : detail::underlying_type {}; + +template +using underlying_type_t = typename underlying_type::type; + +template +using enum_constant = detail::enum_constant; + +// Returns type name of enum. +template +[[nodiscard]] constexpr auto enum_type_name() noexcept -> detail::enable_if_t { + constexpr string_view name = detail::type_name_v>; + static_assert(!name.empty(), "magic_enum::enum_type_name enum type does not have a name."); + + return name; +} + +// Returns number of enum values. +template > +[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_t { + return detail::count_v, S>; +} + +// Returns enum value at specified index. +// No bounds checking is performed: the behavior is undefined if index >= number of enum values. +template > +[[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_t> { + using D = std::decay_t; + + if constexpr (detail::is_sparse_v) { + return MAGIC_ENUM_ASSERT(index < detail::count_v), detail::values_v[index]; + } else { + constexpr auto min = (S == detail::enum_subtype::flags) ? detail::log2(detail::min_v) : detail::min_v; + + return MAGIC_ENUM_ASSERT(index < detail::count_v), detail::value(index); + } +} + +// Returns enum value at specified index. +template > +[[nodiscard]] constexpr auto enum_value() noexcept -> detail::enable_if_t> { + using D = std::decay_t; + static_assert(I < detail::count_v, "magic_enum::enum_value out of range."); + + return enum_value(I); +} + +// Returns std::array with enum values, sorted by enum value. +template > +[[nodiscard]] constexpr auto enum_values() noexcept -> detail::enable_if_t> { + return detail::values_v, S>; +} + +// Returns integer value from enum value. +template +[[nodiscard]] constexpr auto enum_integer(E value) noexcept -> detail::enable_if_t> { + return static_cast>(value); +} + +// Returns underlying value from enum value. +template +[[nodiscard]] constexpr auto enum_underlying(E value) noexcept -> detail::enable_if_t> { + return static_cast>(value); +} + +// Obtains index in enum values from enum value. +// Returns optional with index. +template > +[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t> { + using D = std::decay_t; + using U = underlying_type_t; + + if constexpr (detail::count_v == 0) { + static_cast(value); + return {}; // Empty enum. + } else if constexpr (detail::is_sparse_v || (S == detail::enum_subtype::flags)) { +#if defined(MAGIC_ENUM_ENABLE_HASH) + return detail::constexpr_switch<&detail::values_v, detail::case_call_t::index>( + [](std::size_t i) { return optional{i}; }, + value, + detail::default_result_type_lambda>); +#else + for (std::size_t i = 0; i < detail::count_v; ++i) { + if (enum_value(i) == value) { + return i; + } + } + return {}; // Invalid value or out of range. +#endif + } else { + const auto v = static_cast(value); + if (v >= detail::min_v && v <= detail::max_v) { + return static_cast(v - detail::min_v); + } + return {}; // Invalid value or out of range. + } +} + +// Obtains index in enum values from enum value. +// Returns optional with index. +template +[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t> { + using D = std::decay_t; + + return enum_index(value); +} + +// Obtains index in enum values from static storage enum variable. +template >> +[[nodiscard]] constexpr auto enum_index() noexcept -> detail::enable_if_t { + constexpr auto index = enum_index, S>(V); + static_assert(index, "magic_enum::enum_index enum value does not have a index."); + + return *index; +} + +// Returns name from static storage enum variable. +// This version is much lighter on the compile times and is not restricted to the enum_range limitation. +template +[[nodiscard]] constexpr auto enum_name() noexcept -> detail::enable_if_t { + constexpr string_view name = detail::enum_name_v, V>; + static_assert(!name.empty(), "magic_enum::enum_name enum value does not have a name."); + + return name; +} + +// Returns name from enum value. +// If enum value does not have name or value out of range, returns empty string. +template > +[[nodiscard]] constexpr auto enum_name(E value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + + if (const auto i = enum_index(value)) { + return detail::names_v[*i]; + } + return {}; +} + +// Returns name from enum value. +// If enum value does not have name or value out of range, returns empty string. +template +[[nodiscard]] constexpr auto enum_name(E value) -> detail::enable_if_t { + using D = std::decay_t; + + return enum_name(value); +} + +// Returns std::array with names, sorted by enum value. +template > +[[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_t> { + return detail::names_v, S>; +} + +// Returns std::array with pairs (value, name), sorted by enum value. +template > +[[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_t> { + return detail::entries_v, S>; +} + +// Allows you to write magic_enum::enum_cast("bar", magic_enum::case_insensitive); +inline constexpr auto case_insensitive = detail::case_insensitive<>{}; + +// Obtains enum value from integer value. +// Returns optional with enum value. +template > +[[nodiscard]] constexpr auto enum_cast(underlying_type_t value) noexcept -> detail::enable_if_t>> { + using D = std::decay_t; + + if constexpr (detail::count_v == 0) { + static_cast(value); + return {}; // Empty enum. + } else { + if constexpr (detail::is_sparse_v || (S == detail::enum_subtype::flags)) { +#if defined(MAGIC_ENUM_ENABLE_HASH) + return detail::constexpr_switch<&detail::values_v, detail::case_call_t::value>( + [](D v) { return optional{v}; }, + static_cast(value), + detail::default_result_type_lambda>); +#else + for (std::size_t i = 0; i < detail::count_v; ++i) { + if (value == static_cast>(enum_value(i))) { + return static_cast(value); + } + } + return {}; // Invalid value or out of range. +#endif + } else { + if (value >= detail::min_v && value <= detail::max_v) { + return static_cast(value); + } + return {}; // Invalid value or out of range. + } + } +} + +// Obtains enum value from name. +// Returns optional with enum value. +template , typename BinaryPredicate = std::equal_to<>> +[[nodiscard]] constexpr auto enum_cast(string_view value, [[maybe_unused]] BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable()) -> detail::enable_if_t>, BinaryPredicate> { + using D = std::decay_t; + + if constexpr (detail::count_v == 0) { + static_cast(value); + return {}; // Empty enum. +#if defined(MAGIC_ENUM_ENABLE_HASH) + } else if constexpr (detail::is_default_predicate()) { + return detail::constexpr_switch<&detail::names_v, detail::case_call_t::index>( + [](std::size_t i) { return optional{detail::values_v[i]}; }, + value, + detail::default_result_type_lambda>, + [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); }); +#endif + } else { + for (std::size_t i = 0; i < detail::count_v; ++i) { + if (detail::cmp_equal(value, detail::names_v[i], p)) { + return enum_value(i); + } + } + return {}; // Invalid value or out of range. + } +} + +// Checks whether enum contains value with such value. +template > +[[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + using U = underlying_type_t; + + return static_cast(enum_cast(static_cast(value))); +} + +// Checks whether enum contains value with such value. +template +[[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + using U = underlying_type_t; + + return static_cast(enum_cast(static_cast(value))); +} + +// Checks whether enum contains value with such integer value. +template > +[[nodiscard]] constexpr auto enum_contains(underlying_type_t value) noexcept -> detail::enable_if_t { + using D = std::decay_t; + + return static_cast(enum_cast(value)); +} + +// Checks whether enum contains enumerator with such name. +template , typename BinaryPredicate = std::equal_to<>> +[[nodiscard]] constexpr auto enum_contains(string_view value, BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable()) -> detail::enable_if_t { + using D = std::decay_t; + + return static_cast(enum_cast(value, std::move(p))); +} + +template +inline constexpr auto as_flags = AsFlags ? detail::enum_subtype::flags : detail::enum_subtype::common; + +template +inline constexpr auto as_common = AsFlags ? detail::enum_subtype::common : detail::enum_subtype::flags; + +namespace bitwise_operators { + +template = 0> +constexpr E operator~(E rhs) noexcept { + return static_cast(~static_cast>(rhs)); +} + +template = 0> +constexpr E operator|(E lhs, E rhs) noexcept { + return static_cast(static_cast>(lhs) | static_cast>(rhs)); +} + +template = 0> +constexpr E operator&(E lhs, E rhs) noexcept { + return static_cast(static_cast>(lhs) & static_cast>(rhs)); +} + +template = 0> +constexpr E operator^(E lhs, E rhs) noexcept { + return static_cast(static_cast>(lhs) ^ static_cast>(rhs)); +} + +template = 0> +constexpr E& operator|=(E& lhs, E rhs) noexcept { + return lhs = (lhs | rhs); +} + +template = 0> +constexpr E& operator&=(E& lhs, E rhs) noexcept { + return lhs = (lhs & rhs); +} + +template = 0> +constexpr E& operator^=(E& lhs, E rhs) noexcept { + return lhs = (lhs ^ rhs); +} + +} // namespace magic_enum::bitwise_operators + +} // namespace magic_enum + +#if defined(__clang__) +# pragma clang diagnostic pop +#elif defined(__GNUC__) +# pragma GCC diagnostic pop +#elif defined(_MSC_VER) +# pragma warning(pop) +#endif + +#undef MAGIC_ENUM_GET_ENUM_NAME_BUILTIN +#undef MAGIC_ENUM_GET_TYPE_NAME_BUILTIN +#undef MAGIC_ENUM_VS_2017_WORKAROUND +#undef MAGIC_ENUM_ARRAY_CONSTEXPR +#undef MAGIC_ENUM_FOR_EACH_256 + +#endif // NEARGYE_MAGIC_ENUM_HPP diff --git a/lib/libpcsc-cpp/include/pcsc-cpp/comp_winscard.hpp b/lib/libpcsc-cpp/include/pcsc-cpp/comp_winscard.hpp new file mode 100644 index 0000000..bea4809 --- /dev/null +++ b/lib/libpcsc-cpp/include/pcsc-cpp/comp_winscard.hpp @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#pragma once + +#include + +#ifdef __APPLE__ +#include +#include +#else +#include +#undef IGNORE +#endif + +#ifdef __APPLE__ +#pragma pack(1) +#else +#pragma pack(push, 1) +#endif + +#ifndef SCARD_CTL_CODE +#define SCARD_CTL_CODE(code) (0x42000000 + (code)) +#endif + +// http://pcscworkgroup.com/Download/Specifications/pcsc10_v2.02.09.pdf +// http://ludovic.rousseau.free.fr/softwares/pcsc-lite/SecurePIN%20discussion%20v5.pdf +#define CM_IOCTL_GET_FEATURE_REQUEST SCARD_CTL_CODE(3400) + +enum DRIVER_FEATURES : uint8_t { + FEATURE_VERIFY_PIN_START = 0x01, + FEATURE_VERIFY_PIN_FINISH = 0x02, + FEATURE_MODIFY_PIN_START = 0x03, + FEATURE_MODIFY_PIN_FINISH = 0x04, + FEATURE_GET_KEY_PRESSED = 0x05, + FEATURE_VERIFY_PIN_DIRECT = 0x06, + FEATURE_MODIFY_PIN_DIRECT = 0x07, + FEATURE_MCT_READER_DIRECT = 0x08, + FEATURE_MCT_UNIVERSAL = 0x09, + FEATURE_IFD_PIN_PROPERTIES = 0x0A, + FEATURE_ABORT = 0x0B, + FEATURE_SET_SPE_MESSAGE = 0x0C, + FEATURE_VERIFY_PIN_DIRECT_APP_ID = 0x0D, + FEATURE_MODIFY_PIN_DIRECT_APP_ID = 0x0E, + FEATURE_WRITE_DISPLAY = 0x0F, + FEATURE_GET_KEY = 0x10, + FEATURE_IFD_DISPLAY_PROPERTIES = 0x11, + FEATURE_GET_TLV_PROPERTIES = 0x12, + FEATURE_CCID_ESC_COMMAND = 0x13 +}; + +using PCSC_TLV_STRUCTURE = struct +{ + uint8_t tag; + uint8_t length; + uint32_t value; +}; + +enum bmFormatString : uint8_t { + FormatBinary = 0 << 0, // (1234 => 01h 02h 03h 04h) + FormatBCD = 1 << 0, // (1234 => 12h 34h) + FormatASCII = 1 << 1, // (1234 => 31h 32h 33h 34h) + AlignLeft = 0 << 2, + AlignRight = 1 << 2, + PINFrameOffsetUnitBits = 0 << 7, + PINFrameOffsetUnitBytes = 1 << 7, +}; + +enum bmPINBlockString : uint8_t { + PINLengthNone = 0 << 4, + PINFrameSizeAuto = 0, +}; + +enum bmPINLengthFormat : uint8_t { + PINLengthOffsetUnitBits = 0 << 4, + PINLengthOffsetUnitBytes = 1 << 4, +}; + +enum bEntryValidationCondition : uint8_t { + ValidOnMaxSizeReached = 1 << 0, + ValidOnKeyPressed = 1 << 1, + ValidOnTimeout = 1 << 2, +}; + +enum bNumberMessage : uint8_t { + NoInvitationMessage = 0, + OneInvitationMessage = 1, + TwoInvitationMessage = 2, // MODIFY + ThreeInvitationMessage = 3, // MODIFY + CCIDDefaultInvitationMessage = 0xFF, +}; + +enum bConfirmPIN : uint8_t { + ConfirmNewPin = 1 << 0, + RequestCurrentPin = 1 << 1, + AdvancedModify = 1 << 2, +}; + +using PIN_VERIFY_STRUCTURE = struct +{ + uint8_t bTimerOut; // timeout in seconds (00 means use default timeout) + uint8_t bTimerOut2; // timeout in seconds after first key stroke + uint8_t bmFormatString; // formatting options + uint8_t bmPINBlockString; // PIN block definition + uint8_t bmPINLengthFormat; // PIN length definition + uint16_t wPINMaxExtraDigit; // 0xXXYY where XX is minimum PIN size in digits, and YY is maximum + // PIN size in digits + uint8_t + bEntryValidationCondition; // Conditions under which PIN entry should be considered complete + uint8_t bNumberMessage; // Number of messages to display for PIN verification + uint16_t wLangId; // Language for messages (http://www.usb.org/developers/docs/USB_LANGIDs.pdf) + uint8_t bMsgIndex; // Message index (should be 00) + uint8_t bTeoPrologue[3]; // T=1 I-block prologue field to use (fill with 00) + uint32_t ulDataLength; // length of Data to be sent to the ICC +}; + +#ifdef __APPLE__ +#pragma pack() +#else +#pragma pack(pop) +#endif diff --git a/lib/libpcsc-cpp/include/pcsc-cpp/pcsc-cpp-utils.hpp b/lib/libpcsc-cpp/include/pcsc-cpp/pcsc-cpp-utils.hpp new file mode 100644 index 0000000..6c8df80 --- /dev/null +++ b/lib/libpcsc-cpp/include/pcsc-cpp/pcsc-cpp-utils.hpp @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#pragma once + +#include +#include +#include + +namespace pcsc_cpp +{ + +/** Convert the given integer to a hex string. */ +template +inline std::string int2hexstr(const T value) +{ + std::ostringstream hexStringBuilder; + + hexStringBuilder << "0x" << std::setfill('0') << std::setw(sizeof(long) * 2) << std::hex + << value; + + return hexStringBuilder.str(); +} + +/** Remove absolute path prefix until 'src' from the given path, '/path/to/src/main.cpp' becomes + * 'src/main.cpp'. */ +inline std::string removeAbsolutePathPrefix(const std::string& filePath) +{ + const auto lastSrc = filePath.rfind("src"); + return lastSrc == std::string::npos ? filePath : filePath.substr(lastSrc); +} + +} // namespace pcsc_cpp + +#define THROW_WITH_CALLER_INFO(ExceptionType, message, file, line, func) \ + throw ExceptionType(std::string(message) + " in " + pcsc_cpp::removeAbsolutePathPrefix(file) \ + + ':' + std::to_string(line) + ':' + func) + +#define THROW(ExceptionType, message) \ + THROW_WITH_CALLER_INFO(ExceptionType, message, __FILE__, __LINE__, __func__) + +#define REQUIRE_NON_NULL(val) \ + if (!val) { \ + throw std::logic_error("Null " + std::string(#val) + " in " \ + + pcsc_cpp::removeAbsolutePathPrefix(__FILE__) + ':' \ + + std::to_string(__LINE__) + ':' + __func__); \ + } diff --git a/lib/libpcsc-cpp/include/pcsc-cpp/pcsc-cpp.hpp b/lib/libpcsc-cpp/include/pcsc-cpp/pcsc-cpp.hpp new file mode 100644 index 0000000..22fe2be --- /dev/null +++ b/lib/libpcsc-cpp/include/pcsc-cpp/pcsc-cpp.hpp @@ -0,0 +1,381 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#pragma once + +#include "flag-set-cpp/flag_set.hpp" + +#include +#include +#include + +// The rule of five (C++ Core guidelines C.21). +#define PCSC_CPP_DISABLE_COPY_MOVE(Class) \ + Class(const Class&) = delete; \ + Class& operator=(const Class&) = delete; \ + Class(Class&&) = delete; \ + Class& operator=(Class&&) = delete + +namespace pcsc_cpp +{ + +using byte_type = unsigned char; +using byte_vector = std::vector; +#ifdef _WIN32 +using string_t = std::wstring; +#else +using string_t = std::string; +#endif + +/** Opaque class that wraps the PC/SC resource manager context. */ +class Context; +using ContextPtr = std::shared_ptr; + +/** Returns the value of the response status bytes SW1 and SW2 as a single status word SW. */ +inline constexpr uint16_t toSW(byte_type sw1, byte_type sw2) +{ + return uint16_t(sw1 << 8) | sw2; +} + +/** Struct that wraps response APDUs. */ +struct ResponseApdu +{ + enum Status { + OK = 0x90, + MORE_DATA_AVAILABLE = 0x61, + VERIFICATION_FAILED = 0x63, + VERIFICATION_CANCELLED = 0x64, + WRONG_LENGTH = 0x67, + COMMAND_NOT_ALLOWED = 0x69, + WRONG_PARAMETERS = 0x6a, + WRONG_LE_LENGTH = 0x6c + }; + + byte_type sw1 {}; + byte_type sw2 {}; + + byte_vector data; + + static const size_t MAX_DATA_SIZE = 256; + static const size_t MAX_SIZE = MAX_DATA_SIZE + 2; // + sw1 and sw2 + + ResponseApdu(byte_type s1, byte_type s2, byte_vector d = {}) : + sw1(s1), sw2(s2), data(std::move(d)) + { + } + + ResponseApdu() = default; + + static ResponseApdu fromBytes(const byte_vector& data) + { + if (data.size() < 2) { + throw std::invalid_argument("Need at least 2 bytes for creating ResponseApdu"); + } + + // SW1 and SW2 are in the end + return ResponseApdu {data[data.size() - 2], data[data.size() - 1], + byte_vector {data.cbegin(), data.cend() - 2}}; + } + + byte_vector toBytes() const + { + // makes a copy, valid both if data is empty or full + auto bytes = data; + + bytes.push_back(sw1); + bytes.push_back(sw2); + + return bytes; + } + + uint16_t toSW() const { return pcsc_cpp::toSW(sw1, sw2); } + + bool isOK() const { return sw1 == OK && sw2 == 0x00; } + + // TODO: friend function toString() in utilities.hpp +}; + +/** Struct that wraps command APDUs. */ +struct CommandApdu +{ + byte_type cla; + byte_type ins; + byte_type p1; + byte_type p2; + unsigned short le; + // Lc is data.size() + byte_vector data; + + static const size_t MAX_DATA_SIZE = 255; + static const unsigned short LE_UNUSED = std::numeric_limits::max(); + + CommandApdu(byte_type c, byte_type i, byte_type pp1, byte_type pp2, byte_vector d = {}, + unsigned short l = LE_UNUSED) : + cla(c), + ins(i), p1(pp1), p2(pp2), le(l), data(std::move(d)) + { + } + + CommandApdu(const CommandApdu& other, byte_vector d) : + cla(other.cla), ins(other.ins), p1(other.p1), p2(other.p2), le(other.le), data(std::move(d)) + { + } + + bool isLeSet() const { return le != LE_UNUSED; } + + static CommandApdu fromBytes(const byte_vector& bytes, bool useLe = false) + { + if (bytes.size() < 4) { + throw std::invalid_argument("Command APDU must have > 3 bytes"); + } + + if (bytes.size() == 4) { + return CommandApdu {bytes[0], bytes[1], bytes[2], bytes[3]}; + } + + if (bytes.size() == 5) { + if (useLe) { + return CommandApdu {bytes[0], bytes[1], bytes[2], + bytes[3], byte_vector(), bytes[4]}; + } + throw std::invalid_argument("Command APDU size 5 is invalid without LE"); + } + + if (bytes.size() == 6 && useLe) { + throw std::invalid_argument("Command APDU size 6 uses LE"); + } + + // 0 - cla, 1 - ins, 2 - p1, 3 - p2, 4 - data size + // FIXME: can command chaining use byte 5 for data size too? + auto dataStart = bytes.cbegin() + 5; + + if (useLe) { + return CommandApdu {bytes[0], + bytes[1], + bytes[2], + bytes[3], + byte_vector(dataStart, bytes.cend() - 1), + *(bytes.cend() - 1)}; + } + return CommandApdu {bytes[0], bytes[1], bytes[2], bytes[3], + byte_vector(dataStart, bytes.cend())}; + } + + byte_vector toBytes() const + { + if (data.size() > MAX_DATA_SIZE) { + throw std::invalid_argument("Command chaining not supported"); + } + + auto bytes = byte_vector {cla, ins, p1, p2}; + + if (!data.empty()) { + bytes.push_back(static_cast(data.size())); + bytes.insert(bytes.end(), data.cbegin(), data.cend()); + } + + if (isLeSet()) { + // TODO: EstEID spec: the maximum value of Le is 0xFE + if (le > ResponseApdu::MAX_DATA_SIZE) + throw std::invalid_argument("LE larger than response size"); + bytes.push_back(static_cast(le)); + } + + return bytes; + } +}; + +/** Opaque class that wraps the PC/SC smart card resources like card handle and I/O protocol. */ +class CardImpl; +using CardImplPtr = std::unique_ptr; + +/** PIN pad PIN entry timer timeout */ +constexpr uint8_t PIN_PAD_PIN_ENTRY_TIMEOUT = 90; // 1 minute, 30 seconds + +/** SmartCard manages bidirectional input/output to an ISO 7816 smart card. */ +class SmartCard +{ +public: + enum class Protocol { UNDEFINED, T0, T1 }; // AUTO = T0 | T1 + + using ptr = std::unique_ptr; + + class TransactionGuard + { + public: + TransactionGuard(const CardImpl& CardImpl, bool& inProgress); + ~TransactionGuard(); + PCSC_CPP_DISABLE_COPY_MOVE(TransactionGuard); + + private: + const CardImpl& card; + bool& inProgress; + }; + + SmartCard(const ContextPtr& context, const string_t& readerName, byte_vector atr); + SmartCard(); // Null object constructor. + ~SmartCard(); + PCSC_CPP_DISABLE_COPY_MOVE(SmartCard); + + TransactionGuard beginTransaction(); + ResponseApdu transmit(const CommandApdu& command) const; + ResponseApdu transmitCTL(const CommandApdu& command, uint16_t lang, uint8_t minlen) const; + bool readerHasPinPad() const; + + Protocol protocol() const { return _protocol; } + const byte_vector& atr() const { return _atr; } + +private: + CardImplPtr card; + byte_vector _atr; + Protocol _protocol = Protocol::UNDEFINED; + bool transactionInProgress = false; +}; + +/** Reader provides card reader information, status and gives access to the smart card in it. */ +class Reader +{ +public: + enum class Status { + UNAWARE, + IGNORE, + CHANGED, + UNKNOWN, + UNAVAILABLE, + EMPTY, + PRESENT, + ATRMATCH, + EXCLUSIVE, + INUSE, + MUTE, + UNPOWERED, + _ + }; + + Reader(ContextPtr context, string_t name, byte_vector cardAtr, flag_set status); + + SmartCard::ptr connectToCard() const { return std::make_unique(ctx, name, cardAtr); } + + bool isCardInserted() const { return status[Status::PRESENT]; } + + std::string statusString() const; + + const string_t name; + const byte_vector cardAtr; + const flag_set status; + +private: + ContextPtr ctx; +}; + +/** + * Access system smart card readers, entry point to the library. + * + * @throw ScardError, SystemError + */ +std::vector listReaders(); + +// Utility functions. + +extern const byte_vector APDU_RESPONSE_OK; + +/** Convert bytes to hex string. */ +std::string bytes2hexstr(const byte_vector& bytes); + +/** Transmit APDU command and verify that expected response is received. */ +void transmitApduWithExpectedResponse(const SmartCard& card, const CommandApdu& command, + const byte_vector& expectedResponseBytes = APDU_RESPONSE_OK); +void transmitApduWithExpectedResponse(const SmartCard& card, const byte_vector& commandBytes, + const byte_vector& expectedResponseBytes = APDU_RESPONSE_OK); + +/** Read data length from currently selected file header, file must be ASN.1-encoded. */ +size_t readDataLengthFromAsn1(const SmartCard& card); + +/** Read lenght bytes from currently selected binary file in blockLength-sized chunks. */ +byte_vector readBinary(const SmartCard& card, const size_t length, const size_t blockLength); + +// Errors. + +/** Base class for all pcsc-cpp errors. */ +class Error : public std::runtime_error +{ +public: + using std::runtime_error::runtime_error; +}; + +/** Programming or system errors. */ +class SystemError : public Error +{ +public: + using Error::Error; +}; + +/** Base class for all SCard API errors. */ +class ScardError : public Error +{ +public: + using Error::Error; +}; + +/** Thrown when the PC/SC service is not running. */ +class ScardServiceNotRunningError : public ScardError +{ +public: + using ScardError::ScardError; +}; + +/** Thrown when no card readers are connected to the system. */ +class ScardNoReadersError : public ScardError +{ +public: + using ScardError::ScardError; +}; + +/** Thrown when no card is connected to the selected reader. */ +class ScardNoCardError : public ScardError +{ +public: + using ScardError::ScardError; +}; + +/** Thrown when communication with the card or reader fails. */ +class ScardCardCommunicationFailedError : public ScardError +{ +public: + using ScardError::ScardError; +}; + +/** Thrown when the card is removed from the selected reader. */ +class ScardCardRemovedError : public ScardError +{ +public: + using ScardError::ScardError; +}; + +/** Thrown when the card transaction fails. */ +class ScardTransactionFailedError : public ScardError +{ +public: + using ScardError::ScardError; +}; + +} // namespace pcsc_cpp diff --git a/lib/libpcsc-cpp/scripts/clang-format.sh b/lib/libpcsc-cpp/scripts/clang-format.sh new file mode 100755 index 0000000..f2b0ec4 --- /dev/null +++ b/lib/libpcsc-cpp/scripts/clang-format.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +set -e +set -u + +cd "$( dirname "$0" )/.." + +find src/ include/ tests/{integration,mock} -iname '*.hpp' -o -iname '*.h' -o -iname '*.cpp' | xargs clang-format -i diff --git a/lib/libpcsc-cpp/src/Context.hpp b/lib/libpcsc-cpp/src/Context.hpp new file mode 100644 index 0000000..1c1d2db --- /dev/null +++ b/lib/libpcsc-cpp/src/Context.hpp @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#pragma once + +#include "pcsc-cpp/pcsc-cpp.hpp" +#include "pcsc-cpp/pcsc-cpp-utils.hpp" + +#include "SCardCall.hpp" + +#include "pcsc-cpp/comp_winscard.hpp" + +namespace pcsc_cpp +{ + +class Context +{ +public: + Context() + { + SCard(EstablishContext, DWORD(SCARD_SCOPE_USER), nullptr, nullptr, &contextHandle); + if (!contextHandle) { + THROW(ScardError, + "Context:SCardEstablishContext: service unavailable " + "(null context handle)"); + } + } + + ~Context() + { + if (contextHandle) { + // Cannot throw in destructor, so cannot use the SCard() macro here. + auto result = SCardReleaseContext(contextHandle); + contextHandle = 0; + (void)result; // TODO: Log result here in case it is not OK. + } + } + + PCSC_CPP_DISABLE_COPY_MOVE(Context); + + SCARDCONTEXT handle() const { return contextHandle; } + +private: + SCARDCONTEXT contextHandle = 0; +}; + +} // namespace pcsc_cpp diff --git a/lib/libpcsc-cpp/src/Reader.cpp b/lib/libpcsc-cpp/src/Reader.cpp new file mode 100644 index 0000000..9ba226c --- /dev/null +++ b/lib/libpcsc-cpp/src/Reader.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "pcsc-cpp/pcsc-cpp.hpp" + +#include "magic_enum/magic_enum.hpp" + +#include + +namespace pcsc_cpp +{ + +Reader::Reader(ContextPtr c, string_t n, byte_vector atr, flag_set s) : + name(std::move(n)), cardAtr(std::move(atr)), status(s), ctx(std::move(c)) +{ +} + +std::string Reader::statusString() const +{ + std::vector result; + + for (auto statusValue = int(Reader::Status::UNAWARE); statusValue < int(Reader::Status::_); + ++statusValue) { + if (status[Reader::Status(statusValue)]) { + result.emplace_back(magic_enum::enum_name(Reader::Status(statusValue))); + } + } + + return std::accumulate(std::begin(result), std::end(result), std::string(), + [](const std::string& resultStr, const std::string& item) { + return resultStr.empty() ? item : resultStr + "," + item; + }); +} + +} // namespace pcsc_cpp diff --git a/lib/libpcsc-cpp/src/SCardCall.hpp b/lib/libpcsc-cpp/src/SCardCall.hpp new file mode 100644 index 0000000..a0b4cb4 --- /dev/null +++ b/lib/libpcsc-cpp/src/SCardCall.hpp @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#pragma once + +#include "pcsc-cpp/pcsc-cpp.hpp" +#include "pcsc-cpp/comp_winscard.hpp" +#include "pcsc-cpp/pcsc-cpp-utils.hpp" + +#include + +#ifdef _WIN32 +#include +#endif // _WIN32 + +namespace pcsc_cpp +{ + +inline std::string buildErrorMessage(const char* callerFunctionName, const char* scardFunctionName, + const LONG result, const char* file, int line) +{ + return std::string(scardFunctionName) + " returned " + int2hexstr(result) + " in " + + removeAbsolutePathPrefix(file) + ':' + std::to_string(line) + ':' + callerFunctionName; +} + +template +void SCardCall(const char* callerFunctionName, const char* file, int line, + const char* scardFunctionName, Func scardFunction, Args... args) +{ + // TODO: Add logging - or is exception error message enough? + + const LONG result = scardFunction(args...); + + // TODO: Add more cases when needed. + switch (result) { + case SCARD_S_SUCCESS: + return; + case LONG(SCARD_E_NO_SERVICE): + case LONG(SCARD_E_SERVICE_STOPPED): + throw ScardServiceNotRunningError( + buildErrorMessage(callerFunctionName, scardFunctionName, result, file, line)); + case LONG(SCARD_E_NO_READERS_AVAILABLE): + case LONG(SCARD_E_READER_UNAVAILABLE): + throw ScardNoReadersError( + buildErrorMessage(callerFunctionName, scardFunctionName, result, file, line)); + case LONG(SCARD_E_NO_SMARTCARD): +#ifdef _WIN32 + case ERROR_NO_MEDIA_IN_DRIVE: +#endif // _WIN32 + throw ScardNoCardError( + buildErrorMessage(callerFunctionName, scardFunctionName, result, file, line)); + case LONG(SCARD_E_NOT_READY): + case LONG(SCARD_E_INVALID_VALUE): + case LONG(SCARD_E_COMM_DATA_LOST): + case LONG(SCARD_W_RESET_CARD): +#ifdef _WIN32 + case ERROR_IO_DEVICE: +#endif // _WIN32 + throw ScardCardCommunicationFailedError( + buildErrorMessage(callerFunctionName, scardFunctionName, result, file, line)); + case LONG(SCARD_W_REMOVED_CARD): + throw ScardCardRemovedError( + buildErrorMessage(callerFunctionName, scardFunctionName, result, file, line)); + case LONG(SCARD_E_NOT_TRANSACTED): + throw ScardTransactionFailedError( + buildErrorMessage(callerFunctionName, scardFunctionName, result, file, line)); + default: + throw ScardError( + buildErrorMessage(callerFunctionName, scardFunctionName, result, file, line)); + } +} + +} // namespace pcsc_cpp + +#define SCard(APIFunctionName, ...) \ + SCardCall(__FUNCTION__, __FILE__, __LINE__, "SCard" #APIFunctionName, SCard##APIFunctionName, \ + __VA_ARGS__) diff --git a/lib/libpcsc-cpp/src/SmartCard.cpp b/lib/libpcsc-cpp/src/SmartCard.cpp new file mode 100644 index 0000000..eeda76b --- /dev/null +++ b/lib/libpcsc-cpp/src/SmartCard.cpp @@ -0,0 +1,303 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "pcsc-cpp/pcsc-cpp.hpp" + +#include "Context.hpp" +#include "pcsc-cpp/comp_winscard.hpp" + +#ifdef _WIN32 +#include +#elif !defined(__APPLE__) +#include +#endif + +#include +#include +#include + +// TODO: Someday, maybe SCARD_SHARE_SHARED vs SCARD_SHARE_EXCLUSIVE and SCARD_RESET_CARD on +// disconnect if SCARD_SHARE_EXCLUSIVE, SCARD_LEAVE_CARD otherwise. + +namespace +{ + +using namespace pcsc_cpp; + +constexpr SmartCard::Protocol convertToSmartCardProtocol(const DWORD protocol) +{ + switch (protocol) { + case SCARD_PROTOCOL_UNDEFINED: + return SmartCard::Protocol::UNDEFINED; + case SCARD_PROTOCOL_T0: + return SmartCard::Protocol::T0; + case SCARD_PROTOCOL_T1: + return SmartCard::Protocol::T1; + default: + THROW(Error, "Unsupported card protocol: " + std::to_string(protocol)); + } +} + +std::pair connectToCard(const SCARDCONTEXT ctx, const string_t& readerName) +{ + const unsigned requestedProtocol = + SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1; // Let PCSC auto-select protocol. + DWORD protocolOut = SCARD_PROTOCOL_UNDEFINED; + SCARDHANDLE cardHandle = 0; + + SCard(Connect, ctx, readerName.c_str(), DWORD(SCARD_SHARE_SHARED), requestedProtocol, + &cardHandle, &protocolOut); + + return std::pair {cardHandle, protocolOut}; +} + +} // namespace + +namespace pcsc_cpp +{ + +class CardImpl +{ +public: + explicit CardImpl(std::pair cardParams) : + cardHandle(cardParams.first), _protocol({cardParams.second, sizeof(SCARD_IO_REQUEST)}) + { + // TODO: debug("Protocol: " + to_string(protocol())) + try { + DWORD size = 0; + std::array feature {}; + SCard(Control, cardHandle, DWORD(CM_IOCTL_GET_FEATURE_REQUEST), nullptr, 0U, + feature.data(), DWORD(feature.size()), &size); + for (auto p = feature.cbegin(); DWORD(std::distance(feature.cbegin(), p)) < size;) { + auto tag = DRIVER_FEATURES(*p++); + uint32_t value = 0; + for (unsigned int i = 0, len = *p++; i < len; ++i) + value |= uint32_t(*p++) << 8 * i; + features[tag] = ntohl(value); + } + } catch (const ScardError&) { + // Ignore driver errors during card feature requests. + // TODO: debug(error) + } + } + + ~CardImpl() + { + if (cardHandle) { + // Cannot throw in destructor, so cannot use the SCard() macro here. + auto result = SCardDisconnect(cardHandle, SCARD_LEAVE_CARD); + cardHandle = 0; + (void)result; // TODO: Log result here in case it is not OK. + } + } + + PCSC_CPP_DISABLE_COPY_MOVE(CardImpl); + + bool readerHasPinPad() const + { + if (getenv("SMARTCARDPP_NOPINPAD")) + return false; + return features.find(FEATURE_VERIFY_PIN_START) != features.cend() + || features.find(FEATURE_VERIFY_PIN_DIRECT) != features.cend(); + } + + ResponseApdu transmitBytes(const byte_vector& commandBytes) const + { + byte_vector responseBytes(ResponseApdu::MAX_SIZE, 0); + auto responseLength = DWORD(responseBytes.size()); + + // TODO: debug("Sending: " + bytes2hexstr(commandBytes)) + + SCard(Transmit, cardHandle, &_protocol, commandBytes.data(), DWORD(commandBytes.size()), + nullptr, responseBytes.data(), &responseLength); + + auto response = toResponse(responseBytes, responseLength); + + if (response.sw1 == ResponseApdu::MORE_DATA_AVAILABLE) { + getMoreResponseData(response); + } + + return response; + } + + ResponseApdu transmitBytesCTL(const byte_vector& commandBytes, uint16_t lang, + uint8_t minlen) const + { + uint8_t PINFrameOffset = 0; + uint8_t PINLengthOffset = 0; + byte_vector cmd(sizeof(PIN_VERIFY_STRUCTURE)); + auto* data = (PIN_VERIFY_STRUCTURE*)cmd.data(); + data->bTimerOut = PIN_PAD_PIN_ENTRY_TIMEOUT; + data->bTimerOut2 = PIN_PAD_PIN_ENTRY_TIMEOUT; + data->bmFormatString = + FormatASCII | AlignLeft | uint8_t(PINFrameOffset << 4) | PINFrameOffsetUnitBits; + data->bmPINBlockString = PINLengthNone << 5 | PINFrameSizeAuto; + data->bmPINLengthFormat = PINLengthOffsetUnitBits | PINLengthOffset; + data->wPINMaxExtraDigit = uint16_t(minlen << 8) | 12; + data->bEntryValidationCondition = ValidOnKeyPressed; + data->bNumberMessage = CCIDDefaultInvitationMessage; + data->wLangId = lang; + data->bMsgIndex = NoInvitationMessage; + data->ulDataLength = uint32_t(commandBytes.size()); + cmd.insert(cmd.cend(), commandBytes.cbegin(), commandBytes.cend()); + + DWORD ioctl = features.at(features.find(FEATURE_VERIFY_PIN_START) != features.cend() + ? FEATURE_VERIFY_PIN_START + : FEATURE_VERIFY_PIN_DIRECT); + byte_vector responseBytes(ResponseApdu::MAX_SIZE, 0); + auto responseLength = DWORD(responseBytes.size()); + SCard(Control, cardHandle, ioctl, cmd.data(), DWORD(cmd.size()), + LPVOID(responseBytes.data()), DWORD(responseBytes.size()), &responseLength); + + if (features.find(FEATURE_VERIFY_PIN_FINISH) != features.cend()) { + DWORD finish = features.at(FEATURE_VERIFY_PIN_FINISH); + responseLength = DWORD(responseBytes.size()); + SCard(Control, cardHandle, finish, nullptr, 0U, LPVOID(responseBytes.data()), + DWORD(responseBytes.size()), &responseLength); + } + + return toResponse(responseBytes, responseLength); + } + + void beginTransaction() const { SCard(BeginTransaction, cardHandle); } + + void endTransaction() const { SCard(EndTransaction, cardHandle, DWORD(SCARD_LEAVE_CARD)); } + + DWORD protocol() const { return _protocol.dwProtocol; } + +private: + SCARDHANDLE cardHandle; + const SCARD_IO_REQUEST _protocol; + std::map features; + + ResponseApdu toResponse(byte_vector& responseBytes, size_t responseLength) const + { + if (responseLength > responseBytes.size()) { + THROW(Error, "SCardTransmit: received more bytes than buffer size"); + } + responseBytes.resize(responseLength); + + // TODO: debug("Received: " + bytes2hexstr(responseBytes)) + + auto response = ResponseApdu::fromBytes(responseBytes); + + // Let expected errors through for handling in upper layers or in if blocks below. + switch (response.sw1) { + case ResponseApdu::OK: + case ResponseApdu::MORE_DATA_AVAILABLE: // See the if block after next. + case ResponseApdu::VERIFICATION_FAILED: + case ResponseApdu::VERIFICATION_CANCELLED: + case ResponseApdu::WRONG_LENGTH: + case ResponseApdu::COMMAND_NOT_ALLOWED: + case ResponseApdu::WRONG_PARAMETERS: + case ResponseApdu::WRONG_LE_LENGTH: // See next if block. + break; + default: + THROW(Error, + "Error response: '" + bytes2hexstr({response.sw1, response.sw2}) + "', protocol " + + std::to_string(protocol())); + } + + if (response.sw1 == ResponseApdu::WRONG_LE_LENGTH) { + THROW(Error, "Wrong LE length (SW1=0x6C) in response, please set LE"); + } + + return response; + } + + void getMoreResponseData(ResponseApdu& response) const + { + byte_vector getResponseCommand {0x00, 0xc0, 0x00, 0x00, 0x00}; + + auto newResponse = ResponseApdu(response.sw1, response.sw2); + + while (newResponse.sw1 == ResponseApdu::MORE_DATA_AVAILABLE) { + getResponseCommand[4] = newResponse.sw2; + newResponse = transmitBytes(getResponseCommand); + response.data.insert(response.data.end(), newResponse.data.cbegin(), + newResponse.data.cend()); + } + + response.sw1 = ResponseApdu::OK; + response.sw2 = 0; + } +}; + +SmartCard::TransactionGuard::TransactionGuard(const CardImpl& card, bool& inProgress) : + card(card), inProgress(inProgress) +{ + card.beginTransaction(); + inProgress = true; +} + +SmartCard::TransactionGuard::~TransactionGuard() +{ + inProgress = false; + try { + card.endTransaction(); + } catch (...) { + // Ignore exceptions in destructor. + } +} + +SmartCard::SmartCard(const ContextPtr& contex, const string_t& readerName, byte_vector atr) : + card(std::make_unique(connectToCard(contex->handle(), readerName))), + _atr(std::move(atr)), _protocol(convertToSmartCardProtocol(card->protocol())) +{ + // TODO: debug("Card ATR -> " + bytes2hexstr(atr)) +} + +SmartCard::SmartCard() = default; +SmartCard::~SmartCard() = default; + +SmartCard::TransactionGuard SmartCard::beginTransaction() +{ + REQUIRE_NON_NULL(card) + return {*card, transactionInProgress}; +} + +bool SmartCard::readerHasPinPad() const +{ + return card ? card->readerHasPinPad() : false; +} + +ResponseApdu SmartCard::transmit(const CommandApdu& command) const +{ + REQUIRE_NON_NULL(card) + if (!transactionInProgress) { + THROW(std::logic_error, "Call SmartCard::transmit() inside a transaction"); + } + + return card->transmitBytes(command.toBytes()); +} + +ResponseApdu SmartCard::transmitCTL(const CommandApdu& command, uint16_t lang, uint8_t minlen) const +{ + REQUIRE_NON_NULL(card) + if (!transactionInProgress) { + THROW(std::logic_error, "Call SmartCard::transmit() inside a transaction"); + } + + return card->transmitBytesCTL(command.toBytes(), lang, minlen); +} + +} // namespace pcsc_cpp diff --git a/lib/libpcsc-cpp/src/listReaders.cpp b/lib/libpcsc-cpp/src/listReaders.cpp new file mode 100644 index 0000000..213834b --- /dev/null +++ b/lib/libpcsc-cpp/src/listReaders.cpp @@ -0,0 +1,159 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "pcsc-cpp/pcsc-cpp.hpp" + +#include "Context.hpp" + +#include +#include +#include +#include + +namespace +{ + +using namespace pcsc_cpp; + +inline DWORD updateReaderNamesBuffer(const SCARDCONTEXT ctx, string_t::value_type* buffer, + const DWORD bufferLength = 0) +{ + auto bufferLengthOut = bufferLength; + SCard(ListReaders, ctx, nullptr, buffer, &bufferLengthOut); + return bufferLengthOut; +} + +std::vector getReaderNamePointerList(const string_t& readerNames) +{ + auto readerNamePointerList = std::vector {}; + + if (readerNames.empty()) + return readerNamePointerList; + + // Reader names are \0 separated and end with double \0. +#ifdef _WIN32 + for (const string_t::value_type* name = readerNames.c_str(); *name; name += wcslen(name) + 1) { +#else + for (const string_t::value_type* name = readerNames.c_str(); *name; name += strlen(name) + 1) { +#endif + readerNamePointerList.push_back(name); + } + + return readerNamePointerList; +} + +std::vector getReaderStates(const SCARDCONTEXT ctx, const string_t& readerNames) +{ + auto readerStates = std::vector {}; + for (const auto& readerNamePointer : getReaderNamePointerList(readerNames)) { + readerStates.push_back({readerNamePointer, + nullptr, + SCARD_STATE_UNAWARE, + SCARD_STATE_UNAWARE, + 0, + { + 0, + }}); + } + + if (readerStates.empty()) + return {}; + + SCard(GetStatusChange, ctx, 0U, readerStates.data(), DWORD(readerStates.size())); + + return readerStates; +} + +inline flag_set flagSetFromReaderState(const DWORD readerState) +{ + if (!readerState) { + return flag_set {Reader::Status::UNAWARE}; + } + + static const std::map READER_STATUS_MAP = { + // SCARD_STATE_UNAWARE is zero and covered with (!readerState) above. + {SCARD_STATE_IGNORE, Reader::Status::IGNORE}, + {SCARD_STATE_CHANGED, Reader::Status::CHANGED}, + {SCARD_STATE_UNKNOWN, Reader::Status::UNKNOWN}, + {SCARD_STATE_UNAVAILABLE, Reader::Status::UNAVAILABLE}, + {SCARD_STATE_EMPTY, Reader::Status::EMPTY}, + {SCARD_STATE_PRESENT, Reader::Status::PRESENT}, + {SCARD_STATE_ATRMATCH, Reader::Status::ATRMATCH}, + {SCARD_STATE_EXCLUSIVE, Reader::Status::EXCLUSIVE}, + {SCARD_STATE_INUSE, Reader::Status::INUSE}, + {SCARD_STATE_MUTE, Reader::Status::MUTE}, + {SCARD_STATE_UNPOWERED, Reader::Status::UNPOWERED}}; + + auto result = flag_set {}; + + for (const auto& [key, value] : READER_STATUS_MAP) { + if (readerState & key) { + result.set(value); + } + } + + return result; +} + +inline Reader makeReader(const ContextPtr& ctx, const SCARD_READERSTATE& readerState) +{ + return Reader {ctx, readerState.szReader, + byte_vector {readerState.rgbAtr, readerState.rgbAtr + readerState.cbAtr}, + flagSetFromReaderState(readerState.dwEventState)}; +} + +string_t populateReaderNames(const SCARDCONTEXT ctx) +{ + // Buffer length is in characters, not bytes. + const auto bufferLength = updateReaderNamesBuffer(ctx, nullptr); + + auto readerNames = string_t(bufferLength, 0); + + // The returned buffer length is no longer useful, ignore it. + updateReaderNamesBuffer(ctx, readerNames.data(), bufferLength); + + return readerNames; +} + +} // anonymous namespace + +namespace pcsc_cpp +{ + +std::vector listReaders() +{ + auto ctx = std::make_shared(); + + try { + auto readerNames = populateReaderNames(ctx->handle()); + + auto readers = std::vector {}; + for (const auto& readerState : getReaderStates(ctx->handle(), readerNames)) { + readers.emplace_back(makeReader(ctx, readerState)); + } + return readers; + } catch (const ScardNoReadersError& /* e */) { + return std::vector {}; + } +} + +} // namespace pcsc_cpp diff --git a/lib/libpcsc-cpp/src/utils.cpp b/lib/libpcsc-cpp/src/utils.cpp new file mode 100644 index 0000000..a5567f1 --- /dev/null +++ b/lib/libpcsc-cpp/src/utils.cpp @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "pcsc-cpp/pcsc-cpp.hpp" +#include "pcsc-cpp/pcsc-cpp-utils.hpp" + +#include +#include + +using namespace pcsc_cpp; +using namespace std::string_literals; + +#ifdef HIBYTE +#undef HIBYTE +#endif +#ifdef LOBYTE +#undef LOBYTE +#endif + +constexpr byte_type HIBYTE(size_t w) +{ + return static_cast((w >> 8) & 0xff); +} +constexpr byte_type LOBYTE(size_t w) +{ + return static_cast(w & 0xff); +} + +namespace +{ + +const byte_type DER_SEQUENCE_TYPE_TAG = 0x30; +const byte_type DER_TWO_BYTE_LENGTH = 0x82; + +class UnexpectedResponseError : public Error +{ +public: + explicit UnexpectedResponseError(const CommandApdu& command, + const byte_vector& expectedResponseBytes, + const ResponseApdu& response, const char* file, const int line, + const char* callerFunctionName) : + Error("transmitApduWithExpectedResponse(): Unexpected response to command '"s + + bytes2hexstr(command.toBytes()) + "' - expected '"s + + bytes2hexstr(expectedResponseBytes) + "', got '"s + bytes2hexstr(response.toBytes()) + + " in " + removeAbsolutePathPrefix(file) + ':' + std::to_string(line) + ':' + + callerFunctionName) + { + } +}; + +} // namespace + +namespace pcsc_cpp +{ + +const byte_vector APDU_RESPONSE_OK {ResponseApdu::OK, 0x00}; + +std::string bytes2hexstr(const byte_vector& bytes) +{ + std::ostringstream hexStringBuilder; + + hexStringBuilder << std::setfill('0') << std::hex; + + for (const auto byte : bytes) + hexStringBuilder << std::setw(2) << short(byte); + + return hexStringBuilder.str(); +} + +void transmitApduWithExpectedResponse(const SmartCard& card, const byte_vector& commandBytes, + const byte_vector& expectedResponseBytes) +{ + const auto command = CommandApdu::fromBytes(commandBytes); + transmitApduWithExpectedResponse(card, command, expectedResponseBytes); +} + +void transmitApduWithExpectedResponse(const SmartCard& card, const CommandApdu& command, + const byte_vector& expectedResponseBytes) +{ + const auto response = card.transmit(command); + if (response.toBytes() != expectedResponseBytes) { + throw UnexpectedResponseError(command, expectedResponseBytes, response, __FILE__, __LINE__, + __func__); + } +} + +size_t readDataLengthFromAsn1(const SmartCard& card) +{ + // p1 - offset size first byte, 0 + // p2 - offset size second byte, 0 + // le - number of bytes to read, need 4 bytes from start for length + const auto readBinary4Bytes = CommandApdu {0x00, 0xb0, 0x00, 0x00, byte_vector(), 0x04}; + + auto response = card.transmit(readBinary4Bytes); + + // Verify expected DER header, first byte must be SEQUENCE. + if (response.data[0] != DER_SEQUENCE_TYPE_TAG) { + // TODO: more specific exception + THROW(Error, + "readDataLengthFromAsn1(): First byte must be SEQUENCE (0x30), but is 0x"s + + bytes2hexstr({response.data[0]})); + } + + // TODO: support other lenghts besides 2. + // Assume 2-byte length, so second byte must be 0x82. + if (response.data[1] != DER_TWO_BYTE_LENGTH) { + // TODO: more specific exception + THROW(Error, + "readDataLengthFromAsn1(): Second byte must be two-byte length indicator "s + "(0x82), but is 0x"s + + bytes2hexstr({response.data[1]})); + } + + // Read 2-byte length field at offset 2 and 3 and add the 4 DER length bytes. + const auto length = size_t((response.data[2] << 8) + response.data[3] + 4); + if (length < 128 || length > 0x0f00) { + // TODO: more specific exception + THROW(Error, + "readDataLengthFromAsn1(): Unexpected data length in DER header: "s + + std::to_string(length)); + } + + return length; +} + +byte_vector readBinary(const SmartCard& card, const size_t length, const size_t blockLength) +{ + size_t blockLengthVar = blockLength; + auto lengthCounter = length; + auto resultBytes = byte_vector {}; + auto readBinary = CommandApdu {0x00, 0xb0, 0x00, 0x00}; + + for (size_t offset = 0; lengthCounter != 0; + offset += blockLengthVar, lengthCounter -= blockLengthVar) { + + if (blockLengthVar > lengthCounter) { + blockLengthVar = lengthCounter; + } + + readBinary.p1 = HIBYTE(offset); + readBinary.p2 = LOBYTE(offset); + readBinary.le = static_cast(blockLengthVar); + + auto response = card.transmit(readBinary); + + resultBytes.insert(resultBytes.end(), response.data.cbegin(), response.data.cend()); + } + + if (resultBytes.size() != length) { + // TODO: more specific exception + THROW(Error, "readBinary(): Invalid length: "s + std::to_string(resultBytes.size())); + } + + return resultBytes; +} + +} // namespace pcsc_cpp diff --git a/lib/libpcsc-cpp/tests/integration/test-pcsc-cpp.cpp b/lib/libpcsc-cpp/tests/integration/test-pcsc-cpp.cpp new file mode 100644 index 0000000..9a988a2 --- /dev/null +++ b/lib/libpcsc-cpp/tests/integration/test-pcsc-cpp.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "pcsc-cpp/pcsc-cpp.hpp" + +#include "gtest/gtest.h" + +#include + +TEST(pcsc_cpp_test, listReaders) +{ + using namespace pcsc_cpp; + + auto readers = listReaders(); + for (const auto& reader : readers) { +#ifdef _WIN32 + std::wcout << L"Reader name: '" << reader.name << L"', status: '" + << std::wstring(reader.statusString().cbegin(), reader.statusString().cend()) + << L"'" << std::endl; +#else + std::cout << "Reader name: '" << reader.name << "', status: '" << reader.statusString() + << "'" << std::endl; +#endif + } +} diff --git a/lib/libpcsc-cpp/tests/lib/libpcsc-mock/CMakeLists.txt b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/CMakeLists.txt new file mode 100644 index 0000000..c34f850 --- /dev/null +++ b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/CMakeLists.txt @@ -0,0 +1,64 @@ +cmake_minimum_required(VERSION 3.8.0) +if(POLICY CMP0092) + cmake_policy(SET CMP0092 NEW) +endif() + +project(pcsc-mock) + +# The pcsc-mock library itself. + +add_library(${PROJECT_NAME} + STATIC + include/${PROJECT_NAME}/${PROJECT_NAME}.hpp + src/${PROJECT_NAME}.cpp +) + +target_compile_options(${PROJECT_NAME} PUBLIC + $<$:/W4 /WX> + $<$>:-Wall -Wextra -pedantic -Werror> +) + +target_compile_definitions(${PROJECT_NAME} PUBLIC + $<$:WIN32_LEAN_AND_MEAN;UNICODE> +) + +target_include_directories(${PROJECT_NAME} + PUBLIC + include +) + +target_compile_features(${PROJECT_NAME} + PUBLIC + cxx_std_17 +) + +# PC/SC API dependencies. + +if(MSVC) + # no extra includes required +elseif(APPLE) + # no extra includes required +else() + find_package(PkgConfig) + pkg_check_modules(PCSC libpcsclite) + target_include_directories(${PROJECT_NAME} PUBLIC ${PCSC_INCLUDE_DIRS}) +endif() + +# Tests with Google Test. + +enable_testing() + +find_package(GTest REQUIRED) + +set(TEST_EXE lib${PROJECT_NAME}-test) + +add_executable(${TEST_EXE} + tests/${PROJECT_NAME}-test.cpp +) + +target_link_libraries(${TEST_EXE} + ${PROJECT_NAME} + GTest::Main +) + +add_test(${TEST_EXE} ${TEST_EXE}) diff --git a/lib/libpcsc-cpp/tests/lib/libpcsc-mock/LICENSE b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/LICENSE new file mode 100644 index 0000000..326ac32 --- /dev/null +++ b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020-2023 Estonian Information System Authority + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/lib/libpcsc-cpp/tests/lib/libpcsc-mock/README.md b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/README.md new file mode 100644 index 0000000..34d7614 --- /dev/null +++ b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/README.md @@ -0,0 +1,74 @@ +# libpcsc-mock + +C++ library for mocking responses to PC/SC smart card API function calls. +Intended to be used in unit tests to emulate complex PC/SC scenarios like +different smart card and reader states and replay of longer APDU +request/response sequences. + +## Overview + +Here is a visual overview of the library: + +![libpcsc-mock](docs/libpcsc-mock.png) + +Given the system under test uses the PC/SC API, here is an example Google Test +unit test that uses *libpcsc-mock* to mock the response of the +`SCardListReaders` PC/SC call: + +```c++ +TEST(pcsc_cpp_test, listReadersNoReaders) +{ + PcscMock::addReturnValueForScardFunctionCall("SCardListReaders", + SCARD_E_NO_READERS_AVAILABLE); + + auto readers = systemUnderTest.listReaders(); + EXPECT_EQ(readers.size(), 0); +} +``` + +Here is an example test that uses the replay of longer APDU request/response +sequences: + +```c++ +const PcscMock::ApduScript GET_CERTIFICATE { + // Select master file. + {{0x00, 0xa4, 0x00, 0x0c}, {0x90, 0x00}}, + // Select directory. + {{0x00, 0xa4, 0x01, 0x0c, 0x02, 0xee, 0xee}, {0x90, 0x00}}, + // Select certificate file. + {{0x00, 0xa4, 0x02, 0x0c, 0x02, 0xaa, 0xce}, {0x90, 0x00}}, + ... +}; + +TEST(electronic_id_test, selectCertificate) +{ + PcscMock::setApduScript(GET_CERTIFICATE); + auto certificate = systemUnderTest.getCertificate(); + ... +} +``` + +You can find more test examples in the +[*libelectronic-id*](https://github.com/web-eid/libelectronic-id/) project +`tests/mock` directory. + +## Building + +In Ubuntu: + + apt install build-essential pkg-config cmake libgtest-dev valgrind libpcsclite-dev + sudo bash -c 'cd /usr/src/googletest && cmake . && cmake --build . --target install' + + cd build + cmake .. # optionally with -DCMAKE_BUILD_TYPE=Debug + cmake --build . # optionally with VERBOSE=1 + +## Testing + +Build as described above, then inside `build` directory: + + ctest # or 'valgrind --leak-check=full ctest' + +## Development guidelines + +Format code with `scripts/clang-format.sh` before committing. diff --git a/lib/libpcsc-cpp/tests/lib/libpcsc-mock/docs/libpcsc-mock.png b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/docs/libpcsc-mock.png new file mode 100644 index 0000000..2e5c2aa Binary files /dev/null and b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/docs/libpcsc-mock.png differ diff --git a/lib/libpcsc-cpp/tests/lib/libpcsc-mock/include/pcsc-mock/pcsc-mock.hpp b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/include/pcsc-mock/pcsc-mock.hpp new file mode 100644 index 0000000..27ec0b9 --- /dev/null +++ b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/include/pcsc-mock/pcsc-mock.hpp @@ -0,0 +1,131 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#pragma once + +#include +#include +#include +#include +#include +#include + +#ifdef _WIN32 +using MOCK_LONG = int32_t; +#else +using MOCK_LONG = uint32_t; +#endif + +class PcscMockError : public std::runtime_error +{ +public: + using std::runtime_error::runtime_error; +}; + +class PcscMock +{ +public: + typedef std::vector byte_vector; + // An APDU script is a list of request-response APDU pairs. + typedef std::vector> ApduScript; + // Define local string type so that we can use wstring in Windows if needed. +#ifdef _WIN32 + using string_t = std::wstring; +#else + using string_t = std::string; +#endif + + static void callScardFunction(const std::string& function) + { + instance()._recordedCalls.insert(function); + } + + static bool wasScardFunctionCalled(const std::string& scardFunction) + { + return instance()._recordedCalls.find(scardFunction) != instance()._recordedCalls.end(); + } + + static void addReturnValueForScardFunctionCall(const std::string& scardFunctionName, + MOCK_LONG returnValue) + { + instance()._scardCallReturnValues[scardFunctionName] = returnValue; + } + + static uint32_t returnValueForScardFunctionCall(const std::string& scardFunctionName) + { + // If the key does not exist, then std::map inserts it with a zero-initialized value, + // this means that default return value is SCARD_S_SUCCESS. + return instance()._scardCallReturnValues[scardFunctionName]; + } + + static byte_vector responseForApduCommand(const byte_vector& command); + + static void reset() + { + auto& self = instance(); + + self._recordedCalls.clear(); + self._scardCallReturnValues.clear(); + self._atr = DEFAULT_CARD_ATR; + self._script = DEFAULT_SCRIPT; + self._stepCount = 0; + } + + static void setApduScript(const ApduScript& script) + { + auto& self = instance(); + self._script = script; + self._stepCount = 0; + } + + static const byte_vector& atr() { return instance()._atr; } + static void setAtr(const byte_vector& atr) { instance()._atr = atr; } + + static const byte_vector DEFAULT_CARD_ATR; + static const string_t DEFAULT_READER_NAME; + + static const byte_vector DEFAULT_COMMAND_APDU; + static const byte_vector DEFAULT_RESPONSE_APDU; + static const ApduScript DEFAULT_SCRIPT; + +private: + PcscMock() = default; + ~PcscMock() = default; + + // The rule of five (C++ Core guidelines C.21). + PcscMock(const PcscMock&) = delete; + PcscMock& operator=(const PcscMock&) = delete; + PcscMock(PcscMock&&) = delete; + PcscMock& operator=(PcscMock&&) = delete; + + static PcscMock& instance() + { + static PcscMock self; + return self; + } + + std::set _recordedCalls; + std::map _scardCallReturnValues; + byte_vector _atr = DEFAULT_CARD_ATR; + ApduScript _script = DEFAULT_SCRIPT; + size_t _stepCount = 0; +}; diff --git a/lib/libpcsc-cpp/tests/lib/libpcsc-mock/scripts/clang-format.sh b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/scripts/clang-format.sh new file mode 100644 index 0000000..f63b067 --- /dev/null +++ b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/scripts/clang-format.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +set -e +set -u + +cd "$( dirname "$0" )/.." + +find src/ include/ tests/ -iname '*.hpp' -o -iname '*.h' -o -iname '*.cpp' | xargs clang-format -i diff --git a/lib/libpcsc-cpp/tests/lib/libpcsc-mock/src/pcsc-mock.cpp b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/src/pcsc-mock.cpp new file mode 100644 index 0000000..c205b31 --- /dev/null +++ b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/src/pcsc-mock.cpp @@ -0,0 +1,315 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include + +#ifdef __APPLE__ +#include +#include +using LPSCARD_READERSTATE = SCARD_READERSTATE*; +#define MOCK_CONST +#else +#include +#define MOCK_CONST const +#endif + +#include +#include + +#include +#include + +using namespace std::string_literals; + +namespace +{ + +inline std::string bytes2hexstr(const PcscMock::byte_vector& bytes) +{ + std::ostringstream hexStringBuilder; + + hexStringBuilder << std::setfill('0') << std::hex; + + for (const auto byte : bytes) + hexStringBuilder << std::setw(2) << short(byte); + + return hexStringBuilder.str(); +} + +} // namespace + +PcscMock::byte_vector PcscMock::responseForApduCommand(const PcscMock::byte_vector& command) +{ + auto& self = instance(); + + // Restart script if at end. + if (self._stepCount >= self._script.size()) { + std::cerr << "pcsc-mock: WARNING: restarting script" << std::endl; + self._stepCount = 0; + } + + const auto& [expectedCommand, response] = self._script[self._stepCount]; + + // Empty expected command means that any command is accepted. + if (!expectedCommand.empty() && command != expectedCommand) { + throw PcscMockError("At step "s + std::to_string(self._stepCount) + + ": unexcpected command '"s + bytes2hexstr(command) + "', expected '"s + + bytes2hexstr(expectedCommand) + "' instead"s); + } + + ++self._stepCount; + return response; +} + +const PcscMock::byte_vector PcscMock::DEFAULT_CARD_ATR {0x1, 0x2, 0x3, 0x4}; +#ifdef _WIN32 +const PcscMock::string_t PcscMock::DEFAULT_READER_NAME {L"PcscMock-reader"s}; +#else +const PcscMock::string_t PcscMock::DEFAULT_READER_NAME {"PcscMock-reader"s}; +#endif + +const PcscMock::byte_vector PcscMock::DEFAULT_COMMAND_APDU {0x2, 0x1, 0x3, 0x4}; +const PcscMock::byte_vector PcscMock::DEFAULT_RESPONSE_APDU {0x90, 0x3}; + +const PcscMock::ApduScript PcscMock::DEFAULT_SCRIPT {{DEFAULT_COMMAND_APDU, DEFAULT_RESPONSE_APDU}}; + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4273) +__declspec(dllexport) const SCARD_IO_REQUEST g_rgSCardT0Pci = {SCARD_PROTOCOL_T0, + sizeof(SCARD_IO_REQUEST)}; +__declspec(dllexport) const SCARD_IO_REQUEST g_rgSCardT1Pci = {SCARD_PROTOCOL_T1, + sizeof(SCARD_IO_REQUEST)}; +__declspec(dllexport) const SCARD_IO_REQUEST g_rgSCardRawPci = {SCARD_PROTOCOL_RAW, + sizeof(SCARD_IO_REQUEST)}; +#pragma warning(pop) +#else +MOCK_CONST SCARD_IO_REQUEST g_rgSCardT0Pci = {SCARD_PROTOCOL_T0, sizeof(SCARD_IO_REQUEST)}; +MOCK_CONST SCARD_IO_REQUEST g_rgSCardT1Pci = {SCARD_PROTOCOL_T1, sizeof(SCARD_IO_REQUEST)}; +MOCK_CONST SCARD_IO_REQUEST g_rgSCardRawPci = {SCARD_PROTOCOL_RAW, sizeof(SCARD_IO_REQUEST)}; +#endif + +#ifdef _MSC_VER +WINSCARDAPI LONG WINAPI SCardEstablishContext(_In_ DWORD, _Reserved_ LPCVOID, _Reserved_ LPCVOID, + _Out_ LPSCARDCONTEXT context) +#else +LONG SCardEstablishContext(DWORD, LPCVOID, LPCVOID, LPSCARDCONTEXT context) +#endif +{ + PcscMock::callScardFunction(__FUNCTION__); + *context = 1; + return PcscMock::returnValueForScardFunctionCall(__FUNCTION__); +} + +#ifdef _MSC_VER +WINSCARDAPI LONG WINAPI SCardReleaseContext(SCARDCONTEXT) +#else +LONG SCardReleaseContext(SCARDCONTEXT) +#endif +{ + PcscMock::callScardFunction(__FUNCTION__); + return PcscMock::returnValueForScardFunctionCall(__FUNCTION__); +} + +#ifdef _MSC_VER // TODO: multibyte/Unicode API in Windows? +WINSCARDAPI LONG WINAPI SCardListReadersW(SCARDCONTEXT, LPCWSTR, LPWSTR mszReaders, + LPDWORD pcchReaders) +#else +LONG SCardListReaders(SCARDCONTEXT, LPCSTR, LPSTR mszReaders, LPDWORD pcchReaders) +#endif +{ + PcscMock::callScardFunction("SCardListReaders"); + + if (!pcchReaders) + return SCARD_E_INVALID_PARAMETER; + + DWORD bufferLength = DWORD(PcscMock::DEFAULT_READER_NAME.size() + 1); + + if (mszReaders && *pcchReaders < bufferLength) + return SCARD_E_INSUFFICIENT_BUFFER; + + auto returnValue = PcscMock::returnValueForScardFunctionCall("SCardListReaders"); + if (returnValue) { + return returnValue; + } + + *pcchReaders = bufferLength; + + if (!mszReaders) + // if buffer not given, only output buffer length + return SCARD_S_SUCCESS; + + auto buf = PcscMock::DEFAULT_READER_NAME; + buf.insert(buf.cend(), 0); + + memcpy(mszReaders, buf.c_str(), buf.size() * sizeof(PcscMock::string_t::value_type)); + + return SCARD_S_SUCCESS; +} + +#ifdef _MSC_VER // TODO: multibyte/Unicode API in Windows? +WINSCARDAPI LONG WINAPI SCardConnectW(_In_ SCARDCONTEXT, _In_ LPCWSTR, _In_ DWORD, + _In_ DWORD requestedProtocol, _Out_ LPSCARDHANDLE cardHandle, + _Out_ LPDWORD protocolOut) +#else +LONG SCardConnect(SCARDCONTEXT, LPCSTR, DWORD, DWORD requestedProtocol, LPSCARDHANDLE cardHandle, + LPDWORD protocolOut) +#endif +{ + PcscMock::callScardFunction("SCardConnect"); + + auto returnValue = PcscMock::returnValueForScardFunctionCall("SCardConnect"); + if (returnValue) { + return returnValue; + } + + // TODO: no RAW etc support + if (requestedProtocol == SCARD_PROTOCOL_T0 || requestedProtocol == SCARD_PROTOCOL_T1) { + *cardHandle = 0x0ff; + *protocolOut = requestedProtocol; + } else if (requestedProtocol == (SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1)) { + *cardHandle = 0x0ff; + *protocolOut = SCARD_PROTOCOL_T1; // TODO: make configurable + } else { + return SCARD_E_INVALID_PARAMETER; + } + + return SCARD_S_SUCCESS; +} + +#ifdef _MSC_VER +WINSCARDAPI LONG WINAPI SCardDisconnect(_In_ SCARDHANDLE, _In_ DWORD) +#else +LONG SCardDisconnect(SCARDHANDLE, DWORD) +#endif +{ + PcscMock::callScardFunction(__FUNCTION__); + return PcscMock::returnValueForScardFunctionCall(__FUNCTION__); +} + +#ifdef _MSC_VER // TODO: multibyte/Unicode API in Windows? +WINSCARDAPI LONG WINAPI SCardGetStatusChangeW(SCARDCONTEXT, DWORD, + LPSCARD_READERSTATEW rgReaderStates, DWORD cReaders) +#else +LONG SCardGetStatusChange(SCARDCONTEXT, DWORD, LPSCARD_READERSTATE rgReaderStates, DWORD cReaders) +#endif +{ + PcscMock::callScardFunction("SCardGetStatusChange"); + + if (!rgReaderStates || cReaders != 1) + return SCARD_E_INVALID_PARAMETER; + + auto returnValue = PcscMock::returnValueForScardFunctionCall("SCardGetStatusChange"); + if (returnValue) { + return returnValue; + } + + const auto& atr = PcscMock::atr(); + + rgReaderStates->szReader = PcscMock::DEFAULT_READER_NAME.c_str(); + size_t atrSize = atr.size(); + memcpy(rgReaderStates->rgbAtr, atr.data(), atrSize); + rgReaderStates->cbAtr = DWORD(atrSize); + rgReaderStates->dwEventState = SCARD_STATE_PRESENT; + + return SCARD_S_SUCCESS; +} + +#ifdef _MSC_VER +WINSCARDAPI LONG WINAPI SCardBeginTransaction(_In_ SCARDHANDLE) +#else +LONG SCardBeginTransaction(SCARDHANDLE) +#endif +{ + PcscMock::callScardFunction(__FUNCTION__); + return PcscMock::returnValueForScardFunctionCall(__FUNCTION__); +} + +#ifdef _MSC_VER +WINSCARDAPI LONG WINAPI SCardEndTransaction(_In_ SCARDHANDLE, _In_ DWORD) +#else +LONG SCardEndTransaction(SCARDHANDLE, DWORD) +#endif +{ + PcscMock::callScardFunction(__FUNCTION__); + return PcscMock::returnValueForScardFunctionCall(__FUNCTION__); +} + +#ifdef _MSC_VER +WINSCARDAPI LONG WINAPI SCardTransmit(_In_ SCARDHANDLE, _In_ LPCSCARD_IO_REQUEST, + _In_reads_bytes_(commandBytesLength) LPCBYTE commandBytes, + _In_ DWORD commandBytesLength, _Inout_opt_ LPSCARD_IO_REQUEST, + _Out_writes_bytes_(*responseBytesLength) LPBYTE responseBytes, + _Inout_ LPDWORD responseBytesLength) +#else +LONG SCardTransmit(SCARDHANDLE, LPCSCARD_IO_REQUEST, LPCBYTE commandBytes, DWORD commandBytesLength, + LPSCARD_IO_REQUEST, LPBYTE responseBytes, LPDWORD responseBytesLength) +#endif +{ + PcscMock::callScardFunction(__FUNCTION__); + + if (!commandBytes || !responseBytes || commandBytesLength < 1 || *responseBytesLength < 1) + return SCARD_E_INVALID_PARAMETER; + + PcscMock::byte_vector command {commandBytes, commandBytes + commandBytesLength}; + PcscMock::byte_vector response = PcscMock::responseForApduCommand(command); + + DWORD responseLenght = DWORD(response.size()); + + if (*responseBytesLength < responseLenght) + return SCARD_E_INSUFFICIENT_BUFFER; + + auto returnValue = PcscMock::returnValueForScardFunctionCall(__FUNCTION__); + if (returnValue) { + return returnValue; + } + + *responseBytesLength = responseLenght; + + memcpy(responseBytes, response.data(), responseLenght); + + return SCARD_S_SUCCESS; +} + +#ifdef _MSC_VER +WINSCARDAPI LONG WINAPI SCardControl(_In_ SCARDHANDLE, _In_ DWORD, + _In_reads_bytes_(cbInBufferSize) LPCVOID, _In_ DWORD, + _Out_writes_bytes_(cbOutBufferSize) LPVOID, _In_ DWORD, + _Out_ LPDWORD bytesReturned) +#else +LONG SCardControl(SCARDHANDLE, DWORD, LPCVOID, DWORD, LPVOID, DWORD, LPDWORD bytesReturned) +#endif +{ + PcscMock::callScardFunction(__FUNCTION__); + *bytesReturned = 0; + return PcscMock::returnValueForScardFunctionCall(__FUNCTION__); +} + +#ifdef _MSC_VER +WINSCARDAPI LONG WINAPI SCardFreeMemory(_In_ SCARDCONTEXT, _In_ LPCVOID) +#else +LONG SCardFreeMemory(SCARDCONTEXT, LPCVOID) +#endif +{ + PcscMock::callScardFunction(__FUNCTION__); + return PcscMock::returnValueForScardFunctionCall(__FUNCTION__); +} diff --git a/lib/libpcsc-cpp/tests/lib/libpcsc-mock/tests/pcsc-mock-test.cpp b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/tests/pcsc-mock-test.cpp new file mode 100644 index 0000000..2e8b870 --- /dev/null +++ b/lib/libpcsc-cpp/tests/lib/libpcsc-mock/tests/pcsc-mock-test.cpp @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include + +#include "gtest/gtest.h" + +#ifdef __APPLE__ +#include +#include +#else +#include +#endif + +#include +#include + +TEST(scard_mock_test, testScardCalls) +{ + using namespace std; + + SCARDCONTEXT _context; + LONG rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, nullptr, nullptr, &_context); + EXPECT_FALSE(rv); + EXPECT_TRUE(PcscMock::wasScardFunctionCalled("SCardEstablishContext")); + + vector readerNames; + readerNames.resize(25); + DWORD readerNamesLen = DWORD(readerNames.size()); + rv = SCardListReaders(_context, nullptr, readerNames.data(), &readerNamesLen); + EXPECT_FALSE(rv); + EXPECT_TRUE(PcscMock::wasScardFunctionCalled("SCardListReaders")); + PcscMock::string_t readerName(readerNames.data()); + EXPECT_EQ(readerName, PcscMock::DEFAULT_READER_NAME); + + std::vector readerStates {{nullptr, + nullptr, + 0, + 0, + 0, + { + 0, + }}}; + rv = SCardGetStatusChange(_context, 0, readerStates.data(), DWORD(readerStates.size())); + EXPECT_FALSE(rv); + EXPECT_TRUE(PcscMock::wasScardFunctionCalled("SCardGetStatusChange")); + readerName = readerStates[0].szReader; + EXPECT_EQ(readerName, PcscMock::DEFAULT_READER_NAME); + + auto atrBuf = readerStates[0].rgbAtr; + vector atr(atrBuf, atrBuf + readerStates[0].cbAtr); + EXPECT_EQ(atr, PcscMock::DEFAULT_CARD_ATR); + + auto protocol = SCARD_PROTOCOL_T0; + DWORD protocolOut = SCARD_PROTOCOL_UNDEFINED; + SCARDHANDLE _card; + rv = SCardConnect(_context, nullptr, SCARD_SHARE_SHARED, protocol, &_card, &protocolOut); + EXPECT_FALSE(rv); + EXPECT_TRUE(PcscMock::wasScardFunctionCalled("SCardConnect")); + + rv = SCardBeginTransaction(_card); + EXPECT_FALSE(rv); + EXPECT_TRUE(PcscMock::wasScardFunctionCalled("SCardBeginTransaction")); + + auto commandBytes = PcscMock::byte_vector {2, 1, 3, 4}; + auto responseBytes = PcscMock::byte_vector(5, 0); + DWORD responseLength = DWORD(responseBytes.size()); + SCARD_IO_REQUEST _protocol; // = *SCARD_PCI_T0; <-- non-trivial + rv = SCardTransmit(_card, &_protocol, commandBytes.data(), DWORD(commandBytes.size()), nullptr, + responseBytes.data(), &responseLength); + EXPECT_FALSE(rv); + EXPECT_TRUE(PcscMock::wasScardFunctionCalled("SCardTransmit")); + + rv = SCardEndTransaction(_card, SCARD_LEAVE_CARD); + EXPECT_FALSE(rv); + EXPECT_TRUE(PcscMock::wasScardFunctionCalled("SCardEndTransaction")); + + rv = SCardDisconnect(_card, SCARD_LEAVE_CARD); + EXPECT_FALSE(rv); + EXPECT_TRUE(PcscMock::wasScardFunctionCalled("SCardDisconnect")); + + rv = SCardReleaseContext(_context); + EXPECT_FALSE(rv); + EXPECT_TRUE(PcscMock::wasScardFunctionCalled("SCardReleaseContext")); +} diff --git a/lib/libpcsc-cpp/tests/mock/test-connect-to-card-transmit-apdus.cpp b/lib/libpcsc-cpp/tests/mock/test-connect-to-card-transmit-apdus.cpp new file mode 100644 index 0000000..f11af1e --- /dev/null +++ b/lib/libpcsc-cpp/tests/mock/test-connect-to-card-transmit-apdus.cpp @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "pcsc-cpp/pcsc-cpp.hpp" + +#include "pcsc-mock/pcsc-mock.hpp" +#include "pcsc-cpp/comp_winscard.hpp" + +#include + +using namespace pcsc_cpp; + +namespace +{ + +SmartCard::ptr connectToCard() +{ + auto readers = listReaders(); + EXPECT_EQ(readers.size(), 1U); + + return readers[0].connectToCard(); +} + +} // namespace + +TEST(pcsc_cpp_test, connectToCardSuccess) +{ + auto card = connectToCard(); + + EXPECT_EQ(card->atr(), PcscMock::DEFAULT_CARD_ATR); + EXPECT_EQ(card->protocol(), SmartCard::Protocol::T1); +} + +TEST(pcsc_cpp_test, transmitApduSuccess) +{ + auto card = connectToCard(); + + auto command = CommandApdu::fromBytes(PcscMock::DEFAULT_COMMAND_APDU); + auto expectedResponse = ResponseApdu::fromBytes(PcscMock::DEFAULT_RESPONSE_APDU); + + auto transactionGuard = card->beginTransaction(); + auto response = card->transmit(command); + + EXPECT_EQ(response.toBytes(), expectedResponse.toBytes()); +} diff --git a/lib/libpcsc-cpp/tests/mock/test-select-card-reader-and-card.cpp b/lib/libpcsc-cpp/tests/mock/test-select-card-reader-and-card.cpp new file mode 100644 index 0000000..5a3c83a --- /dev/null +++ b/lib/libpcsc-cpp/tests/mock/test-select-card-reader-and-card.cpp @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2020-2023 Estonian Information System Authority + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "pcsc-cpp/pcsc-cpp.hpp" + +#include "pcsc-mock/pcsc-mock.hpp" +#include "pcsc-cpp/comp_winscard.hpp" + +#include + +TEST(pcsc_cpp_test, listReadersSuccess) +{ + using namespace pcsc_cpp; + + auto readers = listReaders(); + EXPECT_EQ(readers.size(), 1U); +#ifdef _WIN32 + EXPECT_EQ(readers[0].name, L"PcscMock-reader"); +#else + EXPECT_EQ(readers[0].name, "PcscMock-reader"); +#endif + EXPECT_EQ(readers[0].statusString(), "PRESENT"); +} + +TEST(pcsc_cpp_test, listReadersNoReaders) +{ + using namespace pcsc_cpp; + + PcscMock::addReturnValueForScardFunctionCall("SCardListReaders", SCARD_E_NO_READERS_AVAILABLE); + + auto readers = listReaders(); + EXPECT_EQ(readers.size(), 0U); + + PcscMock::reset(); +} + +TEST(pcsc_cpp_test, listReadersNoService) +{ + using namespace pcsc_cpp; + + PcscMock::addReturnValueForScardFunctionCall("SCardEstablishContext", SCARD_E_NO_SERVICE); + + EXPECT_THROW({ listReaders(); }, ScardServiceNotRunningError); + + PcscMock::reset(); +}