AccessBits decode; tests

cli/Interface/MainClass.cpp

@@ -4,6 +4,7 @@
 
 #include <iostream>
 #include <sysexits.h>
+#include <Business/StringUtils.h>
 #include "DBO/Result.h"
 #include "Business/LibNfc.h"
 #include "Business/FreeFareDevice.h"
@@ -60,7 +61,12 @@ int MainClass::main()
     for (size_t i = 0; i < tags.getData().size(); ++i) {
         auto tag = tags.getData()[i];
         std::cout << "UID: " << tag->getUid() << std::endl;
-
+        auto sector = tag->readSector(1, StringUtils::humanToRaw("8829da9daf76").getData(), MFC_KEY_A);
+        if (!sector) {
+            sector.print();
+            return 6;
+        }
+        std::cout << "Sector 1: " << StringUtils::rawToHuman(sector.getData()) << std::endl;
     }
 
     device->close();

src/Business/FreeFareTag.cpp

@@ -2,6 +2,8 @@
 // Created by robin on 6/19/16.
 //
 
+#include <sstream>
+#include <map>
 #include "FreeFareTag.h"
 
 FreeFareTag::FreeFareTag(FreefareTag tag)
@@ -91,4 +93,4 @@ ResultString FreeFareTag::readBlock(int sector, int block, std::string key, int
 
     mifare_classic_disconnect(_tag);
     return ResultString::ok(std::string((const char*)data, sizeof(data)));
-}
+}

src/CMakeLists.txt

@@ -11,7 +11,7 @@ set(SOURCE_FILES
         Business/FreeFareDevice.h
         Business/FreeFareTag.cpp
         Business/FreeFareTag.h
-        Business/StringUtils.cpp Business/StringUtils.h)
+        Business/StringUtils.cpp Business/StringUtils.h DBO/AccessBitsDbo.cpp DBO/AccessBitsDbo.h)
 
 add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES})
 target_link_libraries(${PROJECT_NAME} ${LIBS})

src/DBO/AccessBitsDbo.cpp

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

src/DBO/AccessBitsDbo.h

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

tests/test-main.cpp

@@ -3,6 +3,7 @@
 #include <gtest/gtest.h>
 #include <Business/LibNfc.h>
 #include <Business/StringUtils.h>
+#include <DBO/AccessBitsDbo.h>
 
 TEST(StringUtils, rawToHumanChar)
 {
@@ -91,6 +92,216 @@ TEST(StringUtils, humanToRaw)
   ASSERT_EQ(StringUtils::humanToRaw("1a\n00f").getError(), "Malformed hex data at char 2");
 }
 
+TEST(AccessBitsDbo, getArrayBitimple)
+{
+  const unsigned char buf[] = {0x04};
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 0));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 1));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 2));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 3));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 4));
+  ASSERT_TRUE(AccessBitsDbo::getArrayBit(buf, 5));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 6));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 7));
+}
+
+TEST(AccessBitsDbo, getArrayBitMultiple)
+{
+  const unsigned char buf[] = {0x80, 0x14, 0x01};
+  ASSERT_TRUE(AccessBitsDbo::getArrayBit(buf, 0));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 1));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 2));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 3));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 4));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 5));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 6));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 7));
+
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 8));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 9));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 10));
+  ASSERT_TRUE(AccessBitsDbo::getArrayBit(buf, 11));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 12));
+  ASSERT_TRUE(AccessBitsDbo::getArrayBit(buf, 13));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 14));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 15));
+
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 16));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 17));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 18));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 19));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 20));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 21));
+  ASSERT_FALSE(AccessBitsDbo::getArrayBit(buf, 22));
+  ASSERT_TRUE(AccessBitsDbo::getArrayBit(buf, 23));
+}
+
+TEST(AccessBitsDbo, getBit)
+{
+  const unsigned char buf[4] = {0x05, 0xa3, 0xcf, 0x00};
+  AccessBitsDbo 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};
+  AccessBitsDbo 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};
+  AccessBitsDbo 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};
+  AccessBitsDbo 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};
+  AccessBitsDbo 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};
+  AccessBitsDbo 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};
+  AccessBitsDbo 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};
+  AccessBitsDbo 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};
+  AccessBitsDbo 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));
+}
+
 int main(int argc, char* argv[])
 {
     std::cout << "LibNfc version: " << LibNfc::getVersion() << std::endl;