fixed authentication to sector

cli/Interface/MainClass.cpp

 //    std::vector<std::string> keys;
 //    keys.push_back(StringUtils::humanToRaw("8829da9daf76").getData());
 //    keys.push_back(StringUtils::humanToRaw("ffffffffffff").getData());
-//    keys.push_back(StringUtils::humanToRaw("484558414354").getData());
+    keys.push_back(StringUtils::humanToRaw("484558414354").getData());
 
     int res = dump(tag, keys);
 //    int res = mapKeys(tag, keys);
 
 int MainClass::mapKeys(std::shared_ptr<FreeFareTagBusiness> tag, std::vector<std::string> keys)
 {
-    auto mappedKeysResult = tag->mapKeys(keys, printPercent);
-    std::cout << "\r";
+    auto mappedKeysResult = tag->mapKeys(keys, printPercentMapKeys);
+    if (isatty(1)) {
+        std::cout << "\r";
+    }
     if (!mappedKeysResult) {
         mappedKeysResult.print();
     }
     else {
         auto mappedKeys = mappedKeysResult.getData();
         for (int s = 0; s < mappedKeys.size(); ++s) {
-            auto sectorKeys = mappedKeys[s];
+            auto sectorKey = mappedKeys[s];
             std::cout << "+Sector: " << s << std::endl;
-            for (int b = 0; b < sectorKeys.size(); ++b) {
-                auto blockKeys = sectorKeys[b];
+            for (int b = 0; b < 4; ++b) {
                 std::cout << "+Block: " << b << std::endl;
-                std::cout << "Key A: " << StringUtils::rawToHuman(blockKeys.first) << std::endl;
-                std::cout << "Key B: " << StringUtils::rawToHuman(blockKeys.second) << std::endl;
+                std::cout << "Key A: " << StringUtils::rawToHuman(sectorKey.first) << std::endl;
+                std::cout << "Key B: " << StringUtils::rawToHuman(sectorKey.second) << std::endl;
             }
         }
     }
 
 int MainClass::dump(std::shared_ptr<FreeFareTagBusiness> tag, std::vector<std::string> keys)
 {
-    auto dumpResult = tag->dump(keys, printPercent, printPercent);
-    std::cout << "\r";
+    auto dumpResult = tag->dump(keys, printPercentMapKeys, printPercentDump);
+    if (isatty(1)) {
+        std::cout << "\r";
+    }
     if (!dumpResult) {
         dumpResult.print();
         return 7;
 
 void MainClass::printBlockAccessBits(const AccessBitsDbo &accessBits, int block)
 {
-    std::cout << "read: " << (accessBits.canKeyAReadBlock(block) ? "A" : "") << (accessBits.canKeyBReadBlock(block) ? "B" : "");
-    std::cout << "\t write: " << (accessBits.canKeyAWriteBlock(block) ? "A" : "") << (accessBits.canKeyBWriteBlock(block) ? "B" : "");
-    std::cout << "\t increment: " << (accessBits.canKeyAIncrementBlock(block) ? "A" : "") << (accessBits.canKeyBIncrementBlock(block) ? "B" : "");
-    std::cout << "\t decrement: " << (accessBits.canKeyADecrementBlock(block) ? "A" : "") << (accessBits.canKeyBDecrementBlock(block) ? "B" : "") << std::endl;
+    std::cout << "read: " << (accessBits.canKeyAReadBlock(block) ? "A" : " ") << (accessBits.canKeyBReadBlock(block) ? "B" : " ");
+    std::cout << "\t write: " << (accessBits.canKeyAWriteBlock(block) ? "A" : " ") << (accessBits.canKeyBWriteBlock(block) ? "B" : " ");
+    std::cout << "\t increment: " << (accessBits.canKeyAIncrementBlock(block) ? "A" : " ") << (accessBits.canKeyBIncrementBlock(block) ? "B" : " ");
+    std::cout << "\t decrement: " << (accessBits.canKeyADecrementBlock(block) ? "A" : " ") << (accessBits.canKeyBDecrementBlock(block) ? "B" : " ") << std::endl;
 }
 
 void MainClass::printTrailerAccessBits(const AccessBitsDbo &accessBits)
 {
-    std::cout << "key A read: " << (accessBits.canKeyAReadKeyATrailer() ? "A" : "") << (accessBits.canKeyBReadKeyATrailer() ? "B" : "");
-    std::cout << "\t key A write: " << (accessBits.canKeyAWriteKeyATrailer() ? "A" : "") << (accessBits.canKeyBWriteKeyATrailer() ? "B" : "");
+    std::cout << "key A read: " << (accessBits.canKeyAReadKeyATrailer() ? "A" : " ") << (accessBits.canKeyBReadKeyATrailer() ? "B" : " ");
+    std::cout << "\t key A write: " << (accessBits.canKeyAWriteKeyATrailer() ? "A" : " ") << (accessBits.canKeyBWriteKeyATrailer() ? "B" : " ");
 
-    std::cout << "\t AC bits read: " << (accessBits.canKeyAReadAccessBitsTrailer() ? "A" : "") << (accessBits.canKeyBReadAccessBitsTrailer() ? "B" : "");
-    std::cout << "\t AC bits write: " << (accessBits.canKeyAWriteAccessBitsTrailer() ? "A" : "") << (accessBits.canKeyBWriteAccessBitsTrailer() ? "B" : "");
+    std::cout << "\t AC bits read: " << (accessBits.canKeyAReadAccessBitsTrailer() ? "A" : " ") << (accessBits.canKeyBReadAccessBitsTrailer() ? "B" : " ");
+    std::cout << "\t AC bits write: " << (accessBits.canKeyAWriteAccessBitsTrailer() ? "A" : " ") << (accessBits.canKeyBWriteAccessBitsTrailer() ? "B" : " ");
 
-    std::cout << "\t key B read: " << (accessBits.canKeyAReadKeyBTrailer() ? "A" : "") << (accessBits.canKeyBReadKeyBTrailer() ? "B" : "");
-    std::cout << "\t key B write: " << (accessBits.canKeyAWriteKeyBTrailer() ? "A" : "") << (accessBits.canKeyBWriteKeyBTrailer() ? "B" : "") << std::endl;;
+    std::cout << "\t key B read: " << (accessBits.canKeyAReadKeyBTrailer() ? "A" : " ") << (accessBits.canKeyBReadKeyBTrailer() ? "B" : " ");
+    std::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(1)) {
+        std::cout << "\r\033[2K" << header << ": " << std::fixed << std::setprecision(1)
+        << ((float) done / (float) total * 100.0) << "%" << std::flush;
+    }
+//    std::cout << std::fixed << std::setprecision(1) << ((float)done / (float)total * 100.0) << "%" << std::endl;
+}
+
+void MainClass::printPercentMapKeys(int done, int total)
+{
+    printPercent(done, total, "Mapping keys");
 }
 
-void MainClass::printPercent(int done, int total)
+void MainClass::printPercentDump(int done, int total)
 {
-    std::cout << "\r\033[2K" << std::fixed << std::setprecision(1) << ((float)done / (float)total * 100.0) << "%" << std::flush;
+    printPercent(done, total, "Dumping");
 }
 
 void MainClass::printVersion() const

cli/Interface/MainClass.h

 
     void printVersion() const;
 
-    static void printPercent(int done, int total);
+    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);
 
 private:
     int _argc;

src/Business/FreeFareTagBusiness.cpp

 {
 }
 
-ResultBool FreeFareTagBusiness::authenticate(int sector, int block, std::string key, int keyType)
+ResultBool FreeFareTagBusiness::authenticate(int sector, std::string key, int keyType)
 {
-    return _tag->authenticate(sector, block, key, keyType);
+    return _tag->authenticate(sector, key, keyType);
 }
 
 ResultString FreeFareTagBusiness::readBlock(int sector, int block, std::string key, int keyType)
 
 Result<MappedKeys> FreeFareTagBusiness::mapKeys(std::vector<std::string> keys, std::function<void(int, int)> cb)
 {
-    std::vector<std::vector<std::pair<std::string, std::string>>> mappedKeys;
+    MappedKeys mappedKeys;
 
     for (int i = 0; i < 16; ++i) {
-        std::vector<std::pair<std::string, std::string>> sectorKeys;
-        for (int j = 0; j < 4; ++j) {
-            std::pair<std::string, std::string> blockKeys;
-            for (int k = 0; k < keys.size(); ++k) {
-                auto key = keys[k];
-                if (authenticate(i, j, key, MFC_KEY_A)) {
-                    blockKeys.first = key;
-                }
-                if (authenticate(i, j, key, MFC_KEY_B)) {
-                    blockKeys.second = key;
-                }
-                if (cb != 0) {
-                    cb((i * 4 * keys.size()) + (j * keys.size()) + k + 1, 16 * 4 * keys.size());
-                }
-                if (!blockKeys.first.empty() && !blockKeys.second.empty()) {
-                    break;
-                }
+        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((i * keys.size()) + k + 1, 16 * keys.size());
+            }
+            if (!blockKeys.first.empty() && !blockKeys.second.empty()) {
+                break;
             }
-            sectorKeys.push_back(blockKeys);
         }
-        mappedKeys.push_back(sectorKeys);
+        mappedKeys.push_back(blockKeys);
     }
 
-    return Result<std::vector<std::vector<std::pair<std::string, std::string>>>>::ok(mappedKeys);
+    return Result<MappedKeys>::ok(mappedKeys);
 }
 
 Result<std::vector<SectorDbo>> FreeFareTagBusiness::dump(MappedKeys keys, std::function<void(int, int)> cb)
     if (keys.size() != 16) {
         return Result<std::vector<SectorDbo>>::error("Must have 16 sectors");
     }
-    for (int i = 0; i < keys.size(); ++i) {
-        auto key = keys[i];
-        if (key.size() != 4) {
-            return Result<std::vector<SectorDbo>>::error("Must have 4 keys in sector " + i);
-        }
-    }
     std::vector<SectorDbo> sectors;
     for (int s = 0; s < keys.size(); ++s) {
-        auto sectorKeys = keys[s];
+        auto sectorKey = keys[s];
         SectorDbo sector;
         bool keyA = false;
         bool keyB = false;
-        for (int b = 0; b < sectorKeys.size() - 1; ++b) {
-            auto blockKey = sectorKeys[b];
+        for (int b = 0; b < 3; ++b) {
             std::string data = "";
-            if (!blockKey.first.empty()) {
-                auto blockResult = readBlock(s, b, blockKey.first, MFC_KEY_A);
+            if (!sectorKey.first.empty()) {
+                auto blockResult = readBlock(s, b, sectorKey.first, MFC_KEY_A);
                 if (blockResult) {
                     data = blockResult.getData();
                     keyA = true;
                 }
             }
-            if (!blockKey.second.empty()) {
-                auto blockResult = readBlock(s, b, blockKey.second, MFC_KEY_B);
+            if (!sectorKey.second.empty()) {
+                auto blockResult = readBlock(s, b, sectorKey.second, MFC_KEY_B);
                 if (blockResult) {
                     if (data.empty()) {
                         data = blockResult.getData();
             }
             sector.setBlock(b, data);
             if (cb != 0) {
-                cb((s * sectorKeys.size()) + b + 1, keys.size() * sectorKeys.size());
+                cb((s * 4) + b + 1, keys.size() * 4);
             }
         }
-        int b = sectorKeys.size() - 1;
-        auto blockKey = sectorKeys[b];
+        int b = 3;
         std::string dataA = "";
         std::string dataB = "";
-        if (!blockKey.first.empty()) {
-            auto blockResult = readBlock(s, b, blockKey.first, MFC_KEY_A);
+        if (!sectorKey.first.empty()) {
+            auto blockResult = readBlock(s, b, sectorKey.first, MFC_KEY_A);
             if (blockResult) {
                 dataA = blockResult.getData();
                 keyA = true;
             }
         }
-        if (!blockKey.second.empty()) {
-            auto blockResult = readBlock(s, b, blockKey.second, MFC_KEY_B);
+        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((s * sectorKeys.size()) + b + 1, keys.size() * sectorKeys.size());
+            cb((s * 4) + b + 1, keys.size() * 4);
         }
 
         sector.setBlock(b, dataA);
         AccessBitsDbo accessBitsDboA = sector.getAccessBitsDbo();
         sector.setBlock(b, dataB);
         AccessBitsDbo accessBitsDboB = sector.getAccessBitsDbo();
-        sector.setKeyA(keyA ? blockKey.first : "");
-        sector.setKeyB(keyB ? blockKey.second : "");
+        sector.setKeyA(keyA ? sectorKey.first : "");
+        sector.setKeyB(keyB ? sectorKey.second : "");
 
         std::string accessBits;
         if (keyA && accessBitsDboA.canKeyAReadAccessBitsTrailer()) {

src/Business/FreeFareTagBusiness.h

 #include <DataAccess/FreeFareTag.h>
 #include <DataAccess/SectorDbo.h>
 
-typedef std::vector<std::vector<std::pair<std::string, std::string>>> MappedKeys;
+typedef std::vector<std::pair<std::string, std::string>> MappedKeys;
 
 class FreeFareTagBusiness
 {
 public:
     FreeFareTagBusiness(std::shared_ptr<FreeFareTag> tag);
 
-    ResultBool authenticate(int sector, int block, std::string key, int keyType);
+    ResultBool authenticate(int sector, std::string key, int keyType);
 
     ResultString readBlock(int sector, int block, std::string key, int keyType);
 

src/DataAccess/FreeFareTag.cpp

     freefare_free_tag(_tag);
 }
 
-ResultBool FreeFareTag::authenticate(int sector, int block, std::string key, int keyType)
+ResultBool FreeFareTag::authenticate(int sector, std::string key, int keyType)
 {
+
     if (mifare_classic_connect(_tag) != 0) {
         return ResultBool::error("Failed to connect to MIFARE tag");
     }
-
-    block = mifare_classic_sector_first_block((MifareClassicBlockNumber)sector) + block;
+    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 ResultBool::error("Failed to authenticate to MIFARE tag");
     }
-
     mifare_classic_disconnect(_tag);
     return ResultBool::ok(true);
 }
 
 ResultString FreeFareTag::readBlock(int sector, int block, std::string key, int keyType)
 {
+
     if (mifare_classic_connect(_tag) != 0) {
         return 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) {
     if (mifare_classic_read(_tag, (MifareClassicBlockNumber)block, &data)) {
         return ResultString::error("Failed to read MIFARE tag data");
     }
-
     mifare_classic_disconnect(_tag);
     return ResultString::ok(std::string((const char*)data, sizeof(data)));
 }

src/DataAccess/FreeFareTag.h

     FreeFareTag(FreefareTag tag);
     ~FreeFareTag();
 
-    ResultBool authenticate(int sector, int block, std::string key, int keyType);
+    ResultBool authenticate(int sector, std::string key, int keyType);
 
     ResultString readBlock(int sector, int block, std::string key, int keyType);