reinit

CMakeLists.txt

@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 2.8)
+
+# git current hash
+execute_process(COMMAND git log --pretty=format:%h -n 1
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        OUTPUT_VARIABLE GIT_SHA1)
+
+execute_process(COMMAND git symbolic-ref -q --short HEAD
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        OUTPUT_VARIABLE GIT_REF_NAME)
+if ("${GIT_REF_NAME}" EQUAL "")
+    execute_process(COMMAND git describe --tags --exact-match
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+            OUTPUT_VARIABLE GIT_REF_NAME)
+endif()
+string(STRIP "${GIT_REF_NAME}" GIT_REF_NAME)
+string(STRIP "${GIT_SHA1}" GIT_SHA1)
+add_definitions(-DGIT_SHA1=${GIT_SHA1} -DGIT_REF_NAME=${GIT_REF_NAME})
+
+
+set(PROJECT_NAME nfc_cpptools)
+project(${PROJECT_NAME})
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    message(STATUS "Debug build")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ggdb -g3")
+else()
+    message(STATUS "Release build")
+endif()
+
+add_subdirectory(libnfc_cpptools)
+add_subdirectory(cli)
+#add_subdirectory(gui)
+
+find_package(GTest)
+if (GTEST_FOUND)
+    enable_testing()
+    add_subdirectory(tests)
+endif (GTEST_FOUND)

README.md

@@ -0,0 +1,66 @@
+Mifare-Tools
+============
+
+Library and command line tools for Mifare classic 1K NFC tags.
+It can:
+- List NFC devices
+- List NFC tags
+- Read a Mifare Classic 1K tag
+- Write a Mifare Classic 1K tag
+
+Usage
+=====
+
+List devices:
+```shell
+nfc_cpptools-cli --devices
+```
+
+List tags:
+```shell
+nfc_cpptools-cli --tags
+```
+
+Read a tag with some command line keys:
+```shell
+nfc_cpptools-cli --read --key ffffffffffff --key a1a2a3a4a5a6
+```
+
+Read a tag with a key file and save dump to a file:
+```shell
+nfc_cpptools-cli --read --key-file ~/my_key_file --output ~/my_dump
+```
+
+Write a tag with a command line key, from stdin:
+```shell
+cat ~/my_dump | nfc_cpptools-cli --write --key-file ffffffffffff
+```
+
+Write a tag with a command line key, from a file:
+```shell
+nfc_cpptools-cli --write --key-file ffffffffffff --input ~/my_dump
+```
+
+Write a tag with a key file, from a file, on a specified device, on a specified tag:
+```shell
+nfc_cpptools-cli --write --key-file ffffffffffff --input ~/my_dump --device pn53x_usb:003:008 --tag a1a2a3
+```
+
+Build and Install
+=================
+Requirements
+------------
+Libnfc          https://github.com/nfc-tools/libnfc
+Libfreefare     https://github.com/nfc-tools/libfreefare
+
+Build and Install
+-----------------
+```shell
+git clone https://git.rthoni.com/robin.thoni/mifare-tools
+cd mifare-tools
+mkdir build
+cd build
+cmake ..
+make
+sudo make install
+```

cli/CMakeLists.txt

@@ -0,0 +1,20 @@
+include_directories(
+        .
+        ${LIBNFC_CPPTOOLS_INCLUDE_PATH}
+)
+
+set(SOURCE_FILES
+        main.cpp
+        cli/MainClass.cpp
+        cli/MainClass.h
+        cli/CommandLineParser.cpp
+        cli/CommandLineParser.h
+        DBO/CommandLineOption.cpp
+        DBO/CommandLineOption.h
+        )
+
+add_executable(${PROJECT_NAME}-cli ${SOURCE_FILES})
+target_link_libraries(${PROJECT_NAME}-cli ${PROJECT_NAME})
+
+install(TARGETS ${PROJECT_NAME}-cli
+        RUNTIME DESTINATION bin)

cli/DBO/CommandLineOption.cpp

@@ -0,0 +1,100 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#include "CommandLineOption.h"
+
+CommandLineOption::CommandLineOption(CommandLineParser* parser, const std::string &longName, char shortName,
+                                     const std::string &description, const std::string &valueName,
+                                     const std::string &defaultValue)
+    : _longName(longName)
+    , _shortName(shortName)
+    , _description(description)
+    , _valueName(valueName)
+    , _defaultValue(defaultValue)
+    , _isSet(false)
+{
+    parser->addOption(this);
+}
+
+const std::string &CommandLineOption::getLongName() const
+{
+    return _longName;
+}
+
+void CommandLineOption::setLongName(const std::string &longName)
+{
+    _longName = longName;
+}
+
+char CommandLineOption::getShortName() const
+{
+    return _shortName;
+}
+
+void CommandLineOption::setShortName(char shortName)
+{
+    _shortName = shortName;
+}
+
+const std::string &CommandLineOption::getDescription() const
+{
+    return _description;
+}
+
+void CommandLineOption::setDescription(const std::string &description)
+{
+    _description = description;
+}
+
+const std::string &CommandLineOption::getValueName() const
+{
+    return _valueName;
+}
+
+void CommandLineOption::setValueName(const std::string &valueName)
+{
+    _valueName = valueName;
+}
+
+const std::string &CommandLineOption::getDefaultValue() const
+{
+    return _defaultValue;
+}
+
+void CommandLineOption::setDefaultValue(const std::string &defaultValue)
+{
+    _defaultValue = defaultValue;
+}
+
+const std::vector<std::string> &CommandLineOption::getValues() const
+{
+    return _values;
+}
+
+void CommandLineOption::addValue(const std::string &value)
+{
+    _values.push_back(value);
+}
+
+bool CommandLineOption::isSet() const
+{
+    return _isSet;
+}
+
+void CommandLineOption::setIsSet(bool isSet)
+{
+    _isSet = isSet;
+}
+
+bool CommandLineOption::hasValue() const
+{
+    return !_valueName.empty();
+}
+
+const std::string &CommandLineOption::getValue() const
+{
+    if (_values.empty())
+        return _defaultValue;
+    return _values[_values.size() - 1];
+}

cli/DBO/CommandLineOption.h

@@ -0,0 +1,70 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#ifndef PDNS_SLAVE_COMMANDLINEOPTION_H
+#define PDNS_SLAVE_COMMANDLINEOPTION_H
+
+# include <string>
+# include <vector>
+#include <cli/CommandLineParser.h>
+
+class CommandLineParser;
+
+class CommandLineOption
+{
+public:
+    CommandLineOption(CommandLineParser* parser, const std::string& longName, char shortName,
+                      const std::string& description, const std::string& valueName = "",
+                      const std::string& defaultValue = "");
+
+    const std::string &getLongName() const;
+
+    void setLongName(const std::string &longName);
+
+    char getShortName() const;
+
+    void setShortName(char shortName);
+
+    const std::string &getDescription() const;
+
+    void setDescription(const std::string &description);
+
+    const std::string &getValueName() const;
+
+    void setValueName(const std::string &valueName);
+
+    const std::string &getDefaultValue() const;
+
+    void setDefaultValue(const std::string &defaultValue);
+
+    const std::vector<std::string> &getValues() const;
+
+    const std::string &getValue() const;
+
+    void addValue(const std::string &value);
+
+    bool isSet() const;
+
+    void setIsSet(bool isSet);
+
+    bool hasValue() const;
+
+private:
+    std::string _longName;
+
+    char _shortName;
+
+    std::string _description;
+
+    std::string _valueName;
+
+    std::string _defaultValue;
+
+    std::vector<std::string> _values;
+
+    bool _isSet;
+};
+
+
+#endif //PDNS_SLAVE_COMMANDLINEOPTION_H

cli/cli/CommandLineParser.cpp

@@ -0,0 +1,98 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#include <getopt.h>
+#include <iostream>
+#include "CommandLineParser.h"
+
+CommandLineParser::CommandLineParser(int argc, char **argv)
+    : _argc(argc)
+    , _argv(argv)
+{
+}
+
+bool CommandLineParser::parse()
+{
+    std::string shortOpts;
+    option opts[_options.size() + 1];
+    for (unsigned i = 0; i < _options.size(); ++i)
+    {
+        auto opt = _options[i];
+        shortOpts += opt->getShortName();
+        if (opt->hasValue())
+            shortOpts += ":";
+        opts[i].name = opt->getLongName().c_str();
+        opts[i].has_arg = opt->hasValue();
+        opts[i].flag = 0;
+        opts[i].val = opt->getShortName();
+    }
+    opts[_options.size()] = {0, 0, 0, 0};
+    int option;
+    extern int optind;
+    extern char* optarg;
+    bool valid = true;
+    while ((option = getopt_long(_argc, _argv, shortOpts.c_str(), opts, 0)) != -1)
+    {
+        bool optValid = false;
+        for (unsigned i = 0; i < _options.size(); ++i)
+        {
+            auto opt = _options[i];
+            if (opt->getShortName() == option)
+            {
+                optValid = true;
+                opt->setIsSet(true);
+                if (opt->hasValue())
+                    opt->addValue(optarg);
+            }
+        }
+        if (!optValid)
+            valid = false;
+    }
+    return optind == _argc && valid;
+}
+
+void CommandLineParser::addOption(CommandLineOption* opt)
+{
+    _options.push_back(opt);
+}
+
+int CommandLineParser::showHelp(int status, bool stdErr)
+{
+    auto& out = stdErr ? std::cerr : std::cout;
+    int longestName = 0;
+    int longestValue = 0;
+    for (auto opt : _options) {
+        if (opt->getLongName().length() > longestName) {
+            longestName = opt->getLongName().length();
+        }
+        std::string value = "<" + opt->getValueName();
+        if (!opt->getDefaultValue().empty()) {
+            value += "=" + opt->getDefaultValue();
+        }
+        value += ">";
+        if (value.length() > longestValue) {
+            longestValue = value.length();
+        }
+    }
+    out << "Options:" << std::endl;
+    for (auto opt : _options)
+    {
+        out << "  -" << opt->getShortName() << ", --" << opt->getLongName();
+        out << std::string(longestName - opt->getLongName().length() + 2, ' ');
+        if (opt->hasValue())
+        {
+            std::string value = "<" + opt->getValueName();
+            if (!opt->getDefaultValue().empty()) {
+                value += "=" + opt->getDefaultValue();
+            }
+            value += ">";
+            out << value << std::string(longestValue - value.length() + 2, ' ');
+        }
+        else {
+            out << std::string(longestValue + 2, ' ');
+        }
+        out << opt->getDescription() << std::endl;
+    }
+    return status;
+}

cli/cli/CommandLineParser.h

@@ -0,0 +1,32 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#ifndef PDNS_SLAVE_COMMANDLINEPARSER_H
+#define PDNS_SLAVE_COMMANDLINEPARSER_H
+
+# include "../DBO/CommandLineOption.h"
+
+class CommandLineOption;
+
+class CommandLineParser
+{
+public:
+    CommandLineParser(int argc, char** argv);
+
+    bool parse();
+
+    int showHelp(int status = 0, bool stdErr = true);
+
+    void addOption(CommandLineOption* opt);
+
+private:
+    int _argc;
+
+    char** _argv;
+
+    std::vector<CommandLineOption*> _options;
+};
+
+
+#endif //PDNS_SLAVE_COMMANDLINEPARSER_H

cli/cli/MainClass.cpp

@@ -0,0 +1,452 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#include <iostream>
+#include <sysexits.h>
+#include <iomanip>
+#include <fstream>
+#include <libnfc_cpptools/StringUtils.h>
+#include <libnfc_cpptools/FreeFareDevice.h>
+#include <libnfc_cpptools/Result.h>
+#include <libnfc_cpptools/LibNfc.h>
+#include "CommandLineParser.h"
+#include "MainClass.h"
+
+#define EX_OUTPUT_ERROR 1
+#define EX_INPUT_ERROR 2
+#define EX_KEY_ERROR 10
+#define EX_LIB_NFC_ERROR 12
+#define EX_NFC_DEVICE_NOT_FOUND 13
+#define EX_NFC_TAG_NOT_FOUND 14
+#define EX_MAP_KEYS_ERROR 15
+#define EX_READ_ERROR 16
+#define EX_WRITE_ERROR 17
+
+MainClass::MainClass(int argc, char *argv[])
+    : _argc(argc)
+    , _argv(argv)
+{
+}
+
+int MainClass::main()
+{
+    CommandLineParser parser(_argc, _argv);
+    CommandLineOption optionVersion(&parser, "version", 'v', "Show libnfc and mifare-tools versions");
+    CommandLineOption optionHelp(&parser, "help", 'h', "Show this help");
+
+    CommandLineOption optionMap(&parser, "map", 'm', "Map keys for the tag");
+    CommandLineOption optionRead(&parser, "read", 'r', "Read the tag");
+    CommandLineOption optionWrite(&parser, "write", 'w', "Write the tag");
+    CommandLineOption optionDevices(&parser, "devices", 'd', "List NFC devices");
+    CommandLineOption optionTags(&parser, "tags", 't', "List NFC tags");
+
+    CommandLineOption optionDevice(&parser, "device", 'e', "Use the device DEVICE", "DEVICE");
+    CommandLineOption optionTag(&parser, "tag", 'u', "Use the UID tag", "UID");
+
+    CommandLineOption optionKeyFile(&parser, "key-file", 'f', "Path to a file containing keys", "FILE");
+    CommandLineOption optionKey(&parser, "key", 'k', "Key to use to authenticate", "KEY");
+
+    CommandLineOption optionOutput(&parser, "output", 'o', "Redirect output to FILE. '-' to use stdout", "FILE", "-");
+    CommandLineOption optionInput(&parser, "input", 'i', "Read input from FILE. '-' to use stdin", "FILE", "-");
+
+    if (!parser.parse()) {
+        return parser.showHelp(EX_USAGE);
+    }
+    std::string outputFile = optionOutput.getDefaultValue();
+    if (optionOutput.isSet()) {
+        outputFile = optionOutput.getValue();
+    }
+
+    if (outputFile != "-" && !outputFile.empty()) {
+        std::shared_ptr<std::ofstream> fileCout = std::make_shared<std::ofstream>();
+        fileCout->open(outputFile);
+        if (!*fileCout) {
+            std::cerr << "Failed to redirect output: " << strerror(errno) << std::endl;
+            return EX_OUTPUT_ERROR;
+        }
+        _outputStream = fileCout;
+    }
+
+    std::string inputFile = optionInput.getDefaultValue();
+    if (optionInput.isSet()) {
+        inputFile = optionInput.getValue();
+    }
+    if (inputFile != "-" && !inputFile.empty()) {
+        std::shared_ptr<std::ifstream> fileCin = std::make_shared<std::ifstream>();
+        fileCin->open(inputFile);
+        if (!*fileCin) {
+            std::cerr << "Failed to open input file: " << strerror(errno) << std::endl;
+            return EX_INPUT_ERROR;
+        }
+        _inputStream = fileCin;
+    }
+
+    if (optionVersion.isSet()) {
+        printVersion();
+        return EX_OK;
+    }
+    if (optionHelp.isSet()) {
+        return parser.showHelp(EX_OK, false);
+    }
+
+    std::string deviceName = optionDevice.getDefaultValue();
+    if (optionDevice.isSet()) {
+        deviceName = optionDevice.getValue();
+    }
+
+    std::string tagUid = optionTag.getDefaultValue();
+    if (optionTag.isSet()) {
+        tagUid = optionTag.getValue();
+    }
+
+    std::vector<std::string> keys;
+    if (optionKeyFile.isSet()) {
+        for (auto filePath : optionKeyFile.getValues()) {
+            auto keysResult = readFile(filePath);
+            if (!keysResult) {
+                keysResult.print();
+                return EX_KEY_ERROR;
+            }
+            auto fileKeys = keysResult.getData();
+            keys.insert(keys.end(), fileKeys.begin(), fileKeys.end());
+        }
+    }
+    if (optionKey.isSet()) {
+        for (auto key : optionKey.getValues()) {
+            auto keyResult = LibNfc::Utils::StringUtils::humanToRaw(key);
+            key = keyResult.getData();
+            if (!keyResult || key.length() != 6) {
+                std::cerr << "Invalid key" << std::endl;
+                return EX_KEY_ERROR;
+            }
+            keys.push_back(key);
+        }
+    }
+
+    std::string inputData = "";
+
+    int res = EX_OK;
+    Actions action;
+    if (optionRead.isSet()) {
+        action = Read;
+    }
+    else if (optionMap.isSet()) {
+        action = Map;
+    }
+    else if (optionWrite.isSet()) {
+        auto readResult = readStream(cin());
+        if (!readResult) {
+            readResult.print();
+            return EX_INPUT_ERROR;
+        }
+        for (auto data : readResult.getData()) {
+            inputData += data;
+        }
+        action = Write;
+    }
+    else if (optionDevices.isSet()) {
+        action = Devices;
+    }
+    else if (optionTags.isSet()) {
+        action = Tags;
+    }
+    else {
+        std::cerr << "Must select an action (map|read|write|devices|tags)" << std::endl;
+        return EX_USAGE;
+    }
+
+    LibNfc::Core::LibNfcContext libNfc;
+    auto init = libNfc.init();
+    if (!init) {
+        init.print();
+        res = EX_LIB_NFC_ERROR;
+    }
+    else
+    {
+        auto devicesResult = libNfc.getDevices();
+        if (!devicesResult)
+        {
+            devicesResult.print();
+            res = EX_LIB_NFC_ERROR;
+        }
+        else
+        {
+            auto devices = devicesResult.getData();
+
+            if (action == Devices)
+            {
+                for (auto device : devices) {
+                    cout() << device->getConnStr() << std::endl;
+                }
+            }
+            else
+            {
+                auto device = getDevice(deviceName, devices);
+                if (device == 0)
+                {
+                    std::cerr << "NFC device not found" << std::endl;
+                    res = EX_NFC_DEVICE_NOT_FOUND;
+                }
+                else {
+                    auto open = device->open();
+                    if (!open) {
+                        open.print();
+                        res = EX_LIB_NFC_ERROR;
+                    }
+                    else {
+
+                        LibNfc::FreeFare::FreeFareDevice freeFareDevice(device);
+                        auto tagsResult = freeFareDevice.getTags();
+                        if (!tagsResult) {
+                            tagsResult.print();
+                            res = EX_LIB_NFC_ERROR;
+                        }
+
+                        auto tags = tagsResult.getData();
+
+                        if (action == Tags) {
+                            for (auto tag : tags) {
+                                cout() << "UID=" << tag->getUid() << " \tType="
+                                       << LibNfc::FreeFare::FreeFareTag::getTagTypeString(tag->getType()) << std::endl;
+                            }
+                        }
+                        else {
+                            auto tag = getTag(tagUid, tags);
+                            if (tag == 0) {
+                                std::cerr << "Tag not found" << std::endl;
+                                res = EX_NFC_TAG_NOT_FOUND;
+                            }
+                            else {
+                                if (action == Read) {
+                                    res = read(tag, keys);
+                                }
+                                else if (action == Map) {
+                                    res = mapKeys(tag, keys);
+                                }
+                                else if (action == Write) {
+                                    res = write(tag, keys, inputData);
+                                }
+                            }
+                        }
+                    }
+                    device->close();
+                }
+            }
+        }
+        libNfc.clean();
+    }
+
+    if (_outputStream != 0) {
+        _outputStream->close();
+    }
+    if (_inputStream != 0) {
+        _inputStream->close();
+    }
+    return res;
+}
+
+int MainClass::mapKeys(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys)
+{
+    auto mappedKeysResult = tag->mapKeys(keys, printPercentMapKeys);
+    if (!mappedKeysResult) {
+        mappedKeysResult.print();
+        return EX_MAP_KEYS_ERROR;
+    }
+    else {
+        auto mappedKeys = mappedKeysResult.getData();
+        for (int s = 0; s < mappedKeys.size(); ++s) {
+            auto sectorKey = mappedKeys[s];
+            cout() << "+Sector: " << s << std::endl;
+            for (int b = 0; b < 4; ++b) {
+                cout() << "+Block: " << b << std::endl;
+                cout() << "+Key: A" << std::endl << (!sectorKey.first.empty() ? LibNfc::Utils::StringUtils::rawToHuman(sectorKey.first) : std::string(12, '-')) << std::endl;
+                cout() << "+Key: B" << std::endl << (!sectorKey.second.empty() ? LibNfc::Utils::StringUtils::rawToHuman(sectorKey.second) : std::string(12, '-')) << std::endl;
+            }
+        }
+    }
+    return EX_OK;
+}
+
+int MainClass::read(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys)
+{
+    auto readResult = tag->read(keys, printPercentMapKeys, printPercentDump);
+    if (!readResult) {
+        readResult.print();
+        return EX_READ_ERROR;
+    }
+    auto read = readResult.getData();
+    printSectors(read);
+    return EX_OK;
+}
+
+int MainClass::write(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys, const std::string &data)
+{
+    auto writeResult = tag->write(keys, data, false, printPercentMapKeys, printPercentWrite);
+    if (!writeResult) {
+        writeResult.print();
+        return EX_WRITE_ERROR;
+    }
+//    std::vector<LibNfc::FreeFare::FreeFareSector> sectors;
+//    std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 1024);
+//    for (int i = 0; i < 16; ++i) {
+//        LibNfc::FreeFare::FreeFareSector LibNfc::FreeFare::FreeFareSector(d.substr(i * 64, 64));
+//        sectors.push_back(LibNfc::FreeFare::FreeFareSector);
+//    }
+//    printSectors(sectors);
+    return EX_OK;
+}
+
+void MainClass::printSectors(const std::vector<LibNfc::FreeFare::FreeFareSector> &sectors)
+{
+    for(int s = 0; s < sectors.size(); ++s) {
+        cout() << "+Sector: " << s << std::endl;
+        auto sector = sectors[s];
+        for (int b = 0; b < 3; ++b) {
+            cout() << (sector.hasBlock(b) ? LibNfc::Utils::StringUtils::rawToHuman(sector.getBlock(b)) : std::string(32, '-')) << std::endl;
+        }
+        cout() << (sector.hasKeyA() ? LibNfc::Utils::StringUtils::rawToHuman(sector.getKeyA()) : std::string(12, '-'))
+        << (sector.hasAccessBits() ? LibNfc::Utils::StringUtils::rawToHuman(sector.getAccessBits()) : std::string(8, '-'))
+        << (sector.hasKeyB() ? LibNfc::Utils::StringUtils::rawToHuman(sector.getKeyB()) : std::string(12, '-')) << std::endl;
+
+
+        cout() << "+Trailer key A: " << (sector.hasKeyA() ? LibNfc::Utils::StringUtils::rawToHuman(sector.getKeyA()) : std::string(12, '-'))
+        << "\t AC bits: " << (sector.hasAccessBits() ? LibNfc::Utils::StringUtils::rawToHuman(sector.getAccessBits()) : std::string(8, '-'))
+        << "\t key B: " << (sector.hasKeyB() ? LibNfc::Utils::StringUtils::rawToHuman(sector.getKeyB()) : std::string(12, '-')) << std::endl;
+        LibNfc::FreeFare::FreeFareAccessBits accessBitsDbo = sector.getAccessBitsDbo();
+        for (int b = 0; b < 3; ++b) {
+            cout() << "+Block: " << b << " ";
+            printBlockAccessBits(accessBitsDbo, b);
+        }
+        cout() << "+Block: 3 ";
+        printTrailerAccessBits(accessBitsDbo);
+    }
+}
+
+void MainClass::printBlockAccessBits(const LibNfc::FreeFare::FreeFareAccessBits &accessBits, int block)
+{
+    cout() << "read: " << (accessBits.canKeyAReadBlock(block) ? "A" : " ") << (accessBits.canKeyBReadBlock(block) ? "B" : " ");
+    cout() << "\t write: " << (accessBits.canKeyAWriteBlock(block) ? "A" : " ") << (accessBits.canKeyBWriteBlock(block) ? "B" : " ");
+    cout() << "\t increment: " << (accessBits.canKeyAIncrementBlock(block) ? "A" : " ") << (accessBits.canKeyBIncrementBlock(block) ? "B" : " ");
+    cout() << "\t decrement: " << (accessBits.canKeyADecrementBlock(block) ? "A" : " ") << (accessBits.canKeyBDecrementBlock(block) ? "B" : " ") << std::endl;
+}
+
+void MainClass::printTrailerAccessBits(const LibNfc::FreeFare::FreeFareAccessBits &accessBits)
+{
+    cout() << "key A read: " << (accessBits.canKeyAReadKeyATrailer() ? "A" : " ") << (accessBits.canKeyBReadKeyATrailer() ? "B" : " ");
+    cout() << "\t key A write: " << (accessBits.canKeyAWriteKeyATrailer() ? "A" : " ") << (accessBits.canKeyBWriteKeyATrailer() ? "B" : " ");
+
+    cout() << "\t AC bits read: " << (accessBits.canKeyAReadAccessBitsTrailer() ? "A" : " ") << (accessBits.canKeyBReadAccessBitsTrailer() ? "B" : " ");
+    cout() << "\t AC bits write: " << (accessBits.canKeyAWriteAccessBitsTrailer() ? "A" : " ") << (accessBits.canKeyBWriteAccessBitsTrailer() ? "B" : " ");
+
+    cout() << "\t key B read: " << (accessBits.canKeyAReadKeyBTrailer() ? "A" : " ") << (accessBits.canKeyBReadKeyBTrailer() ? "B" : " ");
+    cout() << "\t key B write: " << (accessBits.canKeyAWriteKeyBTrailer() ? "A" : " ") << (accessBits.canKeyBWriteKeyBTrailer() ? "B" : " ") << std::endl;;
+}
+
+void MainClass::printPercent(int done, int total, const std::string& header)
+{
+    if (isatty(fileno(stdout))) {
+        std::cout << "\r\033[2K" << header << ": " << std::fixed << std::setprecision(1)
+        << ((float) done / (float) total * 100.0) << "%" << std::flush;
+        if (done == total) {
+            std::cout << std::endl;
+        }
+    }
+}
+
+void MainClass::printPercentMapKeys(int done, int total)
+{
+    printPercent(done, total, "Mapping keys");
+}
+
+void MainClass::printPercentDump(int done, int total)
+{
+    printPercent(done, total, "Dumping");
+}
+
+void MainClass::printPercentWrite(int done, int total)
+{
+    printPercent(done, total, "Writing");
+}
+
+void MainClass::printVersion()
+{
+    cout() << "LibNfc version: " << LibNfc::Core::LibNfcContext::getLibNfcVersion() << std::endl;
+    cout() << "Mifare-tools version: " << LibNfc::Core::LibNfcContext::getMifareToolsVersion() << std::endl;
+}
+
+std::shared_ptr<LibNfc::Core::NfcDevice> MainClass::getDevice(const std::string &deviceName, std::vector<std::shared_ptr<LibNfc::Core::NfcDevice>> devices)
+{
+    if (deviceName.empty()) {
+        if (devices.size() > 0) {
+            return devices[0];
+        }
+    }
+    else {
+        for (auto d : devices) {
+            if (d->getConnStr() == deviceName) {
+                return d;
+            }
+        }
+    }
+    return 0;
+}
+
+std::shared_ptr<LibNfc::FreeFare::FreeFareTag> MainClass::getTag(const std::string &tagUid,
+                                                       std::vector<std::shared_ptr<LibNfc::FreeFare::FreeFareTag>> tags)
+{
+    if (tagUid.empty()) {
+        if (tags.size() > 0) {
+            return tags[0];
+        }
+    }
+    else {
+        for (auto t : tags) {
+            if (t->getUid() == tagUid) {
+                return t;
+            }
+        }
+    }
+    return 0;
+}
+
+LibNfc::Utils::Result<std::vector<std::string>> MainClass::readFile(const std::string &filePath)
+{
+    std::ifstream fileInput(filePath);
+    if (fileInput) {
+        return readStream(fileInput);
+    }
+    else {
+        return LibNfc::Utils::Result<std::vector<std::string>>::error("Failed to open file: " + std::string(strerror(errno)));
+    }
+}
+
+LibNfc::Utils::Result<std::vector<std::string>> MainClass::readStream(std::istream &stream)
+{
+    std::vector<std::string> lines;
+    while (!stream.eof()) {
+        std::string line;
+        std::getline(stream, line);
+        line = LibNfc::Utils::StringUtils::removeSpaces(line);
+        if (line.compare(0, 1, "#") != 0 && line.compare(0, 1, "+") != 0) {
+            std::replace(line.begin(), line.end(), '-', '0');
+            auto keyResult = LibNfc::Utils::StringUtils::humanToRaw(line);
+            if (!keyResult) {
+                return LibNfc::Utils::Result<std::vector<std::string>>::error("Invalid data");
+            }
+            line = keyResult.getData();
+            lines.push_back(line);
+        }
+    }
+    return LibNfc::Utils::Result<std::vector<std::string>>::ok(lines);
+}
+
+std::ostream &MainClass::cout()
+{
+    return _outputStream == 0 ? std::cout : *_outputStream;
+}
+
+std::istream &MainClass::cin()
+{
+    return _inputStream == 0 ? std::cin : *_inputStream;
+}

cli/cli/MainClass.h

@@ -0,0 +1,72 @@
+//
+// Created by robin on 8/8/15.
+//
+
+#ifndef PDNS_SLAVE_MAINCLASS_H
+#define PDNS_SLAVE_MAINCLASS_H
+
+#include <memory>
+#include <libnfc_cpptools/FreeFareTag.h>
+#include <libnfc_cpptools/NfcDevice.h>
+
+class MainClass {
+public:
+    enum Actions {
+        Read,
+        Write,
+        Map,
+        Devices,
+        Tags
+    };
+
+    MainClass(int argc, char* argv[]);
+
+    int main();
+
+    std::shared_ptr<LibNfc::Core::NfcDevice> getDevice(const std::string& deviceName, std::vector<std::shared_ptr<LibNfc::Core::NfcDevice>> devices);
+
+    std::shared_ptr<LibNfc::FreeFare::FreeFareTag> getTag(const std::string& tagUid, std::vector<std::shared_ptr<LibNfc::FreeFare::FreeFareTag>> tags);
+
+    int mapKeys(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys);
+
+    int read(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys);
+
+    int write(std::shared_ptr<LibNfc::FreeFare::FreeFareTag> tag, std::vector<std::string> keys, const std::string& data);
+
+    LibNfc::Utils::Result<std::vector<std::string>> readFile(const std::string& filePath);
+
+    LibNfc::Utils::Result<std::vector<std::string>> readStream(std::istream& stream);
+
+    void printSectors(const std::vector<LibNfc::FreeFare::FreeFareSector>& sectors);
+
+    void printBlockAccessBits(const LibNfc::FreeFare::FreeFareAccessBits& accessBits, int block);
+
+    void printTrailerAccessBits(const LibNfc::FreeFare::FreeFareAccessBits& accessBits);
+
+    void printVersion();
+
+    std::ostream& cout();
+
+    std::istream& cin();
+
+    static void printPercent(int done, int total, const std::string& header);
+
+    static void printPercentMapKeys(int done, int total);
+
+    static void printPercentDump(int done, int total);
+
+    static void printPercentWrite(int done, int total);
+
+private:
+    int _argc;
+
+    char** _argv;
+
+    std::shared_ptr<std::ofstream> _outputStream;
+
+    std::shared_ptr<std::ifstream> _inputStream;
+
+};
+
+
+#endif //PDNS_SLAVE_MAINCLASS_H

cli/main.cpp

@@ -0,0 +1,7 @@
+#include "cli/MainClass.h"
+
+int main(int argc, char* argv[])
+{
+    MainClass m(argc, argv);
+    return m.main();
+}

gui/CMakeLists.txt

@@ -0,0 +1,31 @@
+include_directories(.)
+include_directories(. ../libnfc_cpptools)
+
+# Find includes in corresponding build directories
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+# Instruct CMake to run moc automatically when needed.
+set(CMAKE_AUTOMOC ON)
+
+# Find the QtWidgets library
+find_package(Qt5Widgets)
+
+qt5_wrap_ui(UI_HEADERS UI/MainWindow.ui)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -ggdb -g3 ${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}")
+
+# Tell CMake to create the helloworld executable
+add_executable(${PROJECT_NAME}-gui
+        main.cpp
+        UI/MainWindow.cpp
+        UI/MainWindow.h
+        ${UI_HEADERS}
+        Core/LibNfcOperation.cpp
+        Core/LibNfcOperation.hxx
+        Core/LibNfcOperation.h
+        )
+
+# Use the Widgets module from Qt 5.
+target_link_libraries(${PROJECT_NAME}-gui Qt5::Widgets ${PROJECT_NAME})
+
+install(TARGETS ${PROJECT_NAME}-gui
+        RUNTIME DESTINATION bin)

gui/Core/LibNfcOperation.cpp

@@ -0,0 +1,17 @@
+//
+// Created by robin on 10/1/17.
+//
+
+#include "LibNfcOperation.h"
+
+LibNfcOperation::LibNfcOperation(QSharedPointer<LibNfcBusiness>& libNfc,
+                                 std::function<void(QSharedPointer<LibNfcBusiness>)> operation)
+        : m_pLibNfc(libNfc)
+        , m_operation(operation)
+{
+}
+
+void LibNfcOperation::run()
+{
+    m_operation(m_pLibNfc);
+}

gui/Core/LibNfcOperation.h

@@ -0,0 +1,38 @@
+//
+// Created by robin on 10/1/17.
+//
+
+#ifndef MIFARE_TOOLS_LIBNFCOPERATION_H
+#define MIFARE_TOOLS_LIBNFCOPERATION_H
+
+
+#include <QtCore/QThread>
+#include <QtCore/QSharedPointer>
+
+#include <Business/LibNfcBusiness.h>
+
+class LibNfcOperation : public QThread
+{
+    Q_OBJECT
+public:
+    template<typename T>
+    static void runOperation(QSharedPointer<LibNfcBusiness> libNfc,
+                    std::function<Result<T>(QSharedPointer<LibNfcBusiness>)> operation,
+                    std::function<void(Result<T>)> callback);
+
+protected:
+    void run() override;
+
+//signals:
+//    void operationFinished(Result<T> result);
+
+private:
+    explicit LibNfcOperation(QSharedPointer<LibNfcBusiness>& libNfc,
+                             std::function<void(QSharedPointer<LibNfcBusiness>)> operation);
+
+    QSharedPointer<LibNfcBusiness> m_pLibNfc;
+
+    std::function<void(QSharedPointer<LibNfcBusiness>)> m_operation;
+};
+
+#endif //MIFARE_TOOLS_LIBNFCOPERATION_H

gui/Core/LibNfcOperation.hxx

@@ -0,0 +1,30 @@
+//
+// Created by robin on 10/1/17.
+//
+
+#ifndef MIFARE_TOOLS_LIBNFCOPERATION_HXX
+#define MIFARE_TOOLS_LIBNFCOPERATION_HXX
+
+#include "LibNfcOperation.h"
+
+template<typename T>
+void LibNfcOperation::runOperation(QSharedPointer<LibNfcBusiness> libNfc,
+                          std::function<Result<T>(QSharedPointer<LibNfcBusiness>)> operation,
+                          std::function<void(Result<T>)> callback)
+{
+    Result<T>* result = new Result<T>();
+    auto nfcOperation = new LibNfcOperation(libNfc, [result, operation](QSharedPointer<LibNfcBusiness> libNfc)
+    {
+        auto res = operation(libNfc);
+        *result = res;
+    });
+    connect(nfcOperation, &LibNfcOperation::finished, [result, nfcOperation, callback]()
+    {
+        nfcOperation->deleteLater();
+        callback(*result);
+        delete result;
+    });
+    nfcOperation->start();
+}
+
+#endif //MIFARE_TOOLS_LIBNFCOPERATION_HXX

gui/UI/MainWindow.cpp

@@ -0,0 +1,66 @@
+//
+// Created by robin on 10/1/17.
+//
+
+#include "MainWindow.h"
+#include <QMessageBox>
+#include <Core/LibNfcOperation.hxx>
+
+MainWindow::MainWindow(QWidget *parent)
+        : QMainWindow(parent)
+        , m_pUi(new Ui_MainWindow())
+{
+    m_pUi->setupUi(this);
+
+    refreshReaders();
+}
+
+bool MainWindow::initLibNfc()
+{
+    if (!m_pLibNfc) {
+        m_pLibNfc.reset(new LibNfcBusiness());
+        auto initResult = m_pLibNfc->init();
+        if (!initResult) {
+            showError(initResult);
+            return false;
+        }
+    }
+    return true;
+}
+
+void MainWindow::refreshReaders()
+{
+    if (!initLibNfc()) {
+        return;
+    }
+    m_pUi->pComboReaders->clear();
+
+    LibNfcOperation::runOperation<std::vector<std::shared_ptr<NfcDeviceBusiness>>>(m_pLibNfc, [](QSharedPointer<LibNfcBusiness> libNfc)
+                         {
+                             return (Result<std::vector<std::shared_ptr<NfcDeviceBusiness>>>) libNfc->getDevices();
+                         }, [this](Result<std::vector<std::shared_ptr<NfcDeviceBusiness>>> devicesResult)
+    {
+        m_devices = devicesResult.getData();
+        for (auto& device : m_devices) {
+            m_pUi->pComboReaders->addItem(device->getConnStr().c_str());
+        }
+    });
+
+//    auto devicesResult = m_pLibNfc->getDevices();
+//    if (!devicesResult) {
+//        showError(devicesResult);
+//        return;
+//    }
+//
+//    m_devices = devicesResult.getData();
+//    for (auto& device : m_devices) {
+//        m_pUi->pComboReaders->addItem(device->getConnStr().c_str());
+//    }
+}
+
+template<typename T>
+void MainWindow::showError(Result<T> result)
+{
+    result.print();
+    QMessageBox::critical(this, "LibNfc Error", QString("LibNfc error: %1").arg(result.getError().c_str()));
+}

gui/UI/MainWindow.h

@@ -0,0 +1,36 @@
+//
+// Created by robin on 10/1/17.
+//
+
+#ifndef MIFARE_TOOLS_MAINWINDOW_H
+#define MIFARE_TOOLS_MAINWINDOW_H
+
+
+#include <QtWidgets/QMainWindow>
+#include <Business/LibNfcBusiness.h>
+
+#include "ui_MainWindow.h"
+
+class MainWindow : public QMainWindow
+{
+Q_OBJECT
+public:
+    explicit MainWindow(QWidget* parent = nullptr);
+    ~MainWindow() override = default;
+
+    bool initLibNfc();
+
+    void refreshReaders();
+
+    template<typename T> void showError(Result<T> result);
+
+private:
+    QScopedPointer<Ui_MainWindow> m_pUi;
+
+    QSharedPointer<LibNfcBusiness> m_pLibNfc;
+
+    std::vector<std::shared_ptr<NfcDeviceBusiness>> m_devices;
+};
+
+
+#endif //MIFARE_TOOLS_MAINWINDOW_H

gui/UI/MainWindow.ui

@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>800</width>
+    <height>600</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <layout class="QVBoxLayout" name="verticalLayout">
+    <item>
+     <widget class="QWidget" name="widget" native="true">
+      <layout class="QHBoxLayout" name="horizontalLayout">
+       <item>
+        <widget class="QLabel" name="pLblReaders">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+         <property name="text">
+          <string>Reader:</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QComboBox" name="pComboReaders">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QPushButton" name="pBtnReadersRefresh">
+         <property name="text">
+          <string>Refresh</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QPushButton" name="pBtnReadersConnect">
+         <property name="text">
+          <string>Connect</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <spacer name="horizontalSpacer">
+         <property name="orientation">
+          <enum>Qt::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>40</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </widget>
+    </item>
+    <item>
+     <widget class="QTabWidget" name="tabWidget">
+      <property name="currentIndex">
+       <number>0</number>
+      </property>
+      <widget class="QWidget" name="tab">
+       <attribute name="title">
+        <string>Visual</string>
+       </attribute>
+      </widget>
+      <widget class="QWidget" name="tab_2">
+       <attribute name="title">
+        <string>Raw</string>
+       </attribute>
+      </widget>
+     </widget>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>800</width>
+     <height>24</height>
+    </rect>
+   </property>
+   <widget class="QMenu" name="menuFile">
+    <property name="title">
+     <string>File</string>
+    </property>
+    <addaction name="actionOpen"/>
+   </widget>
+   <addaction name="menuFile"/>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+  <action name="actionOpen">
+   <property name="text">
+    <string>Open</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+O</string>
+   </property>
+  </action>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

gui/main.cpp

@@ -0,0 +1,17 @@
+//
+// Created by robin on 10/1/17.
+//
+
+#include <QApplication>
+#include <UI/MainWindow.h>
+
+int main(int argc, char* argv[])
+{
+    QApplication app(argc, argv);
+
+    MainWindow mainWindow;
+
+    mainWindow.show();
+
+    return app.exec();
+}

libnfc_cpptools/CMakeLists.txt

@@ -0,0 +1,45 @@
+include_directories(
+        src/freefare
+        src/libnfc
+        src/utils
+        inc
+)
+
+set(SOURCE_FILES
+        inc/libnfc_cpptools/Result.h
+        src/libnfc/LibNfcInternal.cpp
+        src/libnfc/LibNfcInternal.h
+        src/libnfc/NfcDeviceInternal.cpp
+        src/libnfc/NfcDeviceInternal.h
+        src/freefare/FreeFareDeviceInternal.cpp
+        src/freefare/FreeFareDeviceInternal.h
+        src/freefare/FreeFareTagInternal.cpp
+        src/freefare/FreeFareTagInternal.h
+        src/utils/StringUtils.cpp
+        inc/libnfc_cpptools/StringUtils.h
+        src/freefare/FreeFareAccessBits.cpp
+        inc/libnfc_cpptools/FreeFareAccessBits.h
+        src/libnfc/LibNfc.cpp
+        inc/libnfc_cpptools/LibNfc.h
+        src/libnfc/NfcDevice.cpp
+        inc/libnfc_cpptools/NfcDevice.h
+        src/freefare/FreeFareDevice.cpp
+        inc/libnfc_cpptools/FreeFareDevice.h
+        src/freefare/FreeFareTag.cpp
+        inc/libnfc_cpptools/FreeFareTag.h
+        src/freefare/FreeFareSector.cpp
+        inc/libnfc_cpptools/FreeFareSector.h
+        src/utils/ArrayUtils.cpp
+        inc/libnfc_cpptools/ArrayUtils.h
+        )
+
+add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES})
+target_link_libraries(${PROJECT_NAME}
+        nfc
+        freefare
+        )
+
+install(TARGETS ${PROJECT_NAME}
+        LIBRARY DESTINATION lib)
+
+set(LIBNFC_CPPTOOLS_INCLUDE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/inc PARENT_SCOPE)

libnfc_cpptools/inc/libnfc_cpptools/ArrayUtils.h

@@ -0,0 +1,27 @@
+//
+// Created by robin on 7/23/16.
+//
+
+#ifndef MIFARE_TOOLS_ARRAYUTILS_H
+#define MIFARE_TOOLS_ARRAYUTILS_H
+
+
+namespace LibNfc
+{
+namespace Utils
+{
+
+class ArrayUtils
+{
+public:
+    static void setArrayBit(char *buf, const char &bitPosition, const bool &value);
+    static void setArrayBit(unsigned char *buf, const char &bitPosition, const bool &value);
+    static bool getArrayBit(const char *buf, const char &bitPosition);
+    static bool getArrayBit(const unsigned char *buf, const char &bitPosition);
+
+};
+
+}; // Utils
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_ARRAYUTILS_H

libnfc_cpptools/inc/libnfc_cpptools/FreeFareAccessBits.h

@@ -0,0 +1,70 @@
+//
+// Created by robin on 7/21/16.
+//
+
+#ifndef MIFARE_TOOLS_ACCESSBITSDBO_H
+#define MIFARE_TOOLS_ACCESSBITSDBO_H
+
+
+#include <string>
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+class FreeFareAccessBits
+{
+public:
+
+    static const char nonInvertedBitPosition[4][4];
+    static const char invertedBitPosition[4][4];
+
+    FreeFareAccessBits();
+    FreeFareAccessBits(const std::string& bits);
+
+    char getUserData() const;
+    void setUserData(const char& data);
+
+    void setBit(int i, int j, const bool& value);
+    bool getBit(int i, int j) const;
+    std::string getBits() const;
+
+    bool canKeyAReadBlock(int block) const;
+    bool canKeyBReadBlock(int block) const;
+
+    bool canKeyAWriteBlock(int block) const;
+    bool canKeyBWriteBlock(int block) const;
+
+    bool canKeyAIncrementBlock(int block) const;
+    bool canKeyBIncrementBlock(int block) const;
+
+    bool canKeyADecrementBlock(int block) const;
+    bool canKeyBDecrementBlock(int block) const;
+
+    bool canKeyAReadKeyATrailer() const;
+    bool canKeyBReadKeyATrailer() const;
+
+    bool canKeyAWriteKeyATrailer() const;
+    bool canKeyBWriteKeyATrailer() const;
+
+    bool canKeyAReadAccessBitsTrailer() const;
+    bool canKeyBReadAccessBitsTrailer() const;
+
+    bool canKeyAWriteAccessBitsTrailer() const;
+    bool canKeyBWriteAccessBitsTrailer() const;
+
+    bool canKeyAReadKeyBTrailer() const;
+    bool canKeyBReadKeyBTrailer() const;
+
+    bool canKeyAWriteKeyBTrailer() const;
+    bool canKeyBWriteKeyBTrailer() const;
+
+private:
+    std::string _bits;
+};
+
+}; // FreeFare
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_ACCESSBITSDBO_H

libnfc_cpptools/inc/libnfc_cpptools/FreeFareDevice.h

@@ -0,0 +1,34 @@
+//
+// Created by robin on 7/22/16.
+//
+
+#ifndef MIFARE_TOOLS_FREEFAREDEVICEBUSINESS_H
+#define MIFARE_TOOLS_FREEFAREDEVICEBUSINESS_H
+
+#include "NfcDevice.h"
+#include "FreeFareTag.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+class FreeFareDeviceInternal;
+
+class FreeFareDevice
+{
+public:
+    FreeFareDevice(std::shared_ptr<LibNfc::Core::NfcDevice> device);
+
+    LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTag>>> getTags() const;
+
+protected:
+    std::shared_ptr<LibNfc::Core::NfcDevice> _device;
+
+    std::shared_ptr<FreeFareDeviceInternal> _freeFareDevice;
+};
+
+}; // FreeFare
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_FREEFAREDEVICEBUSINESS_H

libnfc_cpptools/inc/libnfc_cpptools/FreeFareSector.h

@@ -0,0 +1,66 @@
+//
+// Created by robin on 7/22/16.
+//
+
+#ifndef MIFARE_TOOLS_SECTORDBO_H
+#define MIFARE_TOOLS_SECTORDBO_H
+
+
+#include <string>
+#include <libnfc_cpptools/Result.h>
+#include <libnfc_cpptools/FreeFareAccessBits.h>
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+class FreeFareSector
+{
+public:
+    FreeFareSector(const std::string& data = "");
+
+    const std::string& getBlock(int block) const;
+
+    std::string getKeyA() const;
+
+    std::string getKeyB() const;
+
+    std::string getAccessBits() const;
+
+    FreeFareAccessBits getAccessBitsDbo() const;
+
+    void setBlock(int block, const std::string& data);
+
+    void setKeyA(const std::string& key);
+
+    void setKeyB(const std::string& key);
+
+    void setAccessBits(const std::string& accessBits);
+
+    void setAccessBits(const FreeFareAccessBits& accessBits);
+
+    bool hasBlock(int block) const;
+
+    bool hasKeyA() const;
+
+    bool hasKeyB() const;
+
+    bool hasAccessBits() const;
+
+protected:
+    std::string _blocks[4];
+
+    bool _haveBlocks[4];
+
+    bool _hasKeyA;
+
+    bool _hasKeyB;
+
+    bool _hasAccessBits;
+};
+
+}; // FreeFare
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_SECTORDBO_H

libnfc_cpptools/inc/libnfc_cpptools/FreeFareTag.h

@@ -0,0 +1,74 @@
+//
+// Created by robin on 7/22/16.
+//
+
+#ifndef MIFARE_TOOLS_FREEFARETAGBUSINESS_H
+#define MIFARE_TOOLS_FREEFARETAGBUSINESS_H
+
+
+#include <boost/shared_ptr.hpp>
+#include <libnfc_cpptools/FreeFareSector.h>
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+class FreeFareTagInternal;
+
+typedef std::vector<std::pair<std::string, std::string>> MappedKeys;
+
+class FreeFareTag
+{
+public:
+    enum FreeFareTagType {
+        UNKNOWN,
+        FELICA,
+        MIFARE_MINI,
+        MIFARE_CLASSIC_1K,
+        MIFARE_CLASSIC_4K,
+        MIFARE_DESFIRE,
+        MIFARE_ULTRALIGHT,
+        MIFARE_ULTRALIGHT_C
+    };
+
+    static std::string getTagTypeString(FreeFareTagType type);
+
+    FreeFareTag(std::shared_ptr<FreeFareTagInternal> tag);
+
+    LibNfc::Utils::ResultBool authenticate(int sector, std::string key, int keyType);
+
+    LibNfc::Utils::Result<MappedKeys> mapKeys(std::vector<std::string> keys, std::function<void(int, int)> cb = 0);
+
+    LibNfc::Utils::ResultString readBlock(int sector, int block, std::string key, int keyType);
+
+    LibNfc::Utils::Result<FreeFareSector> readSector(int sector, std::string key, int keyType);
+
+    LibNfc::Utils::Result<std::vector<FreeFareSector>> read(MappedKeys keys, std::function<void(int, int)> cb = 0);
+
+    LibNfc::Utils::Result<std::vector<FreeFareSector>> read(std::vector<std::string> keys, std::function<void(int, int)> mapCb = 0,
+                                        std::function<void(int, int)> readCb = 0);
+
+    LibNfc::Utils::ResultBool writeBlock(int sector, int block, std::string key, int keyType, const std::string& data);
+
+    LibNfc::Utils::ResultBool writeSector(int sector, std::string key, int keyType, const std::string& data);
+
+    LibNfc::Utils::ResultBool write(MappedKeys keys, const std::string& data, bool writeSector0, std::function<void(int, int)> cb = 0);
+
+    LibNfc::Utils::ResultBool write(std::vector<std::string> keys, const std::string& data, bool writeSector0,
+                     std::function<void(int, int)> mapCb = 0, std::function<void(int, int)> writeCb = 0);
+
+    const std::string& getUid() const;
+
+    FreeFareTagType getType() const;
+
+    std::shared_ptr<FreeFareTagInternal> getTag() const;
+
+protected:
+    std::shared_ptr<FreeFareTagInternal> _tag;
+};
+
+}; // FreeFare
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_FREEFARETAGBUSINESS_H

libnfc_cpptools/inc/libnfc_cpptools/LibNfc.h

@@ -0,0 +1,44 @@
+//
+// Created by robin on 7/22/16.
+//
+
+#ifndef MIFARE_TOOLS_LIBNFCBUSINESS_H
+#define MIFARE_TOOLS_LIBNFCBUSINESS_H
+
+
+#include <libnfc_cpptools/Result.h>
+#include <libnfc_cpptools/NfcDevice.h>
+
+namespace LibNfc
+{
+namespace Core
+{
+
+class LibNfcInternal;
+
+class LibNfcContext
+{
+public:
+    LibNfcContext();
+    virtual ~LibNfcContext();
+
+    LibNfc::Utils::ResultBool init();
+
+    void clean();
+
+    bool isInitialized() const;
+
+    LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDevice>>> getDevices() const;
+
+    static std::string getLibNfcVersion();
+
+    static std::string getMifareToolsVersion();
+
+protected:
+    std::shared_ptr<LibNfcInternal> _libNfc;
+};
+
+}; // Core
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_LIBNFCBUSINESS_H

libnfc_cpptools/inc/libnfc_cpptools/NfcDevice.h

@@ -0,0 +1,42 @@
+//
+// Created by robin on 7/22/16.
+//
+
+#ifndef MIFARE_TOOLS_NFCDEVICEBUSINESS_H
+#define MIFARE_TOOLS_NFCDEVICEBUSINESS_H
+
+#include <string>
+#include <memory>
+
+#include <libnfc_cpptools/Result.h>
+
+namespace LibNfc
+{
+namespace Core
+{
+
+class NfcDeviceInternal;
+
+class NfcDevice
+{
+public:
+    NfcDevice(std::shared_ptr<NfcDeviceInternal> device);
+
+    LibNfc::Utils::ResultBool open();
+
+    void close();
+
+    bool isOpened() const;
+
+    const std::string & getConnStr() const;
+
+    std::shared_ptr<NfcDeviceInternal> getDevice() const;
+
+protected:
+    std::shared_ptr<NfcDeviceInternal> _device;
+};
+
+}; // Core
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_NFCDEVICEBUSINESS_H

libnfc_cpptools/inc/libnfc_cpptools/Result.h

@@ -0,0 +1,158 @@
+//
+// Created by robin on 8/9/15.
+//
+
+#ifndef RESULT_H
+#define RESULT_H
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <errno.h>
+#include <string.h>
+
+namespace LibNfc
+{
+namespace Utils
+{
+
+template <class T> class Result
+{
+public:
+    static const Result<T> ok(const T& data);
+    static const Result<T> strerror();
+    static const Result<T> error(const std::string& error);
+    template <class U> static const Result<T> error(const Result<U>& other);
+
+    T& getData();
+    const bool isSuccess() const;
+    const std::string& getError() const;
+
+    bool operator !() const;
+    operator bool() const;
+
+    template<class U>
+    friend std::ostream& operator<<(std::ostream& os, const Result<U>& res);
+
+    const Result<T>& print() const;
+
+private:
+    Result();
+
+    T _data;
+
+    std::string _error;
+
+    bool _success;
+};
+
+typedef Result<bool> ResultBool;
+
+typedef Result<int> ResultInt;
+
+typedef Result<long> ResultLong;
+
+typedef Result<float> ResultFloat;
+
+typedef Result<double> ResultDouble;
+
+typedef Result<char> ResultChar;
+
+typedef Result<std::string> ResultString;
+
+
+template<class T>
+Result<T>::Result()
+{
+}
+
+template<class T>
+const Result<T> Result<T>::ok(const T& data)
+{
+    Result<T> r;
+    r._success = true;
+    r._data = data;
+    return r;
+}
+
+template<class T>
+const Result<T> Result<T>::strerror()
+{
+    Result<T> r;
+    r._success = false;
+    r._error = ::strerror(errno);
+    return r;
+}
+
+template<class T>
+const Result<T> Result<T>::error(const std::string& error)
+{
+    Result<T> r;
+    r._success = false;
+    r._error = error;
+    return r;
+}
+
+template<class T>
+template<class U>
+const Result<T> Result<T>::error(const Result<U>& other)
+{
+    Result<T> r;
+    r._success = false;
+    r.error(other.getError());
+    return r;
+}
+
+template<class T>
+T &Result<T>::getData()
+{
+    return _data;
+}
+
+template<class T>
+const bool Result<T>::isSuccess() const
+{
+    return _success;
+}
+
+template<class T>
+bool Result<T>::operator!() const
+{
+    return !isSuccess();
+}
+
+template<class T>
+Result<T>::operator bool() const
+{
+    return isSuccess();
+}
+
+template<class T>
+const std::string &Result<T>::getError() const
+{
+    return _error;
+}
+
+template<class U>
+std::ostream& operator<<(std::ostream& os, const Result<U>& res)
+{
+    if (res._success) {
+        os << "Success";// << res._data;
+    }
+    else {
+        os << "Error: " << (res._error.empty() ? "Unknown error" : res._error);
+    }
+    return os;
+}
+
+template<class T>
+const Result<T>& Result<T>::print() const
+{
+    (_success ? std::cout : std::cerr) << *this << std::endl;
+    return *this;
+}
+
+}; // Utils
+}; // LibNfc
+
+#endif //RESULT_H

libnfc_cpptools/inc/libnfc_cpptools/StringUtils.h

@@ -0,0 +1,51 @@
+//
+// Created by robin on 6/20/16.
+//
+
+#ifndef MIFARE_TOOLS_HEX_H
+#define MIFARE_TOOLS_HEX_H
+
+
+#include <string>
+#include <libnfc_cpptools/Result.h>
+
+namespace LibNfc
+{
+namespace Utils
+{
+
+class StringUtils
+{
+public:
+    static const std::string hex;
+
+    static std::string rawToHuman(uint8_t c);
+    static std::string rawToHuman(int8_t c);
+    static std::string rawToHuman(uint16_t c);
+    static std::string rawToHuman(int16_t c);
+    static std::string rawToHuman(uint32_t c);
+    static std::string rawToHuman(int32_t c);
+    static std::string rawToHuman(uint64_t c);
+    static std::string rawToHuman(int64_t c);
+    static std::string rawToHuman(const std::string& raw);
+
+    static ResultString humanToRaw(const std::string& human);
+
+    static std::string toLower(const std::string& str);
+    static char toLower(char c);
+
+    static std::string toUpper(const std::string& str);
+    static char toUpper(char c);
+
+    static std::string ensureSize(const std::string& data, int size);
+
+    static std::string ltrim(const std::string& s);
+    static std::string rtrim(const std::string& s);
+    static std::string trim(const std::string& s);
+    static std::string removeSpaces(const std::string& s);
+};
+
+}; // Utils
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_HEX_H

libnfc_cpptools/src/freefare/FreeFareAccessBits.cpp

@@ -0,0 +1,219 @@
+//
+// Created by robin on 7/21/16.
+//
+
+#include <cstring>
+#include <iostream>
+#include "libnfc_cpptools/FreeFareAccessBits.h"
+#include "libnfc_cpptools/StringUtils.h"
+#include "libnfc_cpptools/ArrayUtils.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+const char FreeFareAccessBits::nonInvertedBitPosition[4][4] = {
+        {0,  0,  0,  0 },
+        {11, 10, 9,  8 },
+        {23, 22, 21, 20},
+        {19, 18, 17, 16}};
+
+const char FreeFareAccessBits::invertedBitPosition[4][4] = {
+        {0,  0,  0,  0 },
+        {7,  6,  5,  4 },
+        {3,  2,  1,  0},
+        {15, 14, 13, 12}};
+
+FreeFareAccessBits::FreeFareAccessBits()
+    : _bits("\xff\x0f\00\x00", 4)
+{
+}
+
+FreeFareAccessBits::FreeFareAccessBits(const std::string &bits)
+    : _bits(LibNfc::Utils::StringUtils::ensureSize(bits, 4))
+{
+}
+
+char FreeFareAccessBits::getUserData() const
+{
+    return _bits[_bits.length() - 1];
+}
+
+void FreeFareAccessBits::setUserData(const char &data)
+{
+    _bits[_bits.length() - 1] = data;
+}
+
+void FreeFareAccessBits::setBit(int i, int j, const bool& value)
+{
+    char buf[_bits.length()];
+    memcpy(buf, _bits.c_str(), _bits.length());
+
+    LibNfc::Utils::ArrayUtils::setArrayBit(buf, nonInvertedBitPosition[i][j], value);
+    LibNfc::Utils::ArrayUtils::setArrayBit(buf, invertedBitPosition[i][j], !value);
+
+    _bits = std::string(buf, _bits.length());
+}
+
+bool FreeFareAccessBits::getBit(int i, int j) const
+{
+    const char* buf = _bits.c_str();
+    return LibNfc::Utils::ArrayUtils::getArrayBit(buf, nonInvertedBitPosition[i][j]) && !LibNfc::Utils::ArrayUtils::getArrayBit(buf, invertedBitPosition[i][j]);
+}
+
+std::string FreeFareAccessBits::getBits() const
+{
+    return _bits;
+}
+
+bool FreeFareAccessBits::canKeyAReadBlock(int block) const
+{
+    bool c1 = getBit(1, block);
+    bool c2 = getBit(2, block);
+    bool c3 = getBit(3, block);
+    return !c3 || (!c1 && !c2 && c3);
+}
+
+bool FreeFareAccessBits::canKeyBReadBlock(int block) const
+{
+    bool c1 = getBit(1, block);
+    bool c2 = getBit(2, block);
+    bool c3 = getBit(3, block);
+    return !c1 || !c2 || !c3;
+}
+
+bool FreeFareAccessBits::canKeyAWriteBlock(int block) const
+{
+    bool c1 = getBit(1, block);
+    bool c2 = getBit(2, block);
+    bool c3 = getBit(3, block);
+    return !c1 && !c2 && !c3;
+}
+
+bool FreeFareAccessBits::canKeyBWriteBlock(int block) const
+{
+    bool c1 = getBit(1, block);
+    bool c2 = getBit(2, block);
+    bool c3 = getBit(3, block);
+    return (!c2 && !c3) || (c1 && !c3) || (!c1 && c2 && c3);
+}
+
+bool FreeFareAccessBits::canKeyAIncrementBlock(int block) const
+{
+    bool c1 = getBit(1, block);
+    bool c2 = getBit(2, block);
+    bool c3 = getBit(3, block);
+    return !c1 && !c2 && !c3;
+}
+
+bool FreeFareAccessBits::canKeyBIncrementBlock(int block) const
+{
+    bool c1 = getBit(1, block);
+    bool c2 = getBit(2, block);
+    bool c3 = getBit(3, block);
+    return (!c1 && !c2 && !c3) || (c1 && c2 && !c3);
+}
+
+bool FreeFareAccessBits::canKeyADecrementBlock(int block) const
+{
+    bool c1 = getBit(1, block);
+    bool c2 = getBit(2, block);
+    bool c3 = getBit(3, block);
+    return (!c1 && !c2) || (c1 && c2 && !c3);
+}
+
+bool FreeFareAccessBits::canKeyBDecrementBlock(int block) const
+{
+    bool c1 = getBit(1, block);
+    bool c2 = getBit(2, block);
+    bool c3 = getBit(3, block);
+    return (!c1 && !c2) || (c1 && c2 && !c3);
+}
+
+bool FreeFareAccessBits::canKeyAReadKeyATrailer() const
+{
+    return false;
+}
+
+bool FreeFareAccessBits::canKeyBReadKeyATrailer() const
+{
+    return false;
+}
+
+bool FreeFareAccessBits::canKeyAWriteKeyATrailer() const
+{
+    bool c1 = getBit(1, 3);
+    bool c2 = getBit(2, 3);
+    bool c3 = getBit(3, 3);
+    return !c1 && !c2;
+}
+
+bool FreeFareAccessBits::canKeyBWriteKeyATrailer() const
+{
+    bool c1 = getBit(1, 3);
+    bool c2 = getBit(2, 3);
+    bool c3 = getBit(3, 3);
+    return (!c1 && c2 && c3) || (c1 && !c2 && !c3);
+}
+
+bool FreeFareAccessBits::canKeyAReadAccessBitsTrailer() const
+{
+    return true;
+}
+
+bool FreeFareAccessBits::canKeyBReadAccessBitsTrailer() const
+{
+    bool c1 = getBit(1, 3);
+    bool c2 = getBit(2, 3);
+    bool c3 = getBit(3, 3);
+    return c1 || (c2 && c3);
+}
+
+bool FreeFareAccessBits::canKeyAWriteAccessBitsTrailer() const
+{
+    bool c1 = getBit(1, 3);
+    bool c2 = getBit(2, 3);
+    bool c3 = getBit(3, 3);
+    return !c1 && !c2 && c3;
+}
+
+bool FreeFareAccessBits::canKeyBWriteAccessBitsTrailer() const
+{
+    bool c1 = getBit(1, 3);
+    bool c2 = getBit(2, 3);
+    bool c3 = getBit(3, 3);
+    return (!c1 && c2 && c3) || (c1 && !c2 && c3);
+}
+
+bool FreeFareAccessBits::canKeyAReadKeyBTrailer() const
+{
+    bool c1 = getBit(1, 3);
+    bool c2 = getBit(2, 3);
+    bool c3 = getBit(3, 3);
+    return (!c1 && !c2) || (!c1 && !c3);
+}
+
+bool FreeFareAccessBits::canKeyBReadKeyBTrailer() const
+{
+    return false;
+}
+
+bool FreeFareAccessBits::canKeyAWriteKeyBTrailer() const
+{
+    bool c1 = getBit(1, 3);
+    bool c2 = getBit(2, 3);
+    bool c3 = getBit(3, 3);
+    return !c1 && !c2;
+}
+
+bool FreeFareAccessBits::canKeyBWriteKeyBTrailer() const
+{
+    bool c1 = getBit(1, 3);
+    bool c2 = getBit(2, 3);
+    bool c3 = getBit(3, 3);
+    return (!c1 && c2 && c3) || (c1 && !c2 && !c3);
+}
+
+}; // FreeFare
+}; // LibNfc

libnfc_cpptools/src/freefare/FreeFareDevice.cpp

@@ -0,0 +1,37 @@
+//
+// Created by robin on 7/22/16.
+//
+
+#include "libnfc_cpptools/FreeFareDevice.h"
+#include "FreeFareDeviceInternal.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+FreeFareDevice::FreeFareDevice(std::shared_ptr<LibNfc::Core::NfcDevice> device)
+    : _device(device),
+      _freeFareDevice(std::make_shared<FreeFareDeviceInternal>(_device->getDevice()))
+{
+}
+
+LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTag>>> FreeFareDevice::getTags() const
+{
+    if (!_device->isOpened()) {
+        return LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTag>>>::error("Device is not opened");
+    }
+    auto tagsResult = _freeFareDevice->getTags();
+    if (!tagsResult) {
+        return LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTag>>>::error(tagsResult);
+    }
+    auto tags = tagsResult.getData();
+    std::vector<std::shared_ptr<FreeFareTag>> tagsBusiness;
+    for (auto tag : tags) {
+        tagsBusiness.push_back(std::make_shared<FreeFareTag>(tag));
+    }
+    return LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTag>>>::ok(tagsBusiness);
+}
+
+}; // FreeFare
+}; // LibNfc

libnfc_cpptools/src/freefare/FreeFareDeviceInternal.cpp

@@ -0,0 +1,31 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#include "FreeFareDeviceInternal.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+FreeFareDeviceInternal::FreeFareDeviceInternal(std::shared_ptr<LibNfc::Core::NfcDeviceInternal> device)
+    : _device(device)
+{
+}
+
+LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTagInternal>>> FreeFareDeviceInternal::getTags()
+{
+    FreefareTag* tags = freefare_get_tags(_device->getDevice());
+    if (!tags) {
+        return LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTagInternal>>>::error("Failed to get MIFARE tags");
+    }
+    std::vector<std::shared_ptr<FreeFareTagInternal>> tagList;
+    for (size_t i = 0; tags[i] != 0; ++i) {
+        tagList.push_back(std::make_shared<FreeFareTagInternal>(tags[i]));
+    }
+    return LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTagInternal>>>::ok(tagList);
+}
+
+}; // FreeFare
+}; // LibNfc

libnfc_cpptools/src/freefare/FreeFareDeviceInternal.h

@@ -0,0 +1,32 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#ifndef MIFARE_TOOLS_FREEFAREDEVICE_H
+#define MIFARE_TOOLS_FREEFAREDEVICE_H
+
+
+#include <freefare.h>
+#include "NfcDeviceInternal.h"
+#include "FreeFareTagInternal.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+class FreeFareDeviceInternal
+{
+public:
+    FreeFareDeviceInternal(std::shared_ptr<LibNfc::Core::NfcDeviceInternal> device);
+
+    LibNfc::Utils::Result<std::vector<std::shared_ptr<FreeFareTagInternal>>> getTags();
+
+private:
+    std::shared_ptr<LibNfc::Core::NfcDeviceInternal> _device;
+};
+
+}; // FreeFare
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_FREEFAREDEVICE_H

libnfc_cpptools/src/freefare/FreeFareSector.cpp

@@ -0,0 +1,117 @@
+//
+// Created by robin on 7/22/16.
+//
+
+#include "libnfc_cpptools/StringUtils.h"
+#include "libnfc_cpptools/FreeFareSector.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+FreeFareSector::FreeFareSector(const std::string &data)
+{
+    std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 64);
+    for (int i = 0; i < 4; ++i) {
+        _blocks[i] = d.substr(16 * i, 16);
+        _haveBlocks[i] = true;
+    }
+}
+
+const std::string &FreeFareSector::getBlock(int block) const
+{
+    return _blocks[block];
+}
+
+std::string FreeFareSector::getKeyA() const
+{
+    return _blocks[3].substr(0, 6);
+}
+
+std::string FreeFareSector::getKeyB() const
+{
+    return _blocks[3].substr(10, 6);
+}
+
+std::string FreeFareSector::getAccessBits() const
+{
+    return _blocks[3].substr(6, 4);
+}
+
+FreeFareAccessBits FreeFareSector::getAccessBitsDbo() const
+{
+    return FreeFareAccessBits(getAccessBits());
+}
+
+void FreeFareSector::setBlock(int block, const std::string &data)
+{
+    std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 16);
+    if (block == 3) {
+        setKeyA(d.substr(0, 6));
+        setKeyB(d.substr(10, 6));
+        setAccessBits(d.substr(6, 4));
+    }
+    else {
+        _haveBlocks[block] = !data.empty();
+        _blocks[block] = d;
+    }
+}
+
+void FreeFareSector::setKeyA(const std::string &key)
+{
+    std::string k = LibNfc::Utils::StringUtils::ensureSize(key, 6);
+    for (int i = 0; i < k.size(); ++i) {
+        _blocks[3][i] = k[i];
+    }
+    _hasKeyA = !key.empty();
+}
+
+void FreeFareSector::setKeyB(const std::string &key)
+{
+    std::string k = LibNfc::Utils::StringUtils::ensureSize(key, 6);
+    for (int i = 0; i < k.size(); ++i) {
+        _blocks[3][10 + i] = k[i];
+    }
+    _hasKeyB = !key.empty();
+}
+
+void FreeFareSector::setAccessBits(const std::string &accessBits)
+{
+    std::string a = LibNfc::Utils::StringUtils::ensureSize(accessBits, 4);
+    for (int i = 0; i < a.size(); ++i) {
+        _blocks[3][6 + i] = a[i];
+    }
+    _hasAccessBits = !accessBits.empty();
+}
+
+void FreeFareSector::setAccessBits(const FreeFareAccessBits &accessBits)
+{
+    setAccessBits(accessBits.getBits());
+}
+
+bool FreeFareSector::hasBlock(int block) const
+{
+    if (block == 3) {
+        return _hasKeyA && _hasKeyB && _hasAccessBits;
+    }
+    return _haveBlocks[block];
+}
+
+bool FreeFareSector::hasKeyA() const
+{
+    return _hasKeyA;
+}
+
+bool FreeFareSector::hasKeyB() const
+{
+    return _hasKeyB;
+}
+
+bool FreeFareSector::hasAccessBits() const
+{
+    return _hasAccessBits;
+}
+
+}; // FreeFare
+}; // LibNfc

libnfc_cpptools/src/freefare/FreeFareTag.cpp

@@ -0,0 +1,335 @@
+//
+// Created by robin on 7/22/16.
+//
+
+#include "libnfc_cpptools/FreeFareTag.h"
+#include "libnfc_cpptools/StringUtils.h"
+#include "FreeFareTagInternal.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+std::string FreeFareTag::getTagTypeString(FreeFareTag::FreeFareTagType type)
+{
+    if (type == FreeFareTagType::FELICA)
+    {
+        return "FELICA";
+    }
+    if (type == FreeFareTagType::MIFARE_MINI)
+    {
+        return "MIFARE_MINI";
+    }
+    if (type == FreeFareTagType::MIFARE_CLASSIC_1K)
+    {
+        return "MIFARE_CLASSIC_1K";
+    }
+    if (type == FreeFareTagType::MIFARE_CLASSIC_4K)
+    {
+        return "MIFARE_CLASSIC_4K";
+    }
+    if (type == FreeFareTagType::MIFARE_DESFIRE)
+    {
+        return "MIFARE_DESFIRE";
+    }
+    if (type == FreeFareTagType::MIFARE_ULTRALIGHT)
+    {
+        return "MIFARE_ULTRALIGHT";
+    }
+    if (type == FreeFareTagType::MIFARE_ULTRALIGHT_C)
+    {
+        return "MIFARE_ULTRALIGHT_C";
+    }
+    return "UNKNOWN";
+}
+
+FreeFareTag::FreeFareTag(std::shared_ptr<FreeFareTagInternal> tag)
+    : _tag(tag)
+{
+}
+
+LibNfc::Utils::ResultBool FreeFareTag::authenticate(int sector, std::string key, int keyType)
+{
+    return _tag->authenticate(sector, key, keyType);
+}
+
+LibNfc::Utils::Result<MappedKeys> FreeFareTag::mapKeys(std::vector<std::string> keys, std::function<void(int, int)> cb)
+{
+    MappedKeys mappedKeys;
+    int done = 0;
+    int total = 16 * keys.size();
+
+    for (int i = 0; i < 16; ++i) {
+        std::pair<std::string, std::string> blockKeys;
+        for (int k = 0; k < keys.size(); ++k) {
+            auto key = keys[k];
+            if (authenticate(i, key, MFC_KEY_A)) {
+                blockKeys.first = key;
+            }
+            if (authenticate(i, key, MFC_KEY_B)) {
+                blockKeys.second = key;
+            }
+            if (cb != 0) {
+                cb(++done, total);
+            }
+            if (!blockKeys.first.empty() && !blockKeys.second.empty()) {
+                break;
+            }
+        }
+        mappedKeys.push_back(blockKeys);
+    }
+    if (cb != 0 && done < total) {
+        cb(total, total);
+    }
+
+    return LibNfc::Utils::Result<MappedKeys>::ok(mappedKeys);
+}
+
+LibNfc::Utils::ResultString FreeFareTag::readBlock(int sector, int block, std::string key, int keyType)
+{
+    return _tag->readBlock(sector, block, key, keyType);
+}
+
+LibNfc::Utils::Result<FreeFareSector> FreeFareTag::readSector(int sector, std::string key, int keyType)
+{
+    std::string res;
+    int lastBlock = _tag->getSectorBlockCount(sector);
+    for (int i = 0; i < lastBlock; ++i) {
+        auto data = readBlock(sector, i, key, keyType);
+        if (data) {
+            res += data.getData();
+        }
+        else {
+            return LibNfc::Utils::Result<FreeFareSector>::error(data);
+        }
+    }
+    return LibNfc::Utils::Result<FreeFareSector>::ok(FreeFareSector(res));
+}
+
+LibNfc::Utils::Result<std::vector<FreeFareSector>> FreeFareTag::read(MappedKeys keys, std::function<void(int, int)> cb)
+{
+    if (keys.size() != 16) {
+        return LibNfc::Utils::Result<std::vector<FreeFareSector>>::error("Must have 16 sectors keys");
+    }
+    int done = 0;
+    int total = 4 * keys.size();
+    std::vector<FreeFareSector> sectors;
+    for (int s = 0; s < keys.size(); ++s) {
+        auto sectorKey = keys[s];
+        FreeFareSector sector;
+        bool keyA = false;
+        bool keyB = false;
+        for (int b = 0; b < 3; ++b) {
+            std::string data = "";
+            if (!sectorKey.first.empty()) {
+                auto blockResult = readBlock(s, b, sectorKey.first, MFC_KEY_A);
+                if (blockResult) {
+                    data = blockResult.getData();
+                    keyA = true;
+                }
+            }
+            if (!sectorKey.second.empty()) {
+                auto blockResult = readBlock(s, b, sectorKey.second, MFC_KEY_B);
+                if (blockResult) {
+                    if (data.empty()) {
+                        data = blockResult.getData();
+                    }
+                    keyB = true;
+                }
+            }
+            sector.setBlock(b, data);
+            if (cb != 0) {
+                cb(++done, total);
+            }
+        }
+        int b = 3;
+        std::string dataA = "";
+        std::string dataB = "";
+        if (!sectorKey.first.empty()) {
+            auto blockResult = readBlock(s, b, sectorKey.first, MFC_KEY_A);
+            if (blockResult) {
+                dataA = blockResult.getData();
+                keyA = true;
+            }
+        }
+        if (!sectorKey.second.empty()) {
+            auto blockResult = readBlock(s, b, sectorKey.second, MFC_KEY_B);
+            if (blockResult) {
+                dataB = blockResult.getData();
+                keyB = true;
+            }
+        }
+        if (cb != 0) {
+            cb(++done, total);
+        }
+
+        sector.setBlock(b, dataA);
+        FreeFareAccessBits accessBitsDboA = sector.getAccessBitsDbo();
+        sector.setBlock(b, dataB);
+        FreeFareAccessBits accessBitsDboB = sector.getAccessBitsDbo();
+        sector.setKeyA(keyA ? sectorKey.first : "");
+        sector.setKeyB(keyB ? sectorKey.second : "");
+
+        std::string accessBits;
+        if (keyA && accessBitsDboA.canKeyAReadAccessBitsTrailer()) {
+            accessBits = accessBitsDboA.getBits();
+        }
+        else if (keyB && accessBitsDboB.canKeyBReadAccessBitsTrailer()) {
+            accessBits = accessBitsDboB.getBits();
+        }
+        sector.setAccessBits(accessBits);
+
+        sectors.push_back(sector);
+    }
+    if (cb != 0 && done < total) {
+        cb(total, total);
+    }
+
+    return LibNfc::Utils::Result<std::vector<FreeFareSector>>::ok(sectors);
+}
+
+LibNfc::Utils::Result<std::vector<FreeFareSector>> FreeFareTag::read(std::vector<std::string> keys, std::function<void(int, int)> mapCb,
+                                                         std::function<void(int, int)> readCb)
+{
+    auto mappedKeysResult = mapKeys(keys, mapCb);
+    if (!mappedKeysResult) {
+        return LibNfc::Utils::Result<std::vector<FreeFareSector>>::error(mappedKeysResult);
+    }
+    return read(mappedKeysResult.getData(), readCb);
+}
+
+LibNfc::Utils::ResultBool FreeFareTag::writeBlock(int sector, int block, std::string key, int keyType, const std::string &data)
+{
+    return _tag->writeBlock(sector, block, key, keyType, LibNfc::Utils::StringUtils::ensureSize(data, 16));
+}
+
+LibNfc::Utils::ResultBool FreeFareTag::writeSector(int sector, std::string key, int keyType, const std::string &data)
+{
+    std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 64);
+    std::string errors;
+    for (int b = 0; b < 4; ++b) {
+        auto result = writeBlock(sector, b, key, keyType, d.substr(b * 16, 16));
+        if (!result) {
+            errors += std::string(errors.empty() ? "" : "\n") + "Failed to write sector " + std::to_string(sector) +
+                      " block " + std::to_string(b) + " with key " + (keyType == MFC_KEY_A ? "A" : "B") + ": " + result.getError();
+        }
+    }
+    if (errors.empty()) {
+        return LibNfc::Utils::ResultBool::ok(true);
+    }
+    return LibNfc::Utils::ResultBool::error(errors);
+}
+
+LibNfc::Utils::ResultBool FreeFareTag::write(MappedKeys keys, const std::string &data, bool writeSector0, std::function<void(int, int)> cb)
+{
+    if (keys.size() != 16) {
+        return LibNfc::Utils::ResultBool::error("Must have 16 sectors keys");
+    }
+    std::string d = LibNfc::Utils::StringUtils::ensureSize(data, 1024);
+    std::string errors;
+    int done = 0;
+    int total = 4 * keys.size();
+    for (int s = 0; s < keys.size(); ++s) {
+        auto sectorKey = keys[s];
+        for (int b = 0; b < 4; ++b) {
+            if (s == 0 && b == 0 && !writeSector0) {
+                continue;
+            }
+            std::string blockData = d.substr((s * 64) + (b * 16), 16);
+            if (cb != 0 && done < total) {
+                bool keyA = false;
+                bool keyB = false;
+                std::string sectorErrors;
+                if (!sectorKey.first.empty()) {
+                    auto resultA = writeBlock(s, b, sectorKey.first, MFC_KEY_A, blockData);
+                    if (resultA) {
+                        keyA = true;
+                    }
+                    else {
+                        sectorErrors = "Failed to write sector " + std::to_string(s) +
+                                       " block " + std::to_string(b) + " with key A: " + resultA.getError();
+                    }
+                }
+                if (!keyA && !sectorKey.second.empty()) {
+                    auto resultB = writeBlock(s, b, sectorKey.first, MFC_KEY_A, blockData);
+                    if (resultB) {
+                        keyB = true;
+                    }
+                    else {
+                        sectorErrors = std::string(sectorErrors.empty() ? "" : "\n") + "Failed to write sector " + std::to_string(s) +
+                                       " block " + std::to_string(b) + " with key B: " + resultB.getError();
+                    }
+                }
+                if (!keyA && !keyB) {
+                    errors += std::string(errors.empty() ? "" : "\n") + sectorErrors;
+                }
+                cb(++done, total);
+            }
+        }
+    }
+    if (cb != 0 && done < total) {
+        cb(total, total);
+    }
+    if (errors.empty()) {
+        return LibNfc::Utils::ResultBool::ok(true);
+    }
+    return LibNfc::Utils::ResultBool::error(errors);
+}
+
+LibNfc::Utils::ResultBool FreeFareTag::write(std::vector<std::string> keys, const std::string &data, bool writeSector0,
+                                      std::function<void(int, int)> mapCb, std::function<void(int, int)> writeCb)
+{
+    auto mappedKeysResult = mapKeys(keys, mapCb);
+    if (!mappedKeysResult) {
+        return LibNfc::Utils::ResultBool::error(mappedKeysResult);
+    }
+    return write(mappedKeysResult.getData(), data, writeSector0, writeCb);
+}
+
+const std::string &FreeFareTag::getUid() const
+{
+    return _tag->getUid();
+}
+
+FreeFareTag::FreeFareTagType FreeFareTag::getType() const
+{
+    auto type = _tag->getType();
+    if (type == freefare_tag_type::FELICA)
+    {
+        return FreeFareTagType::FELICA;
+    }
+    if (type == freefare_tag_type::MIFARE_MINI)
+    {
+        return FreeFareTagType::MIFARE_MINI;
+    }
+    if (type == freefare_tag_type::MIFARE_CLASSIC_1K)
+    {
+        return FreeFareTagType::MIFARE_CLASSIC_1K;
+    }
+    if (type == freefare_tag_type::MIFARE_CLASSIC_4K)
+    {
+        return FreeFareTagType::MIFARE_CLASSIC_4K;
+    }
+    if (type == freefare_tag_type::MIFARE_DESFIRE)
+    {
+        return FreeFareTagType::MIFARE_DESFIRE;
+    }
+    if (type == freefare_tag_type::MIFARE_ULTRALIGHT)
+    {
+        return FreeFareTagType::MIFARE_ULTRALIGHT;
+    }
+    if (type == freefare_tag_type::MIFARE_ULTRALIGHT_C)
+    {
+        return FreeFareTagType::MIFARE_ULTRALIGHT_C;
+    }
+    return FreeFareTagType::UNKNOWN;
+}
+
+std::shared_ptr<FreeFareTagInternal> FreeFareTag::getTag() const
+{
+    return _tag;
+}
+
+}; // FreeFare
+}; // LibNfc

libnfc_cpptools/src/freefare/FreeFareTagInternal.cpp

@@ -0,0 +1,109 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#include <sstream>
+#include <map>
+#include "FreeFareTagInternal.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+FreeFareTagInternal::FreeFareTagInternal(FreefareTag tag)
+    : _tag(tag)
+{
+    _type = freefare_get_tag_type(tag);
+    _uid = freefare_get_tag_uid(tag);
+}
+
+FreeFareTagInternal::~FreeFareTagInternal()
+{
+    freefare_free_tag(_tag);
+}
+
+LibNfc::Utils::ResultBool FreeFareTagInternal::authenticate(int sector, std::string key, int keyType)
+{
+
+    if (mifare_classic_connect(_tag) != 0) {
+        return LibNfc::Utils::ResultBool::error("Failed to connect to MIFARE tag");
+    }
+    int block = mifare_classic_sector_last_block((MifareClassicBlockNumber)sector);
+    if (mifare_classic_authenticate(_tag, (MifareClassicBlockNumber)block, (const unsigned char*)key.c_str(),
+                                    (MifareClassicKeyType)keyType) != 0) {
+        return LibNfc::Utils::ResultBool::error("Failed to authenticate to MIFARE tag");
+    }
+    mifare_classic_disconnect(_tag);
+    return LibNfc::Utils::ResultBool::ok(true);
+}
+
+LibNfc::Utils::ResultString FreeFareTagInternal::readBlock(int sector, int block, std::string key, int keyType)
+{
+    if (mifare_classic_connect(_tag) != 0) {
+        return LibNfc::Utils::ResultString::error("Failed to connect to MIFARE tag");
+    }
+    block = mifare_classic_sector_first_block((MifareClassicBlockNumber)sector) + block;
+    if (mifare_classic_authenticate(_tag, (MifareClassicBlockNumber)block, (const unsigned char*)key.c_str(),
+                                    (MifareClassicKeyType)keyType) != 0) {
+        return LibNfc::Utils::ResultString::error("Failed to authenticate to MIFARE tag");
+    }
+
+    MifareClassicBlock data;
+    if (mifare_classic_read(_tag, (MifareClassicBlockNumber)block, &data)) {
+        return LibNfc::Utils::ResultString::error("Failed to read MIFARE tag data");
+    }
+    mifare_classic_disconnect(_tag);
+    return LibNfc::Utils::ResultString::ok(std::string((const char*)data, sizeof(data)));
+}
+
+LibNfc::Utils::ResultBool FreeFareTagInternal::writeBlock(int sector, int block, std::string key, int keyType, const std::string &data)
+{
+    if (mifare_classic_connect(_tag) != 0) {
+        return LibNfc::Utils::ResultBool::error("Failed to connect to MIFARE tag");
+    }
+    block = mifare_classic_sector_first_block((MifareClassicBlockNumber)sector) + block;
+    if (mifare_classic_authenticate(_tag, (MifareClassicBlockNumber)block, (const unsigned char*)key.c_str(),
+                                    (MifareClassicKeyType)keyType) != 0) {
+        return LibNfc::Utils::ResultBool::error("Failed to authenticate to MIFARE tag");
+    }
+
+    if (mifare_classic_write(_tag, (MifareClassicBlockNumber)block, (const unsigned char*)data.c_str())) {
+        return LibNfc::Utils::ResultBool::error("Failed to write data to MIFARE tag");
+    }
+    mifare_classic_disconnect(_tag);
+    return LibNfc::Utils::ResultBool::ok(true);
+}
+
+const freefare_tag *FreeFareTagInternal::getTag() const
+{
+    return _tag;
+}
+
+int FreeFareTagInternal::getFirstBlock(int sector) const
+{
+    return mifare_classic_sector_first_block(sector);
+}
+
+int FreeFareTagInternal::getLastBlock(int sector) const
+{
+    return mifare_classic_sector_last_block(sector);
+}
+
+int FreeFareTagInternal::getSectorBlockCount(int sector)
+{
+    return mifare_classic_sector_block_count(sector);
+}
+
+freefare_tag_type FreeFareTagInternal::getType() const
+{
+    return _type;
+}
+
+const std::string &FreeFareTagInternal::getUid() const
+{
+    return _uid;
+}
+
+}; // FreeFare
+}; // LibNfc

libnfc_cpptools/src/freefare/FreeFareTagInternal.h

@@ -0,0 +1,53 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#ifndef MIFARE_TOOLS_FREEFARETAG_H
+#define MIFARE_TOOLS_FREEFARETAG_H
+
+#include <freefare.h>
+#include <string>
+#include "libnfc_cpptools/Result.h"
+
+namespace LibNfc
+{
+namespace FreeFare
+{
+
+class FreeFareTagInternal
+{
+public:
+
+    FreeFareTagInternal(FreefareTag tag);
+    ~FreeFareTagInternal();
+
+    LibNfc::Utils::ResultBool authenticate(int sector, std::string key, int keyType);
+
+    LibNfc::Utils::ResultString readBlock(int sector, int block, std::string key, int keyType);
+
+    LibNfc::Utils::ResultBool writeBlock(int sector, int block, std::string key, int keyType, const std::string& data);
+
+    int getFirstBlock(int sector) const;
+
+    int getLastBlock(int sector) const;
+
+    int getSectorBlockCount(int sector);
+
+    const freefare_tag * getTag() const;
+
+    freefare_tag_type getType() const;
+
+    const std::string & getUid() const;
+
+private:
+    FreefareTag _tag;
+
+    freefare_tag_type _type;
+
+    std::string _uid;
+};
+
+}; // FreeFare
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_FREEFARETAG_H

libnfc_cpptools/src/libnfc/LibNfc.cpp

@@ -0,0 +1,83 @@
+//
+// Created by robin on 7/22/16.
+//
+
+#include <algorithm>
+#include "libnfc_cpptools/LibNfc.h"
+#include "LibNfcInternal.h"
+
+#define Q(x) #x
+#define QUOTE(x) Q(x)
+
+#ifndef GIT_SHA1
+#define GIT_SHA1 "unknown"
+#endif
+
+#ifndef GIT_REF_NAME
+#define GIT_REF_NAME "unknown"
+#endif
+
+namespace LibNfc
+{
+namespace Core
+{
+
+LibNfcContext::LibNfcContext()
+{
+    _libNfc = std::make_shared<LibNfcInternal>();
+}
+
+LibNfcContext::~LibNfcContext()
+{
+    _libNfc->clean();
+}
+
+LibNfc::Utils::ResultBool LibNfcContext::init()
+{
+    if (isInitialized()) {
+        return LibNfc::Utils::ResultBool::error("LibNfc is already initialized");
+    }
+    return _libNfc->init();
+}
+
+std::string LibNfcContext::getLibNfcVersion()
+{
+    return LibNfcInternal::getVersion();
+}
+
+void LibNfcContext::clean()
+{
+    if (isInitialized()) {
+        _libNfc->clean();
+    }
+}
+
+bool LibNfcContext::isInitialized() const
+{
+    return _libNfc->getContext() != 0;
+}
+
+LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDevice>>> LibNfcContext::getDevices() const
+{
+    if (!isInitialized()) {
+        return LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDevice>>>::error("LibNfc is not initialized");
+    }
+    auto devicesResult = _libNfc->getDevices();
+    if (!devicesResult) {
+        return LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDevice>>>::error(devicesResult);
+    }
+    auto devices = devicesResult.getData();
+    std::vector<std::shared_ptr<NfcDevice>> devicesBusiness;
+    for (auto device : devices) {
+        devicesBusiness.push_back(std::make_shared<NfcDevice>(device));
+    }
+    return LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDevice>>>::ok(devicesBusiness);
+}
+
+std::string LibNfcContext::getMifareToolsVersion()
+{
+    return QUOTE(GIT_REF_NAME)  "-"  QUOTE(GIT_SHA1);
+}
+
+}; // Core
+}; // LibNfc

libnfc_cpptools/src/libnfc/LibNfcInternal.cpp

@@ -0,0 +1,64 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#include <boost/shared_ptr.hpp>
+#include "LibNfcInternal.h"
+
+namespace LibNfc
+{
+namespace Core
+{
+
+LibNfcInternal::LibNfcInternal()
+    : _context(0)
+{
+}
+
+LibNfcInternal::~LibNfcInternal()
+{
+    clean();
+}
+
+LibNfc::Utils::ResultBool LibNfcInternal::init()
+{
+    nfc_init(&_context);
+    if (!_context) {
+        return LibNfc::Utils::ResultBool::error("LibNfc could not be initialized");
+    }
+    return LibNfc::Utils::ResultBool::ok(true);
+}
+
+std::string LibNfcInternal::getVersion()
+{
+    return nfc_version();
+}
+
+void LibNfcInternal::clean()
+{
+    nfc_exit(_context);
+    _context = 0;
+}
+
+LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDeviceInternal>>> LibNfcInternal::getDevices() const
+{
+    nfc_connstring devices[16];
+    ::memset((char*)devices, 0, sizeof(devices));
+    size_t count = nfc_list_devices(_context, devices, 16);
+    if (count < 0) {
+        return LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDeviceInternal>>>::error("Failed to list NFC devices: " + count);
+    }
+    std::vector<std::shared_ptr<NfcDeviceInternal>> devicesList;
+    for (size_t i = 0; i < count; ++i) {
+        devicesList.push_back(std::make_shared<NfcDeviceInternal>(this, devices[i]));
+    }
+    return LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDeviceInternal>>>::ok(devicesList);
+}
+
+nfc_context *LibNfcInternal::getContext() const
+{
+    return _context;
+}
+
+}; // Core
+}; // LibNfc

libnfc_cpptools/src/libnfc/LibNfcInternal.h

@@ -0,0 +1,43 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#ifndef MIFARE_TOOLS_LIBNFC_H
+#define MIFARE_TOOLS_LIBNFC_H
+
+#include <memory>
+#include <nfc/nfc.h>
+#include "NfcDeviceInternal.h"
+#include "libnfc_cpptools/Result.h"
+
+namespace LibNfc
+{
+namespace Core
+{
+
+class NfcDeviceInternal;
+
+class LibNfcInternal
+{
+public:
+    LibNfcInternal();
+    virtual ~LibNfcInternal();
+
+    LibNfc::Utils::ResultBool init();
+
+    void clean();
+
+    LibNfc::Utils::Result<std::vector<std::shared_ptr<NfcDeviceInternal>>> getDevices() const;
+
+    static std::string getVersion();
+
+    nfc_context* getContext() const;
+
+protected:
+    nfc_context* _context;
+};
+
+}; // Core
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_LIBNFC_H

libnfc_cpptools/src/libnfc/NfcDevice.cpp

@@ -0,0 +1,49 @@
+//
+// Created by robin on 7/22/16.
+//
+
+#include "libnfc_cpptools/NfcDevice.h"
+#include "NfcDeviceInternal.h"
+
+namespace LibNfc
+{
+namespace Core
+{
+
+NfcDevice::NfcDevice(std::shared_ptr<NfcDeviceInternal> device)
+    : _device(device)
+{
+}
+
+LibNfc::Utils::ResultBool NfcDevice::open()
+{
+    if (isOpened()) {
+        return LibNfc::Utils::ResultBool::error("NFC device is already opened");
+    }
+    return _device->open();
+}
+
+void NfcDevice::close()
+{
+    if (isOpened()) {
+        _device->close();
+    }
+}
+
+bool NfcDevice::isOpened() const
+{
+    return _device->getDevice() != 0;
+}
+
+const std::string &NfcDevice::getConnStr() const
+{
+    return _device->getConnStr();
+}
+
+std::shared_ptr<NfcDeviceInternal> NfcDevice::getDevice() const
+{
+    return _device;
+}
+
+}; // Core
+}; // LibNfc

libnfc_cpptools/src/libnfc/NfcDeviceInternal.cpp

@@ -0,0 +1,50 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#include "NfcDeviceInternal.h"
+
+namespace LibNfc
+{
+namespace Core
+{
+
+NfcDeviceInternal::NfcDeviceInternal(const LibNfcInternal* libNfc, const std::string& str)
+    : _connStr(str)
+    , _device(0)
+    , _libNfc(libNfc)
+{
+}
+
+NfcDeviceInternal::~NfcDeviceInternal()
+{
+    close();
+}
+
+LibNfc::Utils::ResultBool NfcDeviceInternal::open()
+{
+    _device = nfc_open(_libNfc->getContext(), _connStr.c_str());
+    if (!_device) {
+        return LibNfc::Utils::ResultBool::error("Failed to open NFC device");
+    }
+    return LibNfc::Utils::ResultBool::ok(true);
+}
+
+void NfcDeviceInternal::close()
+{
+    nfc_close(_device);
+    _device = 0;
+}
+
+nfc_device *NfcDeviceInternal::getDevice() const
+{
+    return _device;
+}
+
+const std::string &NfcDeviceInternal::getConnStr() const
+{
+    return _connStr;
+}
+
+}; // Core
+}; // LibNfc

libnfc_cpptools/src/libnfc/NfcDeviceInternal.h

@@ -0,0 +1,46 @@
+//
+// Created by robin on 6/19/16.
+//
+
+#ifndef MIFARE_TOOLS_NFCDEVICEDBO_H
+#define MIFARE_TOOLS_NFCDEVICEDBO_H
+
+
+#include <string>
+#include <nfc/nfc-types.h>
+#include "libnfc_cpptools/Result.h"
+#include "LibNfcInternal.h"
+
+namespace LibNfc
+{
+namespace Core
+{
+
+class LibNfcInternal;
+
+class NfcDeviceInternal
+{
+public:
+    NfcDeviceInternal(const LibNfcInternal* libNfc, const std::string& connStr);
+    ~NfcDeviceInternal();
+
+    LibNfc::Utils::ResultBool open();
+
+    void close();
+
+    const std::string & getConnStr() const;
+
+    nfc_device * getDevice() const;
+
+private:
+    std::string _connStr;
+
+    nfc_device* _device;
+
+    const LibNfcInternal* _libNfc;
+};
+
+}; // Core
+}; // LibNfc
+
+#endif //MIFARE_TOOLS_NFCDEVICEDBO_H

libnfc_cpptools/src/utils/ArrayUtils.cpp

@@ -0,0 +1,44 @@
+//
+// Created by robin on 7/23/16.
+//
+
+#include "libnfc_cpptools/ArrayUtils.h"
+
+namespace LibNfc
+{
+namespace Utils
+{
+
+void ArrayUtils::setArrayBit(char *buf, const char &bitPosition, const bool &value)
+{
+    char byteOffset = (char)(bitPosition / 8);
+    char bitOffset = (char)(7 - (bitPosition % 8));
+    if(value)
+    {
+        buf[byteOffset] |=  (1 << bitOffset);
+    }
+    else
+    {
+        buf[byteOffset] &= ~(1 << bitOffset);
+    }
+}
+
+void ArrayUtils::setArrayBit(unsigned char *buf, const char &bitPosition, const bool &value)
+{
+    setArrayBit((char*)buf, bitPosition, value);
+}
+
+bool ArrayUtils::getArrayBit(const char *buf, const char &bitPosition)
+{
+    char byteOffset = (char)(bitPosition / 8);
+    char bitOffset = (char)(7 - (bitPosition % 8));
+    return (buf[byteOffset] >> bitOffset) & 1 == 1;
+}
+
+bool ArrayUtils::getArrayBit(const unsigned char *buf, const char &bitPosition)
+{
+    return getArrayBit((const char *)buf, bitPosition);
+}
+
+}; // Utils
+}; // LibNfc

libnfc_cpptools/src/utils/StringUtils.cpp

@@ -0,0 +1,168 @@
+//
+// Created by robin on 6/20/16.
+//
+
+#include <algorithm>
+#include "libnfc_cpptools/StringUtils.h"
+
+namespace LibNfc
+{
+namespace Utils
+{
+
+const std::string StringUtils::hex = "0123456789abcdef";
+
+std::string StringUtils::rawToHuman(uint8_t c)
+{
+    return std::string(1, hex[c >> 4]) + std::string(1, hex[c & 0x0f]);
+}
+
+std::string StringUtils::rawToHuman(int8_t c)
+{
+    return rawToHuman((uint8_t) c);
+}
+
+std::string StringUtils::rawToHuman(uint16_t c)
+{
+    return rawToHuman((uint8_t) (c >> 8)) + rawToHuman((uint8_t) c);
+}
+
+std::string StringUtils::rawToHuman(int16_t c)
+{
+    return rawToHuman((uint16_t) c);
+}
+
+std::string StringUtils::rawToHuman(uint32_t c)
+{
+    return rawToHuman((uint16_t) (c >> 16)) + rawToHuman((uint16_t) c);
+}
+
+std::string StringUtils::rawToHuman(int32_t c)
+{
+    return rawToHuman((uint32_t) c);
+}
+
+std::string StringUtils::rawToHuman(uint64_t c)
+{
+    return rawToHuman((uint32_t) (c >> 32)) + rawToHuman((uint32_t) c);
+}
+
+std::string StringUtils::rawToHuman(int64_t c)
+{
+    return rawToHuman((uint64_t) c);
+}
+
+std::string StringUtils::rawToHuman(const std::string &raw)
+{
+    std::string human;
+    for (size_t i = 0; i < raw.size(); ++i)
+    {
+        human += rawToHuman((int8_t) raw[i]);
+    }
+    return human;
+}
+
+ResultString StringUtils::humanToRaw(const std::string &human)
+{
+    if (human.size() % 2 != 0)
+    {
+        return ResultString::error("Malformed hex data: invalid length");
+    }
+    std::string raw;
+    for (size_t i = 0; i < human.size(); i += 2)
+    {
+        char c1 = toLower(human[i]);
+        char c2 = toLower(human[i + 1]);
+        size_t i1 = hex.find(c1);
+        size_t i2 = hex.find(c2);
+        if (i1 == std::string::npos || i2 == std::string::npos)
+        {
+            return ResultString::error("Malformed hex data at char " + std::to_string(i));
+        }
+        raw += std::string(1, (char) ((i1 << 4) + i2));
+    }
+    return ResultString::ok(raw);
+}
+
+std::string StringUtils::toLower(const std::string &str)
+{
+    std::string lower;
+    for (size_t i = 0; i < str.size(); ++i)
+    {
+        lower += tolower(str[i]);
+    }
+    return lower;
+}
+
+char StringUtils::toLower(char c)
+{
+    if (c >= 'A' && c <= 'Z')
+    {
+        return c + ('a' - 'A');
+    }
+    return c;
+}
+
+std::string StringUtils::toUpper(const std::string &str)
+{
+    std::string upper;
+    for (size_t i = 0; i < str.size(); ++i)
+    {
+        upper += toUpper(str[i]);
+    }
+    return upper;
+}
+
+char StringUtils::toUpper(char c)
+{
+    if (c >= 'a' && c <= 'z')
+    {
+        return c - ('a' - 'A');
+    }
+    return c;
+}
+
+std::string StringUtils::ensureSize(const std::string &data, int size)
+{
+    if (data.size() == size)
+    {
+        return data;
+    } else if (data.size() > size)
+    {
+        return data.substr(0, size);
+    } else
+    {
+        return data + std::string(size - data.size(), '\0');
+    }
+}
+
+std::string StringUtils::ltrim(const std::string &s)
+{
+    std::string data = s;
+    data.erase(data.begin(), std::find_if(data.begin(), data.end(),
+                                          std::not1(std::ptr_fun<int, int>(std::isspace))));
+    return data;
+}
+
+std::string StringUtils::rtrim(const std::string &s)
+{
+    std::string data = s;
+    data.erase(std::find_if(data.rbegin(), data.rend(),
+                            std::not1(std::ptr_fun<int, int>(std::isspace))).base(), data.end());
+    return data;
+}
+
+std::string StringUtils::trim(const std::string &s)
+{
+    return ltrim(rtrim(s));
+}
+
+std::string StringUtils::removeSpaces(const std::string &s)
+{
+    std::string data = s;
+    data.erase(std::remove_if(data.begin(), data.end(), std::ptr_fun<int, int>(std::isspace)), data.end());
+    return data;
+}
+
+}; // Utils
+}; // LibNfc

tests/CMakeLists.txt

@@ -0,0 +1,14 @@
+enable_testing()
+include_directories(
+        ${LIBNFC_CPPTOOLS_INCLUDE_PATH}
+        )
+
+message(STATUS "include path: " ${LIBNFC_CPPTOOLS_INCLUDE_PATH})
+
+find_package (Threads)
+add_executable(${PROJECT_NAME}-test
+        test-main.cpp
+        )
+
+target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME} gtest pthread)
+add_test(${PROJECT_NAME}-test ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-test)

tests/test-main.cpp

@@ -0,0 +1,542 @@
+#include <iostream>
+#include <string.h>
+#include <gtest/gtest.h>
+#include <libnfc_cpptools/LibNfc.h>
+#include <libnfc_cpptools/StringUtils.h>
+#include <libnfc_cpptools/ArrayUtils.h>
+#include <libnfc_cpptools/FreeFareAccessBits.h>
+
+TEST(StringUtils, rawToHumanChar)
+{
+    ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int8_t)255), "ff");
+    ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int8_t)127), "7f");
+    ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int8_t)10), "0a");
+    ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int8_t)0), "00");
+}
+
+TEST(StringUtils, rawToHumanShort)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int16_t)65535), "ffff");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int16_t)65534), "fffe");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int16_t)256), "0100");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int16_t)255), "00ff");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int16_t)127), "007f");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int16_t)10), "000a");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int16_t)0), "0000");
+}
+
+TEST(StringUtils, rawToHumanInt)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int32_t)4294967295), "ffffffff");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int32_t)4294967294), "fffffffe");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int32_t)65536), "00010000");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int32_t)65535), "0000ffff");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int32_t)65534), "0000fffe");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int32_t)256), "00000100");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int32_t)255), "000000ff");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int32_t)127), "0000007f");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int32_t)10), "0000000a");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int32_t)0), "00000000");
+}
+
+TEST(StringUtils, rawToHumanLong)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)std::numeric_limits<unsigned long>::max()), "ffffffffffffffff");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)std::numeric_limits<unsigned long>::max() - 1), "fffffffffffffffe");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)4294967296), "0000000100000000");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)4294967295), "00000000ffffffff");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)4294967294), "00000000fffffffe");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)65536), "0000000000010000");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)65535), "000000000000ffff");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)65534), "000000000000fffe");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)256), "0000000000000100");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)255), "00000000000000ff");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)127), "000000000000007f");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)10), "000000000000000a");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman((int64_t)0), "0000000000000000");
+}
+
+TEST(StringUtils, rawToHumanString)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rawToHuman(std::string({0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+                                                0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f})),
+            "000102030405060708090a0b0c0d0e0f");
+}
+
+TEST(StringUtils, toLower)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toLower('a'), 'a');
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toLower('z'), 'z');
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toLower('A'), 'a');
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toLower('Z'), 'z');
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toLower('1'), '1');
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toLower('@'), '@');
+}
+
+TEST(StringUtils, toUpper)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toUpper('a'), 'A');
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toUpper('z'), 'Z');
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toUpper('A'), 'A');
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toUpper('Z'), 'Z');
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toUpper('1'), '1');
+  ASSERT_EQ(LibNfc::Utils::StringUtils::toUpper('@'), '@');
+}
+
+TEST(StringUtils, humanToRaw)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::humanToRaw("0f00").getData(), std::string({0x0f, 0x00}));
+  ASSERT_EQ(LibNfc::Utils::StringUtils::humanToRaw("000f").getData(), std::string({0x00, 0x0f}));
+  ASSERT_EQ(LibNfc::Utils::StringUtils::humanToRaw("0a0a").getData(), std::string({0x0a, 0x0a}));
+  ASSERT_EQ(LibNfc::Utils::StringUtils::humanToRaw("1a0f").getData(), std::string({0x1a, 0x0f}));
+  ASSERT_EQ(LibNfc::Utils::StringUtils::humanToRaw("1a00f").getError(), "Malformed hex data: invalid length");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::humanToRaw("1a\n00f").getError(), "Malformed hex data at char 2");
+}
+
+TEST(StringUtils, ensureSize)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::ensureSize("test", 3), "tes");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::ensureSize("test", 4), "test");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::ensureSize("test", 5), std::string({'t', 'e', 's', 't', '\0'}));
+}
+
+TEST(StringUtils, ltrim)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::ltrim("  \n 42"), "42");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::ltrim("  \n 42 \n"), "42 \n");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::ltrim("42  \n "), "42  \n ");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::ltrim(" 42 \n 42  \n "), "42 \n 42  \n ");
+}
+
+TEST(StringUtils, rtrim)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rtrim("  \n 42"), "  \n 42");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rtrim("  \n 42 \n"), "  \n 42");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rtrim("42  \n "), "42");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::rtrim(" 42 \n 42  \n "), " 42 \n 42");
+}
+
+TEST(StringUtils, trim)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::trim("  \n 42"), "42");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::trim("  \n 42 \n"), "42");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::trim("42  \n "), "42");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::trim(" 42 \n 42  \n "), "42 \n 42");
+}
+
+TEST(StringUtils, removeSpaces)
+{
+  ASSERT_EQ(LibNfc::Utils::StringUtils::removeSpaces("  \n 42"), "42");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::removeSpaces("  \n 42 \n"), "42");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::removeSpaces("42  \n "), "42");
+  ASSERT_EQ(LibNfc::Utils::StringUtils::removeSpaces(" 42 \n 42  \n "), "4242");
+}
+
+TEST(ArrayUtils, getArrayBitimple)
+{
+  const unsigned char buf[] = {0x04};
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 0));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 1));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 2));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 3));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 4));
+  ASSERT_TRUE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 5));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 6));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 7));
+}
+
+TEST(ArrayUtils, getArrayBitMultiple)
+{
+  const unsigned char buf[] = {0x80, 0x14, 0x01};
+  ASSERT_TRUE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 0));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 1));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 2));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 3));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 4));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 5));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 6));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 7));
+
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 8));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 9));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 10));
+  ASSERT_TRUE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 11));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 12));
+  ASSERT_TRUE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 13));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 14));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 15));
+
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 16));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 17));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 18));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 19));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 20));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 21));
+  ASSERT_FALSE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 22));
+  ASSERT_TRUE(LibNfc::Utils::ArrayUtils::getArrayBit(buf, 23));
+}
+
+TEST(AccessBitsDbo, getBit)
+{
+  const unsigned char buf[4] = {0x05, 0xa3, 0xcf, 0x00};
+  LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.getBit(1, 0));
+  ASSERT_TRUE(dbo.getBit(2, 0));
+  ASSERT_FALSE(dbo.getBit(3, 0));
+
+  ASSERT_TRUE(dbo.getBit(1, 1));
+  ASSERT_TRUE(dbo.getBit(2, 1));
+  ASSERT_FALSE(dbo.getBit(3, 1));
+
+  ASSERT_FALSE(dbo.getBit(1, 2));
+  ASSERT_TRUE(dbo.getBit(2, 2));
+  ASSERT_TRUE(dbo.getBit(3, 2));
+
+  ASSERT_TRUE(dbo.getBit(1, 3));
+  ASSERT_TRUE(dbo.getBit(2, 3));
+  ASSERT_TRUE(dbo.getBit(3, 3));
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisBlock1)
+{
+  const unsigned char buf[4] = {0xff, 0x0f, 0x00, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_TRUE(dbo.canKeyAReadBlock(0));
+  ASSERT_TRUE(dbo.canKeyBReadBlock(0));
+
+  ASSERT_TRUE(dbo.canKeyAWriteBlock(0));
+  ASSERT_TRUE(dbo.canKeyBWriteBlock(0));
+
+  ASSERT_TRUE(dbo.canKeyAIncrementBlock(0));
+  ASSERT_TRUE(dbo.canKeyBIncrementBlock(0));
+
+  ASSERT_TRUE(dbo.canKeyADecrementBlock(0));
+  ASSERT_TRUE(dbo.canKeyBDecrementBlock(0));
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisBlock2)
+{
+  const unsigned char buf[4] = {0xef, 0x0f, 0x01, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_TRUE(dbo.canKeyAReadBlock(0));
+  ASSERT_TRUE(dbo.canKeyBReadBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAWriteBlock(0));
+  ASSERT_FALSE(dbo.canKeyBWriteBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAIncrementBlock(0));
+  ASSERT_FALSE(dbo.canKeyBIncrementBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyADecrementBlock(0));
+  ASSERT_FALSE(dbo.canKeyBDecrementBlock(0));
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisBlock3)
+{
+  const unsigned char buf[4] = {0xfe, 0x1f, 0x00, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_TRUE(dbo.canKeyAReadBlock(0));
+  ASSERT_TRUE(dbo.canKeyBReadBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAWriteBlock(0));
+  ASSERT_TRUE(dbo.canKeyBWriteBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAIncrementBlock(0));
+  ASSERT_FALSE(dbo.canKeyBIncrementBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyADecrementBlock(0));
+  ASSERT_FALSE(dbo.canKeyBDecrementBlock(0));
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisBlock4)
+{
+  const unsigned char buf[4] = {0xee, 0x1f, 0x01, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_TRUE(dbo.canKeyAReadBlock(0));
+  ASSERT_TRUE(dbo.canKeyBReadBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAWriteBlock(0));
+  ASSERT_TRUE(dbo.canKeyBWriteBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAIncrementBlock(0));
+  ASSERT_TRUE(dbo.canKeyBIncrementBlock(0));
+
+  ASSERT_TRUE(dbo.canKeyADecrementBlock(0));
+  ASSERT_TRUE(dbo.canKeyBDecrementBlock(0));
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisBlock5)
+{
+  const unsigned char buf[4] = {0xff, 0x0e, 0x10, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_TRUE(dbo.canKeyAReadBlock(0));
+  ASSERT_TRUE(dbo.canKeyBReadBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAWriteBlock(0));
+  ASSERT_FALSE(dbo.canKeyBWriteBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAIncrementBlock(0));
+  ASSERT_FALSE(dbo.canKeyBIncrementBlock(0));
+
+  ASSERT_TRUE(dbo.canKeyADecrementBlock(0));
+  ASSERT_TRUE(dbo.canKeyBDecrementBlock(0));
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisBlock6)
+{
+  const unsigned char buf[4] = {0xef, 0x0e, 0x11, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.canKeyAReadBlock(0));
+  ASSERT_TRUE(dbo.canKeyBReadBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAWriteBlock(0));
+  ASSERT_TRUE(dbo.canKeyBWriteBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAIncrementBlock(0));
+  ASSERT_FALSE(dbo.canKeyBIncrementBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyADecrementBlock(0));
+  ASSERT_FALSE(dbo.canKeyBDecrementBlock(0));
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisBlock7)
+{
+  const unsigned char buf[4] = {0xfe, 0x1e, 0x10, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.canKeyAReadBlock(0));
+  ASSERT_TRUE(dbo.canKeyBReadBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAWriteBlock(0));
+  ASSERT_FALSE(dbo.canKeyBWriteBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAIncrementBlock(0));
+  ASSERT_FALSE(dbo.canKeyBIncrementBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyADecrementBlock(0));
+  ASSERT_FALSE(dbo.canKeyBDecrementBlock(0));
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisBlock8)
+{
+  const unsigned char buf[4] = {0xee, 0x1e, 0x11, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.canKeyAReadBlock(0));
+  ASSERT_FALSE(dbo.canKeyBReadBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAWriteBlock(0));
+  ASSERT_FALSE(dbo.canKeyBWriteBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyAIncrementBlock(0));
+  ASSERT_FALSE(dbo.canKeyBIncrementBlock(0));
+
+  ASSERT_FALSE(dbo.canKeyADecrementBlock(0));
+  ASSERT_FALSE(dbo.canKeyBDecrementBlock(0));
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer1)
+{
+  const unsigned char buf[4] = {0xff, 0x0f, 0x00, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
+
+  ASSERT_TRUE(dbo.canKeyAWriteKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyATrailer());
+
+  ASSERT_TRUE(dbo.canKeyAReadAccessBitsTrailer());
+  ASSERT_FALSE(dbo.canKeyBReadAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteAccessBitsTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteAccessBitsTrailer());
+
+  ASSERT_TRUE(dbo.canKeyAReadKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyBTrailer());
+
+  ASSERT_TRUE(dbo.canKeyAWriteKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyBTrailer());
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer2)
+{
+  const unsigned char buf[4] = {0x7f, 0x0f, 0x08, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyATrailer());
+
+  ASSERT_TRUE(dbo.canKeyAReadAccessBitsTrailer());
+  ASSERT_FALSE(dbo.canKeyBReadAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteAccessBitsTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteAccessBitsTrailer());
+
+  ASSERT_TRUE(dbo.canKeyAReadKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyBTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyBTrailer());
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer3)
+{
+  const unsigned char buf[4] = {0xf7, 0x8f, 0x00, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyATrailer());
+  ASSERT_TRUE(dbo.canKeyBWriteKeyATrailer());
+
+  ASSERT_TRUE(dbo.canKeyAReadAccessBitsTrailer());
+  ASSERT_TRUE(dbo.canKeyBReadAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteAccessBitsTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyBTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyBTrailer());
+  ASSERT_TRUE(dbo.canKeyBWriteKeyBTrailer());
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer4)
+{
+  const unsigned char buf[4] = {0x77, 0x8f, 0x08, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyATrailer());
+
+  ASSERT_TRUE(dbo.canKeyAReadAccessBitsTrailer());
+  ASSERT_TRUE(dbo.canKeyBReadAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteAccessBitsTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyBTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyBTrailer());
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer5)
+{
+  const unsigned char buf[4] = {0xff, 0x07, 0x80, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
+
+  ASSERT_TRUE(dbo.canKeyAWriteKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyATrailer());
+
+  ASSERT_TRUE(dbo.canKeyAReadAccessBitsTrailer());
+  ASSERT_FALSE(dbo.canKeyBReadAccessBitsTrailer());
+
+  ASSERT_TRUE(dbo.canKeyAWriteAccessBitsTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteAccessBitsTrailer());
+
+  ASSERT_TRUE(dbo.canKeyAReadKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyBTrailer());
+
+  ASSERT_TRUE(dbo.canKeyAWriteKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyBTrailer());
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer6)
+{
+  const unsigned char buf[4] = {0x7f, 0x07, 0x88, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyATrailer());
+  ASSERT_TRUE(dbo.canKeyBWriteKeyATrailer());
+
+  ASSERT_TRUE(dbo.canKeyAReadAccessBitsTrailer());
+  ASSERT_TRUE(dbo.canKeyBReadAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteAccessBitsTrailer());
+  ASSERT_TRUE(dbo.canKeyBWriteAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyBTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyBTrailer());
+  ASSERT_TRUE(dbo.canKeyBWriteKeyBTrailer());
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer7)
+{
+  const unsigned char buf[4] = {0xf7, 0x87, 0x80, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyATrailer());
+
+  ASSERT_TRUE(dbo.canKeyAReadAccessBitsTrailer());
+  ASSERT_TRUE(dbo.canKeyBReadAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteAccessBitsTrailer());
+  ASSERT_TRUE(dbo.canKeyBWriteAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyBTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyBTrailer());
+}
+
+TEST(AccessBitsDbo, canKeyDoThisOnThisTrailer8)
+{
+  const unsigned char buf[4] = {0x77, 0x87, 0x88, 0x00};
+    LibNfc::FreeFare::FreeFareAccessBits dbo((const char*)buf);
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyATrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyATrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyATrailer());
+
+  ASSERT_TRUE(dbo.canKeyAReadAccessBitsTrailer());
+  ASSERT_TRUE(dbo.canKeyBReadAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteAccessBitsTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteAccessBitsTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAReadKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBReadKeyBTrailer());
+
+  ASSERT_FALSE(dbo.canKeyAWriteKeyBTrailer());
+  ASSERT_FALSE(dbo.canKeyBWriteKeyBTrailer());
+}
+
+int main(int argc, char* argv[])
+{
+    std::cout << "LibNfc version: " << LibNfc::Core::LibNfcContext::getLibNfcVersion() << std::endl;
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}