Merge remote-tracking branch 'origin/master' into PenturaLabs-iclass-research

diff --git a/.gitattributes b/.gitattributes
new file mode 100644 (file)
index 0000000..ef225ce
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,4 @@
+# .gitattributes
+# prevent binary files from CRLF handling, diff and merge:
+fpga/fpga.bit -crlf -diff
+ 
\ No newline at end of file

diff --git a/.gitignore b/.gitignore
index ea93d61f674061c741675128472a807978a71b81..07669e14a240ae9125fef7ea6cc66387cae3211b 100644 (file)
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,8 @@
 # .gitignore
 # don't push these files to the repository
 
+*.log
+*.eml
 *.o
 *.a
 *.d

diff --git a/armsrc/iso14443a.c b/armsrc/iso14443a.c
index d5dd05ca14be2eaed5a0db7df78ace80df5c0df4..9a80a17723b3ca4e6a4f392a21fc4166d5b8a9f2 100644 (file)
--- a/armsrc/iso14443a.c
+++ b/armsrc/iso14443a.c
@@ -507,6 +507,7 @@ void RAMFUNC SnoopIso14443a(uint8_t param) {
        LEDsoff();
        // init trace buffer
        iso14a_clear_trace();
+       iso14a_set_tracing(TRUE);
 
        // We won't start recording the frames that we acquire until we trigger;
        // a good trigger condition to get started is probably when we see a
@@ -1861,10 +1862,9 @@ void ReaderIso14443a(UsbCommand *c)
                if(param & ISO14A_APPEND_CRC) {
                        AppendCrc14443a(cmd,len);
                        len += 2;
-                       lenbits += 16;
+                       if (lenbits) lenbits += 16;
                }
                if(lenbits>0) {
-
                        ReaderTransmitBitsPar(cmd,lenbits,GetParity(cmd,lenbits/8), NULL);
                } else {
                        ReaderTransmit(cmd,len, NULL);
@@ -2206,9 +2206,12 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
 
        if (MF_DBGLEVEL >= 1)   {
                if (!_7BUID) {
-                       Dbprintf("4B UID: %02x%02x%02x%02x",rUIDBCC1[0] , rUIDBCC1[1] , rUIDBCC1[2] , rUIDBCC1[3]);
+                       Dbprintf("4B UID: %02x%02x%02x%02x", 
+                               rUIDBCC1[0], rUIDBCC1[1], rUIDBCC1[2], rUIDBCC1[3]);
                } else {
-                       Dbprintf("7B UID: (%02x)%02x%02x%02x%02x%02x%02x%02x",rUIDBCC1[0] , rUIDBCC1[1] , rUIDBCC1[2] , rUIDBCC1[3],rUIDBCC2[0],rUIDBCC2[1] ,rUIDBCC2[2] , rUIDBCC2[3]);
+                       Dbprintf("7B UID: (%02x)%02x%02x%02x%02x%02x%02x%02x",
+                               rUIDBCC1[0], rUIDBCC1[1], rUIDBCC1[2], rUIDBCC1[3],
+                               rUIDBCC2[0], rUIDBCC2[1] ,rUIDBCC2[2], rUIDBCC2[3]);
                }
        }
 
@@ -2276,7 +2279,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
                                // select card
                                if (len == 9 && 
                                                (receivedCmd[0] == 0x93 && receivedCmd[1] == 0x70 && memcmp(&receivedCmd[2], rUIDBCC1, 4) == 0)) {
-                                       EmSendCmd(_7BUID?rSAK1:rSAK, sizeof(_7BUID?rSAK1:rSAK));
+                                       EmSendCmd(_7BUID?rSAK1:rSAK, _7BUID?sizeof(rSAK1):sizeof(rSAK));
                                        cuid = bytes_to_num(rUIDBCC1, 4);
                                        if (!_7BUID) {
                                                cardSTATE = MFEMUL_WORK;
@@ -2318,10 +2321,13 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
 
                                // test if auth OK
                                if (cardRr != prng_successor(nonce, 64)){
-                                       if (MF_DBGLEVEL >= 2)   Dbprintf("AUTH FAILED. cardRr=%08x, succ=%08x",cardRr, prng_successor(nonce, 64));
+                                       if (MF_DBGLEVEL >= 2) Dbprintf("AUTH FAILED for sector %d with key %c. cardRr=%08x, succ=%08x",
+                                                       cardAUTHSC, cardAUTHKEY == 0 ? 'A' : 'B',
+                                                       cardRr, prng_successor(nonce, 64));
                                        // Shouldn't we respond anything here?
                                        // Right now, we don't nack or anything, which causes the
                                        // reader to do a WUPA after a while. /Martin
+                                       // -- which is the correct response. /piwi
                                        cardSTATE_TO_IDLE();
                                        LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parityBits, TRUE);
                                        LogTrace(NULL, 0, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, 0, TRUE);
@@ -2335,7 +2341,9 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
                                EmSendCmd(rAUTH_AT, sizeof(rAUTH_AT));
                                LED_C_ON();
                                cardSTATE = MFEMUL_WORK;
-                               if (MF_DBGLEVEL >= 4)   Dbprintf("AUTH COMPLETED. sector=%d, key=%d time=%d", cardAUTHSC, cardAUTHKEY, GetTickCount() - authTimer);
+                               if (MF_DBGLEVEL >= 4)   Dbprintf("AUTH COMPLETED for sector %d with key %c. time=%d", 
+                                       cardAUTHSC, cardAUTHKEY == 0 ? 'A' : 'B',
+                                       GetTickCount() - authTimer);
                                break;
                        }
                        case MFEMUL_SELECT2:{
@@ -2393,12 +2401,12 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
                                        crypto1_create(pcs, emlGetKey(cardAUTHSC, cardAUTHKEY));
 
                                        if (!encrypted_data) { // first authentication
-                                               if (MF_DBGLEVEL >= 2) Dbprintf("Reader authenticating for block %d (0x%02x) with key %d",receivedCmd[1] ,receivedCmd[1],cardAUTHKEY  );
+                                               if (MF_DBGLEVEL >= 4) Dbprintf("Reader authenticating for block %d (0x%02x) with key %d",receivedCmd[1] ,receivedCmd[1],cardAUTHKEY  );
 
                                                crypto1_word(pcs, cuid ^ nonce, 0);//Update crypto state
                                                num_to_bytes(nonce, 4, rAUTH_AT); // Send nonce
                                        } else { // nested authentication
-                                               if (MF_DBGLEVEL >= 2) Dbprintf("Reader doing nested authentication for block %d (0x%02x) with key %d",receivedCmd[1] ,receivedCmd[1],cardAUTHKEY );
+                                               if (MF_DBGLEVEL >= 4) Dbprintf("Reader doing nested authentication for block %d (0x%02x) with key %d",receivedCmd[1] ,receivedCmd[1],cardAUTHKEY );
                                                ans = nonce ^ crypto1_word(pcs, cuid ^ nonce, 0); 
                                                num_to_bytes(ans, 4, rAUTH_AT);
                                        }
@@ -2429,9 +2437,9 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
 
                                if(receivedCmd[0] == 0x30 // read block
                                                || receivedCmd[0] == 0xA0 // write block
-                                               || receivedCmd[0] == 0xC0
-                                               || receivedCmd[0] == 0xC1
-                                               || receivedCmd[0] == 0xC2 // inc dec restore
+                                               || receivedCmd[0] == 0xC0 // inc
+                                               || receivedCmd[0] == 0xC1 // dec
+                                               || receivedCmd[0] == 0xC2 // restore
                                                || receivedCmd[0] == 0xB0) { // transfer
                                        if (receivedCmd[1] >= 16 * 4) {
                                                EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
@@ -2447,7 +2455,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
                                }
                                // read block
                                if (receivedCmd[0] == 0x30) {
-                                       if (MF_DBGLEVEL >= 2) {
+                                       if (MF_DBGLEVEL >= 4) {
                                                Dbprintf("Reader reading block %d (0x%02x)",receivedCmd[1],receivedCmd[1]);
                                        }
                                        emlGetMem(response, receivedCmd[1], 1);
@@ -2463,7 +2471,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
                                }
                                // write block
                                if (receivedCmd[0] == 0xA0) {
-                                       if (MF_DBGLEVEL >= 2) Dbprintf("RECV 0xA0 write block %d (%02x)",receivedCmd[1],receivedCmd[1]);
+                                       if (MF_DBGLEVEL >= 4) Dbprintf("RECV 0xA0 write block %d (%02x)",receivedCmd[1],receivedCmd[1]);
                                        EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));
                                        cardSTATE = MFEMUL_WRITEBL2;
                                        cardWRBL = receivedCmd[1];
@@ -2471,7 +2479,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
                                }
                                // increment, decrement, restore
                                if (receivedCmd[0] == 0xC0 || receivedCmd[0] == 0xC1 || receivedCmd[0] == 0xC2) {
-                                       if (MF_DBGLEVEL >= 2) Dbprintf("RECV 0x%02x inc(0xC1)/dec(0xC0)/restore(0xC2) block %d (%02x)",receivedCmd[0],receivedCmd[1],receivedCmd[1]);
+                                       if (MF_DBGLEVEL >= 4) Dbprintf("RECV 0x%02x inc(0xC1)/dec(0xC0)/restore(0xC2) block %d (%02x)",receivedCmd[0],receivedCmd[1],receivedCmd[1]);
                                        if (emlCheckValBl(receivedCmd[1])) {
                                                if (MF_DBGLEVEL >= 2) Dbprintf("Reader tried to operate on block, but emlCheckValBl failed, nacking");
                                                EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
@@ -2489,7 +2497,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
                                }
                                // transfer
                                if (receivedCmd[0] == 0xB0) {
-                                       if (MF_DBGLEVEL >= 2) Dbprintf("RECV 0x%02x transfer block %d (%02x)",receivedCmd[0],receivedCmd[1],receivedCmd[1]);
+                                       if (MF_DBGLEVEL >= 4) Dbprintf("RECV 0x%02x transfer block %d (%02x)",receivedCmd[0],receivedCmd[1],receivedCmd[1]);
                                        if (emlSetValBl(cardINTREG, cardINTBLOCK, receivedCmd[1]))
                                                EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
                                        else
@@ -2624,7 +2632,8 @@ void RAMFUNC SniffMifare(uint8_t param) {
        // C(red) A(yellow) B(green)
        LEDsoff();
        // init trace buffer
-    iso14a_clear_trace();
+       iso14a_clear_trace();
+       iso14a_set_tracing(TRUE);
 
        // The command (reader -> tag) that we're receiving.
        // The length of a received command will in most cases be no more than 18 bytes.

diff --git a/armsrc/mifarecmd.c b/armsrc/mifarecmd.c
index 6a491b532a73739aaf9da9540fe5014fab2bbe91..42dee56ec96ae1a2cdf940a18b00e4ad33b9004c 100644 (file)
--- a/armsrc/mifarecmd.c
+++ b/armsrc/mifarecmd.c
@@ -14,7 +14,7 @@
 #include "apps.h"\r
 \r
 //-----------------------------------------------------------------------------\r
-// Select, Authenticaate, Read an MIFARE tag. \r
+// Select, Authenticate, Read a MIFARE tag. \r
 // read block\r
 //-----------------------------------------------------------------------------\r
 void MifareReadBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)\r
@@ -35,7 +35,7 @@ void MifareReadBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        pcs = &mpcs;\r
 \r
        // clear trace\r
-       iso14a_clear_trace();\r
+       iso14a_clear_trace();\r
 //     iso14a_set_tracing(false);\r
 \r
        iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN);\r
@@ -46,22 +46,22 @@ void MifareReadBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
 \r
        while (true) {\r
                if(!iso14443a_select_card(uid, NULL, &cuid)) {\r
-               if (MF_DBGLEVEL >= 1)   Dbprintf("Can't select card");\r
+                       if (MF_DBGLEVEL >= 1)   Dbprintf("Can't select card");\r
                        break;\r
                };\r
 \r
                if(mifare_classic_auth(pcs, cuid, blockNo, keyType, ui64Key, AUTH_FIRST)) {\r
-               if (MF_DBGLEVEL >= 1)   Dbprintf("Auth error");\r
+                       if (MF_DBGLEVEL >= 1)   Dbprintf("Auth error");\r
                        break;\r
                };\r
                \r
                if(mifare_classic_readblock(pcs, cuid, blockNo, dataoutbuf)) {\r
-               if (MF_DBGLEVEL >= 1)   Dbprintf("Read block error");\r
+                       if (MF_DBGLEVEL >= 1)   Dbprintf("Read block error");\r
                        break;\r
                };\r
 \r
                if(mifare_classic_halt(pcs, cuid)) {\r
-               if (MF_DBGLEVEL >= 1)   Dbprintf("Halt error");\r
+                       if (MF_DBGLEVEL >= 1)   Dbprintf("Halt error");\r
                        break;\r
                };\r
                \r
@@ -74,20 +74,11 @@ void MifareReadBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        \r
        if (MF_DBGLEVEL >= 2)   DbpString("READ BLOCK FINISHED");\r
 \r
-       // add trace trailer\r
-       memset(uid, 0x44, 4);\r
-       LogTrace(uid, 4, 0, 0, TRUE);\r
-\r
-//     UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};\r
-//     memcpy(ack.d.asBytes, dataoutbuf, 16);\r
-       \r
        LED_B_ON();\r
-  cmd_send(CMD_ACK,isOK,0,0,dataoutbuf,16);\r
-//     UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));\r
+       cmd_send(CMD_ACK,isOK,0,0,dataoutbuf,16);\r
        LED_B_OFF();\r
 \r
-\r
-  // Thats it...\r
+       // Thats it...\r
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);\r
        LEDsoff();\r
 //  iso14a_set_tracing(TRUE);\r
@@ -148,9 +139,10 @@ void MifareUReadBlock(uint8_t arg0,uint8_t *datain)
        LEDsoff();\r
 }\r
 \r
+\r
 //-----------------------------------------------------------------------------\r
-// Select, Authenticaate, Read an MIFARE tag. \r
-// read sector (data = 4 x 16 bytes = 64 bytes)\r
+// Select, Authenticate, Read a MIFARE tag. \r
+// read sector (data = 4 x 16 bytes = 64 bytes, or 16 x 16 bytes = 256 bytes)\r
 //-----------------------------------------------------------------------------\r
 void MifareReadSector(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)\r
 {\r
@@ -161,8 +153,8 @@ void MifareReadSector(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        ui64Key = bytes_to_num(datain, 6);\r
        \r
        // variables\r
-       byte_t isOK = 0;\r
-       byte_t dataoutbuf[16 * 4];\r
+       byte_t isOK;\r
+       byte_t dataoutbuf[16 * 16];\r
        uint8_t uid[10];\r
        uint32_t cuid;\r
        struct Crypto1State mpcs = {0, 0};\r
@@ -170,7 +162,7 @@ void MifareReadSector(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        pcs = &mpcs;\r
 \r
        // clear trace\r
-       iso14a_clear_trace();\r
+       iso14a_clear_trace();\r
 //     iso14a_set_tracing(false);\r
 \r
        iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN);\r
@@ -179,72 +171,47 @@ void MifareReadSector(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        LED_B_OFF();\r
        LED_C_OFF();\r
 \r
-       while (true) {\r
-               if(!iso14443a_select_card(uid, NULL, &cuid)) {\r
+       isOK = 1;\r
+       if(!iso14443a_select_card(uid, NULL, &cuid)) {\r
+               isOK = 0;\r
                if (MF_DBGLEVEL >= 1)   Dbprintf("Can't select card");\r
-                       break;\r
-               };\r
+       }\r
 \r
-               if(mifare_classic_auth(pcs, cuid, sectorNo * 4, keyType, ui64Key, AUTH_FIRST)) {\r
+       \r
+       if(isOK && mifare_classic_auth(pcs, cuid, FirstBlockOfSector(sectorNo), keyType, ui64Key, AUTH_FIRST)) {\r
+               isOK = 0;\r
                if (MF_DBGLEVEL >= 1)   Dbprintf("Auth error");\r
+       }\r
+       \r
+       for (uint8_t blockNo = 0; isOK && blockNo < NumBlocksPerSector(sectorNo); blockNo++) {\r
+               if(mifare_classic_readblock(pcs, cuid, FirstBlockOfSector(sectorNo) + blockNo, dataoutbuf + 16 * blockNo)) {\r
+                       isOK = 0;\r
+                       if (MF_DBGLEVEL >= 1)   Dbprintf("Read sector %2d block %2d error", sectorNo, blockNo);\r
                        break;\r
-               };\r
-               \r
-               if(mifare_classic_readblock(pcs, cuid, sectorNo * 4 + 0, dataoutbuf + 16 * 0)) {\r
-               if (MF_DBGLEVEL >= 1)   Dbprintf("Read block 0 error");\r
-                       break;\r
-               };\r
-               if(mifare_classic_readblock(pcs, cuid, sectorNo * 4 + 1, dataoutbuf + 16 * 1)) {\r
-               if (MF_DBGLEVEL >= 1)   Dbprintf("Read block 1 error");\r
-                       break;\r
-               };\r
-               if(mifare_classic_readblock(pcs, cuid, sectorNo * 4 + 2, dataoutbuf + 16 * 2)) {\r
-               if (MF_DBGLEVEL >= 1)   Dbprintf("Read block 2 error");\r
-                       break;\r
-               };\r
-               if(mifare_classic_readblock(pcs, cuid, sectorNo * 4 + 3, dataoutbuf + 16 * 3)) {\r
-               if (MF_DBGLEVEL >= 1)   Dbprintf("Read block 3 error");\r
-                       break;\r
-               };\r
+               }\r
+       }\r
                \r
-               if(mifare_classic_halt(pcs, cuid)) {\r
+       if(mifare_classic_halt(pcs, cuid)) {\r
                if (MF_DBGLEVEL >= 1)   Dbprintf("Halt error");\r
-                       break;\r
-               };\r
-\r
-               isOK = 1;\r
-               break;\r
        }\r
+\r
        \r
        //  ----------------------------- crypto1 destroy\r
        crypto1_destroy(pcs);\r
        \r
        if (MF_DBGLEVEL >= 2) DbpString("READ SECTOR FINISHED");\r
 \r
-       // add trace trailer\r
-       memset(uid, 0x44, 4);\r
-       LogTrace(uid, 4, 0, 0, TRUE);\r
-\r
-//     UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};\r
-//     memcpy(ack.d.asBytes, dataoutbuf, 16 * 2);\r
-       \r
        LED_B_ON();\r
-  cmd_send(CMD_ACK,isOK,0,0,dataoutbuf,32);\r
-//     UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));\r
-//     SpinDelay(100);\r
-       \r
-//     memcpy(ack.d.asBytes, dataoutbuf + 16 * 2, 16 * 2);\r
-//     UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));\r
-  cmd_send(CMD_ACK,isOK,0,0,dataoutbuf+32, 32);\r
+       cmd_send(CMD_ACK,isOK,0,0,dataoutbuf,16*NumBlocksPerSector(sectorNo));\r
        LED_B_OFF();\r
 \r
        // Thats it...\r
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);\r
        LEDsoff();\r
 //  iso14a_set_tracing(TRUE);\r
-\r
 }\r
 \r
+\r
 void MifareUReadCard(uint8_t arg0, uint8_t *datain)\r
 {\r
   // params\r
@@ -288,25 +255,19 @@ void MifareUReadCard(uint8_t arg0, uint8_t *datain)
         \r
         if (MF_DBGLEVEL >= 2) DbpString("READ CARD FINISHED");\r
 \r
-        // add trace trailer\r
-        memset(uid, 0x44, 4);\r
-        LogTrace(uid, 4, 0, 0, TRUE);\r
-        \r
         LED_B_ON();\r
                cmd_send(CMD_ACK,isOK,0,0,dataoutbuf,64);\r
-  //cmd_send(CMD_ACK,isOK,0,0,dataoutbuf+32, 32);\r
         LED_B_OFF();\r
 \r
         // Thats it...\r
         FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);\r
         LEDsoff();\r
-//  iso14a_set_tracing(TRUE);\r
 \r
 }\r
 \r
 \r
 //-----------------------------------------------------------------------------\r
-// Select, Authenticaate, Read an MIFARE tag. \r
+// Select, Authenticate, Write a MIFARE tag. \r
 // read block\r
 //-----------------------------------------------------------------------------\r
 void MifareWriteBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)\r
@@ -368,15 +329,8 @@ void MifareWriteBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        \r
        if (MF_DBGLEVEL >= 2)   DbpString("WRITE BLOCK FINISHED");\r
 \r
-       // add trace trailer\r
-       memset(uid, 0x44, 4);\r
-       LogTrace(uid, 4, 0, 0, TRUE);\r
-\r
-//     UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};\r
-       \r
        LED_B_ON();\r
        cmd_send(CMD_ACK,isOK,0,0,0,0);\r
-//     UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));\r
        LED_B_OFF();\r
 \r
 \r
@@ -387,6 +341,7 @@ void MifareWriteBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
 \r
 }\r
 \r
+\r
 void MifareUWriteBlock(uint8_t arg0, uint8_t *datain)\r
 {\r
         // params\r
@@ -433,13 +388,8 @@ void MifareUWriteBlock(uint8_t arg0, uint8_t *datain)
         \r
         if (MF_DBGLEVEL >= 2)   DbpString("WRITE BLOCK FINISHED");\r
 \r
-        // add trace trailer\r
-        memset(uid, 0x44, 4);\r
-        LogTrace(uid, 4, 0, 0, TRUE);\r
-\r
         LED_B_ON();\r
-       cmd_send(CMD_ACK,isOK,0,0,0,0);\r
-//      UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));\r
+               cmd_send(CMD_ACK,isOK,0,0,0,0);\r
         LED_B_OFF();\r
 \r
 \r
@@ -447,71 +397,67 @@ void MifareUWriteBlock(uint8_t arg0, uint8_t *datain)
         FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);\r
         LEDsoff();\r
 //  iso14a_set_tracing(TRUE);\r
-\r
 }\r
 \r
+\r
 void MifareUWriteBlock_Special(uint8_t arg0, uint8_t *datain)\r
 {\r
-        // params\r
-        uint8_t blockNo = arg0;\r
-        byte_t blockdata[4];\r
-        \r
+       // params\r
+       uint8_t blockNo = arg0;\r
+       byte_t blockdata[4];\r
+       \r
        memcpy(blockdata, datain,4);\r
 \r
-        // variables\r
-        byte_t isOK = 0;\r
-        uint8_t uid[10];\r
-        uint32_t cuid;\r
-\r
-        // clear trace\r
-        iso14a_clear_trace();\r
-        //  iso14a_set_tracing(false);\r
+       // variables\r
+       byte_t isOK = 0;\r
+       uint8_t uid[10];\r
+       uint32_t cuid;\r
 \r
-               iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN);\r
+       // clear trace\r
+       iso14a_clear_trace();\r
+       //  iso14a_set_tracing(false);\r
 \r
-        LED_A_ON();\r
-        LED_B_OFF();\r
-        LED_C_OFF();\r
+       iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN);\r
 \r
-        while (true) {\r
-                        if(!iso14443a_select_card(uid, NULL, &cuid)) {\r
-                        if (MF_DBGLEVEL >= 1)   Dbprintf("Can't select card");\r
-                        break;\r
-                };\r
+       LED_A_ON();\r
+       LED_B_OFF();\r
+       LED_C_OFF();\r
 \r
-                if(mifare_ultra_special_writeblock(cuid, blockNo, blockdata)) {\r
-                        if (MF_DBGLEVEL >= 1)   Dbprintf("Write block error");\r
-                        break;\r
-                };\r
+       while (true) {\r
+               if(!iso14443a_select_card(uid, NULL, &cuid)) {\r
+                       if (MF_DBGLEVEL >= 1)   Dbprintf("Can't select card");\r
+                       break;\r
+               };\r
 \r
-                if(mifare_ultra_halt(cuid)) {\r
-                        if (MF_DBGLEVEL >= 1)   Dbprintf("Halt error");\r
-                        break;\r
-                };\r
+               if(mifare_ultra_special_writeblock(cuid, blockNo, blockdata)) {\r
+                       if (MF_DBGLEVEL >= 1)   Dbprintf("Write block error");\r
+                       break;\r
+               };\r
 \r
-                isOK = 1;\r
-                break;\r
-        }\r
+               if(mifare_ultra_halt(cuid)) {\r
+                       if (MF_DBGLEVEL >= 1)   Dbprintf("Halt error");\r
+                       break;\r
+               };\r
 \r
-        if (MF_DBGLEVEL >= 2)   DbpString("WRITE BLOCK FINISHED");\r
+               isOK = 1;\r
+               break;\r
+       }\r
 \r
-        // add trace trailer\r
-       memset(uid, 0x44, 4);\r
-        LogTrace(uid, 4, 0, 0, TRUE);\r
+       if (MF_DBGLEVEL >= 2)   DbpString("WRITE BLOCK FINISHED");\r
 \r
-       LED_B_ON();\r
-        cmd_send(CMD_ACK,isOK,0,0,0,0);\r
-//      UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));\r
-        LED_B_OFF();\r
+       LED_B_ON();\r
+       cmd_send(CMD_ACK,isOK,0,0,0,0);\r
+       LED_B_OFF();\r
 \r
 \r
-        // Thats it...\r
-        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);\r
-        LEDsoff();\r
+       // Thats it...\r
+       FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);\r
+       LEDsoff();\r
 //  iso14a_set_tracing(TRUE);\r
 \r
 }\r
 \r
+\r
 // Return 1 if the nonce is invalid else return 0\r
 int valid_nonce(uint32_t Nt, uint32_t NtEnc, uint32_t Ks1, byte_t * parity) {\r
        return ((oddparity((Nt >> 24) & 0xFF) == ((parity[0]) ^ oddparity((NtEnc >> 24) & 0xFF) ^ BIT(Ks1,16))) & \\r
@@ -520,7 +466,6 @@ int valid_nonce(uint32_t Nt, uint32_t NtEnc, uint32_t Ks1, byte_t * parity) {
 }\r
 \r
 \r
-\r
 //-----------------------------------------------------------------------------\r
 // MIFARE nested authentication. \r
 // \r
@@ -769,18 +714,11 @@ void MifareChkKeys(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        LED_B_OFF();\r
        LED_C_OFF();\r
 \r
-//     SpinDelay(300);\r
        for (i = 0; i < keyCount; i++) {\r
-//             FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);\r
-//             SpinDelay(100);\r
-//             FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);\r
-               // prepare next select by sending a HALT. There is no need to power down the card.\r
                if(mifare_classic_halt(pcs, cuid)) {\r
                        if (MF_DBGLEVEL >= 1)   Dbprintf("ChkKeys: Halt error");\r
                }\r
 \r
-               // SpinDelay(50);\r
-               \r
                if(!iso14443a_select_card(uid, NULL, &cuid)) {\r
                        if (OLD_MF_DBGLEVEL >= 1)       Dbprintf("ChkKeys: Can't select card");\r
                        break;\r
@@ -798,10 +736,6 @@ void MifareChkKeys(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        //  ----------------------------- crypto1 destroy\r
        crypto1_destroy(pcs);\r
        \r
-       // add trace trailer\r
-       memset(uid, 0x44, 4);\r
-       LogTrace(uid, 4, 0, 0, TRUE);\r
-\r
        LED_B_ON();\r
     cmd_send(CMD_ACK,isOK,0,0,datain + i * 6,6);\r
        LED_B_OFF();\r
@@ -823,6 +757,7 @@ void MifareSetDbgLvl(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
        Dbprintf("Debug level: %d", MF_DBGLEVEL);\r
 }\r
 \r
+\r
 //-----------------------------------------------------------------------------\r
 // Work with emulator memory\r
 // \r
@@ -831,29 +766,29 @@ void MifareEMemClr(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
        emlClearMem();\r
 }\r
 \r
+\r
 void MifareEMemSet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain){\r
        emlSetMem(datain, arg0, arg1); // data, block num, blocks count\r
 }\r
 \r
+\r
 void MifareEMemGet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain){\r
-//     UsbCommand ack = {CMD_ACK, {arg0, arg1, 0}};\r
 \r
-  byte_t buf[48];\r
-       emlGetMem(buf, arg0, arg1); // data, block num, blocks count\r
+       byte_t buf[48];\r
+       emlGetMem(buf, arg0, arg1); // data, block num, blocks count (max 4)\r
 \r
        LED_B_ON();\r
-  cmd_send(CMD_ACK,arg0,arg1,0,buf,48);\r
-//     UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));\r
+       cmd_send(CMD_ACK,arg0,arg1,0,buf,48);\r
        LED_B_OFF();\r
 }\r
 \r
+\r
 //-----------------------------------------------------------------------------\r
 // Load a card into the emulator memory\r
 // \r
 //-----------------------------------------------------------------------------\r
 void MifareECardLoad(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain){\r
-       int i;\r
-       uint8_t sectorNo = 0;\r
+       uint8_t numSectors = arg0;\r
        uint8_t keyType = arg1;\r
        uint64_t ui64Key = 0;\r
        uint32_t cuid;\r
@@ -876,63 +811,51 @@ void MifareECardLoad(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
        LED_B_OFF();\r
        LED_C_OFF();\r
        \r
-       while (true) {\r
-               if(!iso14443a_select_card(uid, NULL, &cuid)) {\r
-                       if (MF_DBGLEVEL >= 1)   Dbprintf("Can't select card");\r
-                       break;\r
-               };\r
-               \r
-               for (i = 0; i < 16; i++) {\r
-                       sectorNo = i;\r
-                       ui64Key = emlGetKey(sectorNo, keyType);\r
-       \r
-                       if (!i){\r
-                               if(mifare_classic_auth(pcs, cuid, sectorNo * 4, keyType, ui64Key, AUTH_FIRST)) {\r
-                                       if (MF_DBGLEVEL >= 1)   Dbprintf("Sector[%d]. Auth error", i);\r
-                                       break;\r
-                               }\r
-                       } else {\r
-                               if(mifare_classic_auth(pcs, cuid, sectorNo * 4, keyType, ui64Key, AUTH_NESTED)) {\r
-                                       if (MF_DBGLEVEL >= 1)   Dbprintf("Sector[%d]. Auth nested error", i);\r
-                                       break;\r
-                               }\r
-                       }\r
+       bool isOK = true;\r
+\r
+       if(!iso14443a_select_card(uid, NULL, &cuid)) {\r
+               isOK = false;\r
+               if (MF_DBGLEVEL >= 1)   Dbprintf("Can't select card");\r
+       }\r
                \r
-                       if(mifare_classic_readblock(pcs, cuid, sectorNo * 4 + 0, dataoutbuf)) {\r
-                               if (MF_DBGLEVEL >= 1)   Dbprintf("Read block 0 error");\r
+       for (uint8_t sectorNo = 0; isOK && sectorNo < numSectors; sectorNo++) {\r
+               ui64Key = emlGetKey(sectorNo, keyType);\r
+               if (sectorNo == 0){\r
+                       if(isOK && mifare_classic_auth(pcs, cuid, FirstBlockOfSector(sectorNo), keyType, ui64Key, AUTH_FIRST)) {\r
+                               isOK = false;\r
+                               if (MF_DBGLEVEL >= 1)   Dbprintf("Sector[%2d]. Auth error", sectorNo);\r
                                break;\r
-                       };\r
-                       emlSetMem(dataoutbuf, sectorNo * 4 + 0, 1);\r
-                       \r
-                       if(mifare_classic_readblock(pcs, cuid, sectorNo * 4 + 1, dataoutbuf)) {\r
-                               if (MF_DBGLEVEL >= 1)   Dbprintf("Read block 1 error");\r
-                               break;\r
-                       };\r
-                       emlSetMem(dataoutbuf, sectorNo * 4 + 1, 1);\r
-\r
-                       if(mifare_classic_readblock(pcs, cuid, sectorNo * 4 + 2, dataoutbuf)) {\r
-                               if (MF_DBGLEVEL >= 1)   Dbprintf("Read block 2 error");\r
+                       }\r
+               } else {\r
+                       if(isOK && mifare_classic_auth(pcs, cuid, FirstBlockOfSector(sectorNo), keyType, ui64Key, AUTH_NESTED)) {\r
+                               isOK = false;\r
+                               if (MF_DBGLEVEL >= 1)   Dbprintf("Sector[%2d]. Auth nested error", sectorNo);\r
                                break;\r
-                       };\r
-                       emlSetMem(dataoutbuf, sectorNo * 4 + 2, 1);\r
-\r
-                       // get block 3 bytes 6-9\r
-                       if(mifare_classic_readblock(pcs, cuid, sectorNo * 4 + 3, dataoutbuf)) {\r
-                               if (MF_DBGLEVEL >= 1)   Dbprintf("Read block 3 error");\r
+                       }\r
+               }\r
+               \r
+               for (uint8_t blockNo = 0; isOK && blockNo < NumBlocksPerSector(sectorNo); blockNo++) {\r
+                       if(isOK && mifare_classic_readblock(pcs, cuid, FirstBlockOfSector(sectorNo) + blockNo, dataoutbuf)) {\r
+                               isOK = false;\r
+                               if (MF_DBGLEVEL >= 1)   Dbprintf("Error reading sector %2d block %2d", sectorNo, blockNo);\r
                                break;\r
                        };\r
-                       emlGetMem(dataoutbuf2, sectorNo * 4 + 3, 1);\r
-                       memcpy(&dataoutbuf2[6], &dataoutbuf[6], 4);\r
-                       emlSetMem(dataoutbuf2,  sectorNo * 4 + 3, 1);\r
+                       if (isOK) {\r
+                               if (blockNo < NumBlocksPerSector(sectorNo) - 1) {\r
+                                       emlSetMem(dataoutbuf, FirstBlockOfSector(sectorNo) + blockNo, 1);\r
+                               } else {        // sector trailer, keep the keys, set only the AC\r
+                                       emlGetMem(dataoutbuf2, FirstBlockOfSector(sectorNo) + blockNo, 1);\r
+                                       memcpy(&dataoutbuf2[6], &dataoutbuf[6], 4);\r
+                                       emlSetMem(dataoutbuf2,  FirstBlockOfSector(sectorNo) + blockNo, 1);\r
+                               }\r
+                       }\r
                }\r
 \r
-               if(mifare_classic_halt(pcs, cuid)) {\r
-                       if (MF_DBGLEVEL >= 1)   Dbprintf("Halt error");\r
-                       break;\r
-               };\r
-               \r
-               break;\r
-       }       \r
+       }\r
+\r
+       if(mifare_classic_halt(pcs, cuid)) {\r
+               if (MF_DBGLEVEL >= 1)   Dbprintf("Halt error");\r
+       };\r
 \r
        //  ----------------------------- crypto1 destroy\r
        crypto1_destroy(pcs);\r
@@ -942,16 +865,8 @@ void MifareECardLoad(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
        \r
        if (MF_DBGLEVEL >= 2) DbpString("EMUL FILL SECTORS FINISHED");\r
 \r
-       // add trace trailer\r
-       memset(uid, 0x44, 4);\r
-       LogTrace(uid, 4, 0, 0, TRUE);\r
 }\r
 \r
-//-----------------------------------------------------------------------------\r
-// MIFARE 1k emulator\r
-// \r
-//-----------------------------------------------------------------------------\r
-\r
 \r
 //-----------------------------------------------------------------------------\r
 // Work with "magic Chinese" card (email him: ouyangweidaxian@live.cn)\r
@@ -1074,22 +989,8 @@ void MifareCSetBlock(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
                break;\r
        }\r
        \r
-//     UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};\r
-//     if (isOK) memcpy(ack.d.asBytes, uid, 4);\r
-       \r
-       // add trace trailer\r
-       /**\r
-       *       Removed by Martin, the uid is overwritten with 0x44, \r
-       *       which can 't be intended. \r
-       *\r
-       *       memset(uid, 0x44, 4);\r
-       *       LogTrace(uid, 4, 0, 0, TRUE);\r
-       **/\r
-       \r
-\r
        LED_B_ON();\r
-  cmd_send(CMD_ACK,isOK,0,0,uid,4);\r
-//     UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));\r
+       cmd_send(CMD_ACK,isOK,0,0,uid,4);\r
        LED_B_OFF();\r
 \r
        if ((workFlags & 0x10) || (!isOK)) {\r
@@ -1099,6 +1000,7 @@ void MifareCSetBlock(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
        }\r
 }\r
 \r
+\r
 void MifareCGetBlock(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain){\r
   \r
   // params\r
@@ -1171,20 +1073,8 @@ void MifareCGetBlock(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
                break;\r
        }\r
        \r
-//     UsbCommand ack = {CMD_ACK, {isOK, 0, 0}};\r
-//     if (isOK) memcpy(ack.d.asBytes, data, 18);\r
-       \r
-       // add trace trailer\r
-       /*\r
-       * Removed by Martin, this piece of overwrites the 'data' variable \r
-       * which is sent two lines down, and is obviously not correct. \r
-       * \r
-       * memset(data, 0x44, 4);\r
-       * LogTrace(data, 4, 0, 0, TRUE);\r
-       */\r
        LED_B_ON();\r
-  cmd_send(CMD_ACK,isOK,0,0,data,18);\r
-//     UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));\r
+       cmd_send(CMD_ACK,isOK,0,0,data,18);\r
        LED_B_OFF();\r
 \r
        if ((workFlags & 0x10) || (!isOK)) {\r

diff --git a/armsrc/mifareutil.c b/armsrc/mifareutil.c
index b847043bbd8a00237e54a77a4080ac383f9705fb..0b93db8f7e195f925c808010dedebfe2cbdf9c1b 100644 (file)
--- a/armsrc/mifareutil.c
+++ b/armsrc/mifareutil.c
@@ -453,6 +453,27 @@ int mifare_ultra_halt(uint32_t uid)
        return 0;
 }
 
+\r
+// Mifare Memory Structure: up to 32 Sectors with 4 blocks each (1k and 2k cards),\r
+// plus evtl. 8 sectors with 16 blocks each (4k cards)\r
+uint8_t NumBlocksPerSector(uint8_t sectorNo) \r
+{\r
+       if (sectorNo < 32) \r
+               return 4;\r
+       else\r
+               return 16;\r
+}\r
+\r
+uint8_t FirstBlockOfSector(uint8_t sectorNo) \r
+{\r
+       if (sectorNo < 32)\r
+               return sectorNo * 4;\r
+       else\r
+               return 32*4 + (sectorNo - 32) * 16;\r
+               \r
+}\r
+\r
+\r
 // work with emulator memory
 void emlSetMem(uint8_t *data, int blockNum, int blocksCount) {
        uint8_t* emCARD = eml_get_bigbufptr_cardmem();
@@ -522,7 +543,7 @@ uint64_t emlGetKey(int sectorNum, int keyType) {
        uint8_t key[6];\r
        uint8_t* emCARD = eml_get_bigbufptr_cardmem();\r
        \r
-       memcpy(key, emCARD + 3 * 16 + sectorNum * 4 * 16 + keyType * 10, 6);\r
+       memcpy(key, emCARD + 16 * (FirstBlockOfSector(sectorNum) + NumBlocksPerSector(sectorNum) - 1) + keyType * 10, 6);\r
        return bytes_to_num(key, 6);\r
 }\r
 \r

diff --git a/armsrc/mifareutil.h b/armsrc/mifareutil.h
index ad637ea02fd790492be2c26480bd3d982f9d469d..8708d3dd416c7cfaa6e3d82a05caf3de83a80fed 100644 (file)
--- a/armsrc/mifareutil.h
+++ b/armsrc/mifareutil.h
@@ -80,6 +80,10 @@ uint8_t* mifare_get_bigbufptr(void);
 uint8_t* eml_get_bigbufptr_sendbuf(void);\r
 uint8_t* eml_get_bigbufptr_recbuf(void);\r
 \r
+// Mifare memory structure\r
+uint8_t NumBlocksPerSector(uint8_t sectorNo);\r
+uint8_t FirstBlockOfSector(uint8_t sectorNo);\r
+\r
 // emulator functions\r
 void emlClearMem(void);\r
 void emlSetMem(uint8_t *data, int blockNum, int blocksCount);\r

diff --git a/client/cmdhf14a.c b/client/cmdhf14a.c
index d16d71ff09ae34a09a35511b9a0a6b22f639d7e7..39bdcf4020def3eb2730a046450dd94c57d3b231 100644 (file)
--- a/client/cmdhf14a.c
+++ b/client/cmdhf14a.c
@@ -183,27 +183,29 @@ void iso14a_set_timeout(uint32_t timeout) {
 
 int CmdHF14AReader(const char *Cmd)
 {
-       UsbCommand c = {CMD_READER_ISO_14443a, {ISO14A_CONNECT, 0, 0}};
+       UsbCommand c = {CMD_READER_ISO_14443a, {ISO14A_CONNECT | ISO14A_NO_DISCONNECT, 0, 0}};
        SendCommand(&c);
 
        UsbCommand resp;
        WaitForResponse(CMD_ACK,&resp);
        
-       iso14a_card_select_t *card = (iso14a_card_select_t *)resp.d.asBytes;
+       iso14a_card_select_t card;
+       memcpy(&card, (iso14a_card_select_t *)resp.d.asBytes, sizeof(iso14a_card_select_t));
 
-       if(resp.arg[0] == 0) {
+       uint64_t select_status = resp.arg[0];           // 0: couldn't read, 1: OK, with ATS, 2: OK, no ATS
+       
+       if(select_status == 0) {
                PrintAndLog("iso14443a card select failed");
                return 0;
        }
 
-       PrintAndLog("ATQA : %02x %02x", card->atqa[0], card->atqa[1]);
-       PrintAndLog(" UID : %s", sprint_hex(card->uid, card->uidlen));
-       PrintAndLog(" SAK : %02x [%d]", card->sak, resp.arg[0]);
+       PrintAndLog("ATQA : %02x %02x", card.atqa[1], card.atqa[0]);
+       PrintAndLog(" UID : %s", sprint_hex(card.uid, card.uidlen));
+       PrintAndLog(" SAK : %02x [%d]", card.sak, resp.arg[0]);
 
-       switch (card->sak) {
+       switch (card.sak) {
                case 0x00: PrintAndLog("TYPE : NXP MIFARE Ultralight | Ultralight C"); break;
                case 0x04: PrintAndLog("TYPE : NXP MIFARE (various !DESFire !DESFire EV1)"); break;
-
                case 0x08: PrintAndLog("TYPE : NXP MIFARE CLASSIC 1k | Plus 2k SL1"); break;
                case 0x09: PrintAndLog("TYPE : NXP MIFARE Mini 0.3k"); break;
                case 0x10: PrintAndLog("TYPE : NXP MIFARE Plus 2k SL2"); break;
@@ -217,67 +219,107 @@ int CmdHF14AReader(const char *Cmd)
                case 0x98: PrintAndLog("TYPE : Gemplus MPCOS"); break;
                default: ;
        }
-       if(resp.arg[0] == 1) {
+
+       
+       // try to request ATS even if tag claims not to support it
+       if (select_status == 2) {
+               uint8_t rats[] = { 0xE0, 0x80 }; // FSDI=8 (FSD=256), CID=0
+               c.arg[0] = ISO14A_RAW | ISO14A_APPEND_CRC | ISO14A_NO_DISCONNECT;
+               c.arg[1] = 2;
+               c.arg[2] = 0;
+               memcpy(c.d.asBytes, rats, 2);
+               SendCommand(&c);
+               WaitForResponse(CMD_ACK,&resp);
+               
+           memcpy(&card.ats, resp.d.asBytes, resp.arg[0]);
+               card.ats_len = resp.arg[0];                             // note: ats_len includes CRC Bytes
+       } 
+
+       // disconnect
+       c.arg[0] = 0;
+       c.arg[1] = 0;
+       c.arg[2] = 0;
+       SendCommand(&c);
+
+       
+       if(card.ats_len >= 3) {                 // a valid ATS consists of at least the length byte (TL) and 2 CRC bytes
                bool ta1 = 0, tb1 = 0, tc1 = 0;
                int pos;
 
-               PrintAndLog(" ATS : %s", sprint_hex(card->ats, card->ats_len));
-               if (card->ats_len > 0) {
-                       PrintAndLog("       -  TL : length is %d bytes", card->ats[0]);
+               if (select_status == 2) {
+                       PrintAndLog("SAK incorrectly claims that card doesn't support RATS");
                }
-               if (card->ats_len > 1) {
-                       ta1 = (card->ats[1] & 0x10) == 0x10;
-                       tb1 = (card->ats[1] & 0x20) == 0x20;
-                       tc1 = (card->ats[1] & 0x40) == 0x40;
+               PrintAndLog(" ATS : %s", sprint_hex(card.ats, card.ats_len));
+               PrintAndLog("       -  TL : length is %d bytes", card.ats[0]);
+               if (card.ats[0] != card.ats_len - 2) {
+                       PrintAndLog("ATS may be corrupted. Length of ATS (%d bytes incl. 2 Bytes CRC) doesn't match TL", card.ats_len);
+               }
+               
+               if (card.ats[0] > 1) {          // there is a format byte (T0)
+                       ta1 = (card.ats[1] & 0x10) == 0x10;
+                       tb1 = (card.ats[1] & 0x20) == 0x20;
+                       tc1 = (card.ats[1] & 0x40) == 0x40;
+                       int16_t fsci = card.ats[1] & 0x0f;
                        PrintAndLog("       -  T0 : TA1 is%s present, TB1 is%s present, "
-                                       "TC1 is%s present, FSCI is %d",
+                                       "TC1 is%s present, FSCI is %d (FSC = %ld)",
                                (ta1 ? "" : " NOT"), (tb1 ? "" : " NOT"), (tc1 ? "" : " NOT"),
-                               (card->ats[1] & 0x0f));
+                               fsci,
+                               fsci < 5 ? (fsci - 2) * 8 : 
+                                       fsci < 8 ? (fsci - 3) * 32 :
+                                       fsci == 8 ? 256 :
+                                       -1
+                               );
                }
                pos = 2;
-               if (ta1 && card->ats_len > pos) {
+               if (ta1) {
                        char dr[16], ds[16];
                        dr[0] = ds[0] = '\0';
-                       if (card->ats[pos] & 0x10) strcat(ds, "2, ");
-                       if (card->ats[pos] & 0x20) strcat(ds, "4, ");
-                       if (card->ats[pos] & 0x40) strcat(ds, "8, ");
-                       if (card->ats[pos] & 0x01) strcat(dr, "2, ");
-                       if (card->ats[pos] & 0x02) strcat(dr, "4, ");
-                       if (card->ats[pos] & 0x04) strcat(dr, "8, ");
+                       if (card.ats[pos] & 0x10) strcat(ds, "2, ");
+                       if (card.ats[pos] & 0x20) strcat(ds, "4, ");
+                       if (card.ats[pos] & 0x40) strcat(ds, "8, ");
+                       if (card.ats[pos] & 0x01) strcat(dr, "2, ");
+                       if (card.ats[pos] & 0x02) strcat(dr, "4, ");
+                       if (card.ats[pos] & 0x04) strcat(dr, "8, ");
                        if (strlen(ds) != 0) ds[strlen(ds) - 2] = '\0';
                        if (strlen(dr) != 0) dr[strlen(dr) - 2] = '\0';
                        PrintAndLog("       - TA1 : different divisors are%s supported, "
                                        "DR: [%s], DS: [%s]",
-                                       (card->ats[pos] & 0x80 ? " NOT" : ""), dr, ds);
+                                       (card.ats[pos] & 0x80 ? " NOT" : ""), dr, ds);
                        pos++;
                }
-               if (tb1 && card->ats_len > pos) {
-                       PrintAndLog("       - TB1 : SFGI = %d, FWI = %d",
-                                       (card->ats[pos] & 0x08),
-                                       (card->ats[pos] & 0x80) >> 4);
+               if (tb1) {
+                       uint32_t sfgi = card.ats[pos] & 0x0F;
+                       uint32_t fwi = card.ats[pos] >> 4;
+                       PrintAndLog("       - TB1 : SFGI = %d (SFGT = %s%ld/fc), FWI = %d (FWT = %ld/fc)",
+                                       (sfgi),
+                                       sfgi ? "" : "(not needed) ",
+                                       sfgi ? (1 << 12) << sfgi : 0,
+                                       fwi,
+                                       (1 << 12) << fwi
+                                       );
                        pos++;
                }
-               if (tc1 && card->ats_len > pos) {
+               if (tc1) {
                        PrintAndLog("       - TC1 : NAD is%s supported, CID is%s supported",
-                                       (card->ats[pos] & 0x01) ? "" : " NOT",
-                                       (card->ats[pos] & 0x02) ? "" : " NOT");
+                                       (card.ats[pos] & 0x01) ? "" : " NOT",
+                                       (card.ats[pos] & 0x02) ? "" : " NOT");
                        pos++;
                }
-               if (card->ats_len > pos) {
+               if (card.ats[0] > pos) {
                        char *tip = "";
-                       if (card->ats_len - pos > 7) {
-                               if (memcmp(card->ats + pos, "\xC1\x05\x2F\x2F\x01\xBC\xD6", 7) == 0) {
+                       if (card.ats[0] - pos >= 7) {
+                               if (memcmp(card.ats + pos, "\xC1\x05\x2F\x2F\x01\xBC\xD6", 7) == 0) {
                                        tip = "-> MIFARE Plus X 2K or 4K";
-                               } else if (memcmp(card->ats + pos, "\xC1\x05\x2F\x2F\x00\x35\xC7", 7) == 0) {
+                               } else if (memcmp(card.ats + pos, "\xC1\x05\x2F\x2F\x00\x35\xC7", 7) == 0) {
                                        tip = "-> MIFARE Plus S 2K or 4K";
                                }
                        } 
-                       PrintAndLog("       -  HB : %s%s", sprint_hex(card->ats + pos, card->ats_len - pos - 2), tip);
-                       if (card->ats[pos] == 0xC1) {
+                       PrintAndLog("       -  HB : %s%s", sprint_hex(card.ats + pos, card.ats[0] - pos), tip);
+                       if (card.ats[pos] == 0xC1) {
                                PrintAndLog("               c1 -> Mifare or (multiple) virtual cards of various type");
                                PrintAndLog("                  %02x -> Length is %d bytes",
-                                               card->ats[pos + 1], card->ats[pos + 1]);
-                               switch (card->ats[pos + 2] & 0xf0) {
+                                               card.ats[pos + 1], card.ats[pos + 1]);
+                               switch (card.ats[pos + 2] & 0xf0) {
                                        case 0x10:
                                                PrintAndLog("                     1x -> MIFARE DESFire");
                                                break;
@@ -285,7 +327,7 @@ int CmdHF14AReader(const char *Cmd)
                                                PrintAndLog("                     2x -> MIFARE Plus");
                                                break;
                                }
-                               switch (card->ats[pos + 2] & 0x0f) {
+                               switch (card.ats[pos + 2] & 0x0f) {
                                        case 0x00:
                                                PrintAndLog("                     x0 -> <1 kByte");
                                                break;
@@ -302,7 +344,7 @@ int CmdHF14AReader(const char *Cmd)
                                                PrintAndLog("                     x0 -> 8 kByte");
                                                break;
                                }
-                               switch (card->ats[pos + 3] & 0xf0) {
+                               switch (card.ats[pos + 3] & 0xf0) {
                                        case 0x00:
                                                PrintAndLog("                        0x -> Engineering sample");
                                                break;
@@ -310,7 +352,7 @@ int CmdHF14AReader(const char *Cmd)
                                                PrintAndLog("                        2x -> Released");
                                                break;
                                }
-                               switch (card->ats[pos + 3] & 0x0f) {
+                               switch (card.ats[pos + 3] & 0x0f) {
                                        case 0x00:
                                                PrintAndLog("                        x0 -> Generation 1");
                                                break;
@@ -321,7 +363,7 @@ int CmdHF14AReader(const char *Cmd)
                                                PrintAndLog("                        x2 -> Generation 3");
                                                break;
                                }
-                               switch (card->ats[pos + 4] & 0x0f) {
+                               switch (card.ats[pos + 4] & 0x0f) {
                                        case 0x00:
                                                PrintAndLog("                           x0 -> Only VCSL supported");
                                                break;
@@ -335,10 +377,10 @@ int CmdHF14AReader(const char *Cmd)
                        }
                }
        } else {
-               PrintAndLog("proprietary non iso14443a-4 card found, RATS not supported");
-  }
+               PrintAndLog("proprietary non iso14443-4 card found, RATS not supported");
+       }
 
-       return resp.arg[0];
+       return select_status;
 }
 
 // Collect ISO14443 Type A UIDs
@@ -357,23 +399,20 @@ int CmdHF14ACUIDs(const char *Cmd)
                UsbCommand c = {CMD_READER_ISO_14443a, {ISO14A_CONNECT, 0, 0}};
                SendCommand(&c);
     
-    UsbCommand resp;
-    WaitForResponse(CMD_ACK,&resp);
+               UsbCommand resp;
+               WaitForResponse(CMD_ACK,&resp);
 
-               uint8_t *uid  = resp.d.asBytes;
-               iso14a_card_select_t *card = (iso14a_card_select_t *)(uid + 12);
+               iso14a_card_select_t *card = (iso14a_card_select_t *) resp.d.asBytes;
 
                // check if command failed
                if (resp.arg[0] == 0) {
                        PrintAndLog("Card select failed.");
                } else {
-                       // check if UID is 4 bytes
-                       if ((card->atqa[1] & 0xC0) == 0) {
-                               PrintAndLog("%02X%02X%02X%02X",
-                                           *uid, *(uid + 1), *(uid + 2), *(uid + 3));
-                       } else {
-                               PrintAndLog("UID longer than 4 bytes");
+                       char uid_string[20];
+                       for (uint16_t i = 0; i < card->uidlen; i++) {
+                               sprintf(&uid_string[2*i], "%02X", card->uid[i]);
                        }
+                       PrintAndLog("%s", uid_string);
                }
        }
        PrintAndLog("End: %u", time(NULL));

diff --git a/client/cmdhfmf.c b/client/cmdhfmf.c
index a26652566e812d353a6a1f739ed4a296902561f6..b66aa3a6d59d220d685c8b57ce657b3f415feee8 100644 (file)
--- a/client/cmdhfmf.c
+++ b/client/cmdhfmf.c
@@ -121,7 +121,7 @@ int CmdHF14AMfWrBl(const char *Cmd)
                PrintAndLog("Block data must include 32 HEX symbols");\r
                return 1;\r
        }\r
-       PrintAndLog("--block no:%02x key type:%02x key:%s", blockNo, keyType, sprint_hex(key, 6));\r
+       PrintAndLog("--block no:%d, key type:%c, key:%s", blockNo, keyType?'B':'A', sprint_hex(key, 6));\r
        PrintAndLog("--data: %s", sprint_hex(bldata, 16));\r
        \r
   UsbCommand c = {CMD_MIFARE_WRITEBL, {blockNo, keyType, 0}};\r
@@ -168,7 +168,7 @@ int CmdHF14AMfUWrBl(const char *Cmd)
                        if (!chinese_card){\r
                                PrintAndLog("Access Denied");\r
                        }else{\r
-                               PrintAndLog("--specialblock no:%02x", blockNo);\r
+                               PrintAndLog("--specialblock no:%d", blockNo);\r
                                PrintAndLog("--data: %s", sprint_hex(bldata, 4));\r
                                UsbCommand d = {CMD_MIFAREU_WRITEBL, {blockNo}};\r
                                memcpy(d.d.asBytes,bldata, 4);\r
@@ -186,7 +186,7 @@ int CmdHF14AMfUWrBl(const char *Cmd)
                          if (!chinese_card){\r
                                PrintAndLog("Access Denied");\r
                          }else{\r
-                               PrintAndLog("--specialblock no:%02x", blockNo);\r
+                               PrintAndLog("--specialblock no:%d", blockNo);\r
                                PrintAndLog("--data: %s", sprint_hex(bldata, 4));\r
                                UsbCommand d = {CMD_MIFAREU_WRITEBL, {blockNo}};\r
                                memcpy(d.d.asBytes,bldata, 4);\r
@@ -204,7 +204,7 @@ int CmdHF14AMfUWrBl(const char *Cmd)
                        if (!chinese_card){\r
                                PrintAndLog("Access Denied");\r
                        }else{\r
-                               PrintAndLog("--specialblock no:%02x", blockNo);\r
+                               PrintAndLog("--specialblock no:%d", blockNo);\r
                                PrintAndLog("--data: %s", sprint_hex(bldata, 4));\r
                                UsbCommand c = {CMD_MIFAREU_WRITEBL, {blockNo}};\r
                                memcpy(c.d.asBytes, bldata, 4);\r
@@ -219,7 +219,7 @@ int CmdHF14AMfUWrBl(const char *Cmd)
                        }\r
                        break;\r
                case 3:\r
-                       PrintAndLog("--specialblock no:%02x", blockNo);\r
+                       PrintAndLog("--specialblock no:%d", blockNo);\r
                        PrintAndLog("--data: %s", sprint_hex(bldata, 4));\r
                        UsbCommand d = {CMD_MIFAREU_WRITEBL, {blockNo}};\r
                        memcpy(d.d.asBytes,bldata, 4);\r
@@ -233,7 +233,7 @@ int CmdHF14AMfUWrBl(const char *Cmd)
                        }\r
                        break;\r
                default: \r
-                       PrintAndLog("--block no:%02x", blockNo);\r
+                       PrintAndLog("--block no:%d", blockNo);\r
                        PrintAndLog("--data: %s", sprint_hex(bldata, 4));               \r
                        UsbCommand e = {CMD_MIFAREU_WRITEBL, {blockNo}};\r
                        memcpy(e.d.asBytes,bldata, 4);\r
@@ -250,6 +250,7 @@ int CmdHF14AMfUWrBl(const char *Cmd)
        return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfRdBl(const char *Cmd)\r
 {\r
        uint8_t blockNo = 0;\r
@@ -276,7 +277,7 @@ int CmdHF14AMfRdBl(const char *Cmd)
                PrintAndLog("Key must include 12 HEX symbols");\r
                return 1;\r
        }\r
-       PrintAndLog("--block no:%02x key type:%02x key:%s ", blockNo, keyType, sprint_hex(key, 6));\r
+       PrintAndLog("--block no:%d, key type:%c, key:%s ", blockNo, keyType?'B':'A', sprint_hex(key, 6));\r
        \r
   UsbCommand c = {CMD_MIFARE_READBL, {blockNo, keyType, 0}};\r
        memcpy(c.d.asBytes, key, 6);\r
@@ -284,8 +285,8 @@ int CmdHF14AMfRdBl(const char *Cmd)
 \r
        UsbCommand resp;\r
        if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
-               uint8_t                isOK  = resp.arg[0] & 0xff;\r
-               uint8_t              * data  = resp.d.asBytes;\r
+               uint8_t isOK  = resp.arg[0] & 0xff;\r
+               uint8_t *data = resp.d.asBytes;\r
 \r
                if (isOK)\r
                        PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 16));\r
@@ -300,66 +301,67 @@ int CmdHF14AMfRdBl(const char *Cmd)
 \r
 int CmdHF14AMfURdBl(const char *Cmd)\r
 {\r
-        uint8_t blockNo = 0;\r
+       uint8_t blockNo = 0;\r
 \r
-        if (strlen(Cmd)<1) {\r
-                PrintAndLog("Usage:  hf mf urdbl    <block number>");\r
-                PrintAndLog("        sample: hf mf urdbl 0");\r
-                return 0;\r
-        }       \r
+    if (strlen(Cmd)<1) {\r
+               PrintAndLog("Usage:  hf mf urdbl    <block number>");\r
+               PrintAndLog("        sample: hf mf urdbl 0");\r
+        return 0;\r
+    }       \r
         \r
-        blockNo = param_get8(Cmd, 0);\r
-        PrintAndLog("--block no:%02x", blockNo);\r
+    blockNo = param_get8(Cmd, 0);\r
+    PrintAndLog("--block no:%d", blockNo);\r
         \r
-  UsbCommand c = {CMD_MIFAREU_READBL, {blockNo}};\r
-  SendCommand(&c);\r
-\r
-        UsbCommand resp;\r
-        if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
-                uint8_t                isOK  = resp.arg[0] & 0xff;\r
-                uint8_t              * data  = resp.d.asBytes;\r
+       UsbCommand c = {CMD_MIFAREU_READBL, {blockNo}};\r
+       SendCommand(&c);\r
 \r
-                if (isOK)\r
-                        PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 4));\r
-                else\r
-                        PrintAndLog("isOk:%02x", isOK);\r
-        } else {\r
-                PrintAndLog("Command execute timeout");\r
-        }\r
+    UsbCommand resp;\r
+    if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
+               uint8_t isOK = resp.arg[0] & 0xff;\r
+        uint8_t *data = resp.d.asBytes;\r
+\r
+        if (isOK)\r
+            PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 4));\r
+        else\r
+            PrintAndLog("isOk:%02x", isOK);\r
+    } else {\r
+        PrintAndLog("Command execute timeout");\r
+    }\r
 \r
-  return 0;\r
+       return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfURdCard(const char *Cmd)\r
 {\r
-        int i;\r
-        uint8_t sectorNo = 0;\r
+    int i;\r
+    uint8_t sectorNo = 0;\r
        uint8_t *lockbytes_t=NULL;\r
        uint8_t lockbytes[2]={0,0};\r
        bool bit[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};\r
         \r
-        uint8_t isOK  = 0;\r
-        uint8_t * data  = NULL;\r
+    uint8_t isOK  = 0;\r
+    uint8_t * data  = NULL;\r
 \r
-        if (sectorNo > 15) {\r
-                PrintAndLog("Sector number must be less than 16");\r
-                return 1;\r
-        }\r
-        PrintAndLog("Attempting to Read Ultralight... ");\r
+    if (sectorNo > 15) {\r
+        PrintAndLog("Sector number must be less than 16");\r
+        return 1;\r
+    }\r
+    PrintAndLog("Attempting to Read Ultralight... ");\r
         \r
        UsbCommand c = {CMD_MIFAREU_READCARD, {sectorNo}};\r
        SendCommand(&c);\r
 \r
-        UsbCommand resp;\r
-        if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
-                isOK  = resp.arg[0] & 0xff;\r
-                data  = resp.d.asBytes;\r
-\r
-                PrintAndLog("isOk:%02x", isOK);\r
-                if (isOK) \r
-                        for (i = 0; i < 16; i++) {\r
-                               switch(i){\r
-                                 case 2:\r
+    UsbCommand resp;\r
+    if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
+        isOK = resp.arg[0] & 0xff;\r
+        data = resp.d.asBytes;\r
+\r
+        PrintAndLog("isOk:%02x", isOK);\r
+        if (isOK) \r
+            for (i = 0; i < 16; i++) {\r
+                       switch(i){\r
+                               case 2:\r
                                        //process lock bytes\r
                                        lockbytes_t=data+(i*4);\r
                                        lockbytes[0]=lockbytes_t[2];\r
@@ -369,68 +371,67 @@ int CmdHF14AMfURdCard(const char *Cmd)
                                        }\r
                                        //PrintAndLog("LB %02x %02x", lockbytes[0],lockbytes[1]);\r
                                        //PrintAndLog("LB2b %02x %02x %02x %02x %02x %02x %02x %02x",bit[8],bit[9],bit[10],bit[11],bit[12],bit[13],bit[14],bit[15]);            \r
-                                       PrintAndLog("Block %02x:%s ", i,sprint_hex(data + i * 4, 4));\r
+                                       PrintAndLog("Block %3d:%s ", i,sprint_hex(data + i * 4, 4));\r
                                        break;\r
-                                 case 3: \r
-                                       PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[4]);\r
+                               case 3: \r
+                                       PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[4]);\r
                                        break;\r
-                                 case 4:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[3]);\r
+                               case 4:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[3]);\r
                                        break;\r
-                                 case 5:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[2]);\r
+                               case 5:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[2]);\r
                                        break;\r
-                                 case 6:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[1]);\r
+                               case 6:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[1]);\r
                                        break;\r
-                                 case 7:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[0]);\r
+                               case 7:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[0]);\r
                                        break;\r
-                                 case 8:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[15]);\r
+                               case 8:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[15]);\r
                                        break;\r
-                                 case 9:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[14]);\r
+                               case 9:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[14]);\r
                                        break;\r
-                                 case 10:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[13]);\r
+                               case 10:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[13]);\r
                                        break;\r
-                                 case 11:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[12]);\r
+                               case 11:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[12]);\r
                                        break;\r
-                                 case 12:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[11]);\r
+                               case 12:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[11]);\r
                                        break;\r
-                                 case 13:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[10]);\r
+                               case 13:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[10]);\r
                                        break;\r
-                                 case 14:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[9]);\r
+                               case 14:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[9]);\r
                                        break;\r
-                                 case 15:\r
-                                        PrintAndLog("Block %02x:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[8]);\r
+                               case 15:\r
+                    PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[8]);\r
                                        break;\r
-                                 default:\r
-                                       PrintAndLog("Block %02x:%s ", i,sprint_hex(data + i * 4, 4));\r
+                               default:\r
+                                       PrintAndLog("Block %3d:%s ", i,sprint_hex(data + i * 4, 4));\r
                                        break;\r
                                }\r
                         }\r
         } else {\r
-                PrintAndLog("Command1 execute timeout");\r
+                PrintAndLog("Command execute timeout");\r
         }\r
   return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfRdSc(const char *Cmd)\r
 {\r
        int i;\r
        uint8_t sectorNo = 0;\r
        uint8_t keyType = 0;\r
        uint8_t key[6] = {0, 0, 0, 0, 0, 0};\r
-       \r
        uint8_t isOK  = 0;\r
-       uint8_t * data  = NULL;\r
-\r
+       uint8_t *data  = NULL;\r
        char cmdp       = 0x00;\r
 \r
        if (strlen(Cmd)<3) {\r
@@ -440,12 +441,12 @@ int CmdHF14AMfRdSc(const char *Cmd)
        }       \r
        \r
        sectorNo = param_get8(Cmd, 0);\r
-       if (sectorNo > 63) {\r
-               PrintAndLog("Sector number must be less than 64");\r
+       if (sectorNo > 39) {\r
+               PrintAndLog("Sector number must be less than 40");\r
                return 1;\r
        }\r
        cmdp = param_getchar(Cmd, 1);\r
-       if (cmdp == 0x00) {\r
+       if (cmdp != 'a' && cmdp != 'A' && cmdp != 'b' && cmdp != 'B') {\r
                PrintAndLog("Key type must be A or B");\r
                return 1;\r
        }\r
@@ -454,11 +455,11 @@ int CmdHF14AMfRdSc(const char *Cmd)
                PrintAndLog("Key must include 12 HEX symbols");\r
                return 1;\r
        }\r
-       PrintAndLog("--sector no:%02x key type:%02x key:%s ", sectorNo, keyType, sprint_hex(key, 6));\r
+       PrintAndLog("--sector no:%d key type:%c key:%s ", sectorNo, keyType?'B':'A', sprint_hex(key, 6));\r
        \r
-  UsbCommand c = {CMD_MIFARE_READSC, {sectorNo, keyType, 0}};\r
+       UsbCommand c = {CMD_MIFARE_READSC, {sectorNo, keyType, 0}};\r
        memcpy(c.d.asBytes, key, 6);\r
-  SendCommand(&c);\r
+       SendCommand(&c);\r
        PrintAndLog(" ");\r
 \r
        UsbCommand resp;\r
@@ -467,95 +468,123 @@ int CmdHF14AMfRdSc(const char *Cmd)
                data  = resp.d.asBytes;\r
 \r
                PrintAndLog("isOk:%02x", isOK);\r
-               if (isOK) \r
-                       for (i = 0; i < 2; i++) {\r
-                               PrintAndLog("data:%s", sprint_hex(data + i * 16, 16));\r
+               if (isOK) {\r
+                       for (i = 0; i < (sectorNo<32?3:15); i++) {\r
+                               PrintAndLog("data   : %s", sprint_hex(data + i * 16, 16));\r
                        }\r
+                       PrintAndLog("trailer: %s", sprint_hex(data + (sectorNo<32?3:15) * 16, 16));\r
+               }\r
        } else {\r
-               PrintAndLog("Command1 execute timeout");\r
+               PrintAndLog("Command execute timeout");\r
        }\r
 \r
-  // response2\r
-       PrintAndLog(" ");\r
-       if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
-               isOK  = resp.arg[0] & 0xff;\r
-               data  = resp.d.asBytes;\r
+  return 0;\r
+}\r
 \r
-               if (isOK) \r
-                       for (i = 0; i < 2; i++) {\r
-                               PrintAndLog("data:%s", sprint_hex(data + i * 16, 16));\r
-               }\r
+\r
+uint8_t FirstBlockOfSector(uint8_t sectorNo)\r
+{\r
+       if (sectorNo < 32) {\r
+               return sectorNo * 4;\r
        } else {\r
-               PrintAndLog("Command2 execute timeout");\r
+               return 32 * 4 + (sectorNo - 32) * 16;\r
        }\r
-       \r
-  return 0;\r
 }\r
 \r
+\r
+uint8_t NumBlocksPerSector(uint8_t sectorNo)\r
+{\r
+       if (sectorNo < 32) {\r
+               return 4;\r
+       } else {\r
+               return 16;\r
+       }\r
+}\r
+\r
+\r
 int CmdHF14AMfDump(const char *Cmd)\r
 {\r
-       int i, j;\r
+       uint8_t sectorNo, blockNo;\r
        \r
        uint8_t keyA[40][6];\r
        uint8_t keyB[40][6];\r
        uint8_t rights[40][4];\r
+       uint8_t carddata[256][16];\r
+       uint8_t numSectors = 16;\r
        \r
        FILE *fin;\r
        FILE *fout;\r
        \r
        UsbCommand resp;\r
+\r
+       char cmdp = param_getchar(Cmd, 0);\r
+       switch (cmdp) {\r
+               case '0' : numSectors = 5; break;\r
+               case '1' : \r
+               case '\0': numSectors = 16; break;\r
+               case '2' : numSectors = 32; break;\r
+               case '4' : numSectors = 40; break;\r
+               default:   numSectors = 16;\r
+       }       \r
        \r
-       if ((fin = fopen("dumpkeys.bin","rb")) == NULL) {\r
-               PrintAndLog("Could not find file dumpkeys.bin");\r
-               return 1;\r
+       if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {\r
+               PrintAndLog("Usage:   hf mf dump [card memory]");\r
+               PrintAndLog("  [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");\r
+               PrintAndLog("");\r
+               PrintAndLog("Samples: hf mf dump");\r
+               PrintAndLog("         hf mf dump 4");\r
+               return 0;\r
        }\r
        \r
-       if ((fout = fopen("dumpdata.bin","wb")) == NULL) { \r
-               PrintAndLog("Could not create file name dumpdata.bin");\r
+       if ((fin = fopen("dumpkeys.bin","rb")) == NULL) {\r
+               PrintAndLog("Could not find file dumpkeys.bin");\r
                return 1;\r
        }\r
        \r
        // Read key file\r
-       \r
-       for (i=0 ; i<16 ; i++) {\r
-               if (fread( keyA[i], 1, 6, fin ) == 0) {\r
-      PrintAndLog("File reading error.");\r
+\r
+       for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
+               if (fread( keyA[sectorNo], 1, 6, fin ) == 0) {\r
+                       PrintAndLog("File reading error.");\r
                        return 2;\r
-    }\r
+               }\r
        }\r
-       for (i=0 ; i<16 ; i++) {\r
-               if (fread( keyB[i], 1, 6, fin ) == 0) {\r
-      PrintAndLog("File reading error.");\r
+       \r
+       for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
+               if (fread( keyB[sectorNo], 1, 6, fin ) == 0) {\r
+                       PrintAndLog("File reading error.");\r
                        return 2;\r
-    }\r
+               }\r
        }\r
        \r
        // Read access rights to sectors\r
-       \r
+\r
        PrintAndLog("|-----------------------------------------|");\r
        PrintAndLog("|------ Reading sector access bits...-----|");\r
        PrintAndLog("|-----------------------------------------|");\r
        \r
-       for (i = 0 ; i < 16 ; i++) {\r
-               UsbCommand c = {CMD_MIFARE_READBL, {4*i + 3, 0, 0}};\r
-               memcpy(c.d.asBytes, keyA[i], 6);\r
+       for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
+               UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + NumBlocksPerSector(sectorNo) - 1, 0, 0}};\r
+               memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
                SendCommand(&c);\r
 \r
-    if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
+               if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
                        uint8_t isOK  = resp.arg[0] & 0xff;\r
                        uint8_t *data  = resp.d.asBytes;\r
                        if (isOK){\r
-                               rights[i][0] = ((data[7] & 0x10)>>4) | ((data[8] & 0x1)<<1) | ((data[8] & 0x10)>>2);\r
-                               rights[i][1] = ((data[7] & 0x20)>>5) | ((data[8] & 0x2)<<0) | ((data[8] & 0x20)>>3);\r
-                               rights[i][2] = ((data[7] & 0x40)>>6) | ((data[8] & 0x4)>>1) | ((data[8] & 0x40)>>4);\r
-                               rights[i][3] = ((data[7] & 0x80)>>7) | ((data[8] & 0x8)>>2) | ((data[8] & 0x80)>>5);\r
-                               }\r
-                       else{\r
-                               PrintAndLog("Could not get access rights for block %d", i);\r
+                               rights[sectorNo][0] = ((data[7] & 0x10)>>2) | ((data[8] & 0x1)<<1) | ((data[8] & 0x10)>>4); // C1C2C3 for data area 0\r
+                               rights[sectorNo][1] = ((data[7] & 0x20)>>3) | ((data[8] & 0x2)<<0) | ((data[8] & 0x20)>>5); // C1C2C3 for data area 1\r
+                               rights[sectorNo][2] = ((data[7] & 0x40)>>4) | ((data[8] & 0x4)>>1) | ((data[8] & 0x40)>>6); // C1C2C3 for data area 2\r
+                               rights[sectorNo][3] = ((data[7] & 0x80)>>5) | ((data[8] & 0x8)>>2) | ((data[8] & 0x80)>>7); // C1C2C3 for sector trailer\r
+                       } else {\r
+                               PrintAndLog("Could not get access rights for sector %2d. Trying with defaults...", sectorNo);\r
+                               rights[sectorNo][0] = rights[sectorNo][1] = rights[sectorNo][2] = 0x00;\r
+                               rights[sectorNo][3] = 0x01;\r
                        }\r
-               }\r
-               else {\r
-                       PrintAndLog("Command execute timeout");\r
+               } else {\r
+                       PrintAndLog("Command execute timeout when trying to read access rights for sector %2d. Trying with defaults...", sectorNo);\r
+                       rights[sectorNo][0] = rights[sectorNo][1] = rights[sectorNo][2] = 0x00;\r
+                       rights[sectorNo][3] = 0x01;\r
                }\r
        }\r
        \r
@@ -565,85 +594,116 @@ int CmdHF14AMfDump(const char *Cmd)
        PrintAndLog("|----- Dumping all blocks to file... -----|");\r
        PrintAndLog("|-----------------------------------------|");\r
        \r
-  \r
-       for (i=0 ; i<16 ; i++) {\r
-               for (j=0 ; j<4 ; j++) {\r
-      bool received = false;\r
-      \r
-      if (j == 3){\r
-                               UsbCommand c = {CMD_MIFARE_READBL, {i*4 + j, 0, 0}};\r
-                               memcpy(c.d.asBytes, keyA[i], 6);\r
+       bool isOK = true;\r
+       for (sectorNo = 0; isOK && sectorNo < numSectors; sectorNo++) {\r
+               for (blockNo = 0; isOK && blockNo < NumBlocksPerSector(sectorNo); blockNo++) {\r
+                       bool received = false;\r
+                       if (blockNo == NumBlocksPerSector(sectorNo) - 1) {              // sector trailer. At least the Access Conditions can always be read with key A. \r
+                               UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 0, 0}};\r
+                               memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
                                SendCommand(&c);\r
-        received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
-                       }\r
-                       else{\r
-                               if ((rights[i][j] == 6) | (rights[i][j] == 5)) {\r
-                                       UsbCommand c = {CMD_MIFARE_READBL, {i*4+j, 1, 0}};\r
-                                       memcpy(c.d.asBytes, keyB[i], 6);\r
+                               received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
+                       } else {                                                                                                // data block. Check if it can be read with key A or key B\r
+                               uint8_t data_area = sectorNo<32?blockNo:blockNo/5;\r
+                               if ((rights[sectorNo][data_area] == 0x03) || (rights[sectorNo][data_area] == 0x05)) {   // only key B would work\r
+                                       UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 1, 0}};\r
+                                       memcpy(c.d.asBytes, keyB[sectorNo], 6);\r
                                        SendCommand(&c);\r
-          received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
-                               }\r
-                               else if (rights[i][j] == 7) {\r
-                                       PrintAndLog("Access rights do not allow reading of sector %d block %d",i,j);\r
-                               }\r
-                               else {\r
-                                       UsbCommand c = {CMD_MIFARE_READBL, {i*4+j, 0, 0}};\r
-                                       memcpy(c.d.asBytes, keyA[i], 6);\r
+                                       received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
+                               } else if (rights[sectorNo][data_area] == 0x07) {                                                                               // no key would work\r
+                                       isOK = false;\r
+                                       PrintAndLog("Access rights do not allow reading of sector %2d block %3d", sectorNo, blockNo);\r
+                               } else {                                                                                                                                                                // key A would work\r
+                                       UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 0, 0}};\r
+                                       memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
                                        SendCommand(&c);\r
-          received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
+                                       received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
                                }\r
                        }\r
 \r
                        if (received) {\r
-                               uint8_t isOK  = resp.arg[0] & 0xff;\r
+                               isOK  = resp.arg[0] & 0xff;\r
                                uint8_t *data  = resp.d.asBytes;\r
-                               if (j == 3) {\r
-                                       data[0]  = (keyA[i][0]);\r
-                                       data[1]  = (keyA[i][1]);\r
-                                       data[2]  = (keyA[i][2]);\r
-                                       data[3]  = (keyA[i][3]);\r
-                                       data[4]  = (keyA[i][4]);\r
-                                       data[5]  = (keyA[i][5]);\r
-                                       data[10] = (keyB[i][0]);\r
-                                       data[11] = (keyB[i][1]);\r
-                                       data[12] = (keyB[i][2]);\r
-                                       data[13] = (keyB[i][3]);\r
-                                       data[14] = (keyB[i][4]);\r
-                                       data[15] = (keyB[i][5]);\r
+                               if (blockNo == NumBlocksPerSector(sectorNo) - 1) {              // sector trailer. Fill in the keys.\r
+                                       data[0]  = (keyA[sectorNo][0]);\r
+                                       data[1]  = (keyA[sectorNo][1]);\r
+                                       data[2]  = (keyA[sectorNo][2]);\r
+                                       data[3]  = (keyA[sectorNo][3]);\r
+                                       data[4]  = (keyA[sectorNo][4]);\r
+                                       data[5]  = (keyA[sectorNo][5]);\r
+                                       data[10] = (keyB[sectorNo][0]);\r
+                                       data[11] = (keyB[sectorNo][1]);\r
+                                       data[12] = (keyB[sectorNo][2]);\r
+                                       data[13] = (keyB[sectorNo][3]);\r
+                                       data[14] = (keyB[sectorNo][4]);\r
+                                       data[15] = (keyB[sectorNo][5]);\r
                                }\r
                                if (isOK) {\r
-                                       fwrite ( data, 1, 16, fout );\r
-                    PrintAndLog("Dumped card data into 'dumpdata.bin'");\r
-\r
-                               }\r
-                               else {\r
-                                       PrintAndLog("Could not get access rights for block %d", i);\r
+                                       memcpy(carddata[FirstBlockOfSector(sectorNo) + blockNo], data, 16);\r
+                    PrintAndLog("Successfully read block %2d of sector %2d.", blockNo, sectorNo);\r
+                               } else {\r
+                                       PrintAndLog("Could not read block %2d of sector %2d", blockNo, sectorNo);\r
+                                       break;\r
                                }\r
                        }\r
                        else {\r
-                               PrintAndLog("Command execute timeout");\r
+                               isOK = false;\r
+                               PrintAndLog("Command execute timeout when trying to read block %2d of sector %2d.", blockNo, sectorNo);\r
+                               break;\r
                        }\r
                }\r
+\r
        }\r
-       \r
+\r
+       if (isOK) {\r
+               if ((fout = fopen("dumpdata.bin","wb")) == NULL) { \r
+                       PrintAndLog("Could not create file name dumpdata.bin");\r
+                       return 1;\r
+               }\r
+               uint16_t numblocks = FirstBlockOfSector(numSectors - 1) + NumBlocksPerSector(numSectors - 1);\r
+               fwrite(carddata, 1, 16*numblocks, fout);\r
+               fclose(fout);\r
+               PrintAndLog("Dumped %d blocks (%d bytes) to file dumpdata.bin", numblocks, 16*numblocks);\r
+       }\r
+               \r
        fclose(fin);\r
-       fclose(fout);\r
-  return 0;\r
+       return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfRestore(const char *Cmd)\r
 {\r
 \r
-       int i,j;\r
+       uint8_t sectorNo,blockNo;\r
        uint8_t keyType = 0;\r
        uint8_t key[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};\r
        uint8_t bldata[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};\r
-       uint8_t keyA[16][6];\r
-       uint8_t keyB[16][6];\r
+       uint8_t keyA[40][6];\r
+       uint8_t keyB[40][6];\r
+       uint8_t numSectors;\r
        \r
        FILE *fdump;\r
        FILE *fkeys;\r
-       \r
+\r
+       char cmdp = param_getchar(Cmd, 0);\r
+       switch (cmdp) {\r
+               case '0' : numSectors = 5; break;\r
+               case '1' : \r
+               case '\0': numSectors = 16; break;\r
+               case '2' : numSectors = 32; break;\r
+               case '4' : numSectors = 40; break;\r
+               default:   numSectors = 16;\r
+       }       \r
+\r
+       if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {\r
+               PrintAndLog("Usage:   hf mf restore [card memory]");\r
+               PrintAndLog("  [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");\r
+               PrintAndLog("");\r
+               PrintAndLog("Samples: hf mf restore");\r
+               PrintAndLog("         hf mf restore 4");\r
+               return 0;\r
+       }\r
+\r
        if ((fdump = fopen("dumpdata.bin","rb")) == NULL) {\r
                PrintAndLog("Could not find file dumpdata.bin");\r
                return 1;\r
@@ -653,63 +713,54 @@ int CmdHF14AMfRestore(const char *Cmd)
                return 1;\r
        }\r
        \r
-       for (i=0 ; i<16 ; i++) {\r
-               if (fread(keyA[i], 1, 6, fkeys) == 0) {\r
-      PrintAndLog("File reading error.");\r
+       for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
+               if (fread(keyA[sectorNo], 1, 6, fkeys) == 0) {\r
+                       PrintAndLog("File reading error (dumpkeys.bin).");\r
                        return 2;\r
-    }\r
+               }\r
        }\r
-       for (i=0 ; i<16 ; i++) {\r
-               if (fread(keyB[i], 1, 6, fkeys) == 0) {\r
-      PrintAndLog("File reading error.");\r
+\r
+       for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
+               if (fread(keyB[sectorNo], 1, 6, fkeys) == 0) {\r
+                       PrintAndLog("File reading error (dumpkeys.bin).");\r
                        return 2;\r
-    }\r
+               }\r
        }\r
-       \r
+\r
        PrintAndLog("Restoring dumpdata.bin to card");\r
 \r
-       for (i=0 ; i<16 ; i++) {\r
-               for( j=0 ; j<4 ; j++) {\r
-                       UsbCommand c = {CMD_MIFARE_WRITEBL, {i*4 + j, keyType, 0}};\r
+       for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
+               for(blockNo = 0; blockNo < NumBlocksPerSector(sectorNo); blockNo++) {\r
+                       UsbCommand c = {CMD_MIFARE_WRITEBL, {FirstBlockOfSector(sectorNo) + blockNo, keyType, 0}};\r
                        memcpy(c.d.asBytes, key, 6);\r
                        \r
                        if (fread(bldata, 1, 16, fdump) == 0) {\r
-        PrintAndLog("File reading error.");\r
-        return 2;\r
-      }\r
+                               PrintAndLog("File reading error (dumpdata.bin).");\r
+                               return 2;\r
+                       }\r
                                        \r
-                       if (j == 3) {\r
-                               bldata[0]  = (keyA[i][0]);\r
-                               bldata[1]  = (keyA[i][1]);\r
-                               bldata[2]  = (keyA[i][2]);\r
-                               bldata[3]  = (keyA[i][3]);\r
-                               bldata[4]  = (keyA[i][4]);\r
-                               bldata[5]  = (keyA[i][5]);\r
-                               bldata[10] = (keyB[i][0]);\r
-                               bldata[11] = (keyB[i][1]);\r
-                               bldata[12] = (keyB[i][2]);\r
-                               bldata[13] = (keyB[i][3]);\r
-                               bldata[14] = (keyB[i][4]);\r
-                               bldata[15] = (keyB[i][5]);\r
+                       if (blockNo == NumBlocksPerSector(sectorNo) - 1) {      // sector trailer\r
+                               bldata[0]  = (keyA[sectorNo][0]);\r
+                               bldata[1]  = (keyA[sectorNo][1]);\r
+                               bldata[2]  = (keyA[sectorNo][2]);\r
+                               bldata[3]  = (keyA[sectorNo][3]);\r
+                               bldata[4]  = (keyA[sectorNo][4]);\r
+                               bldata[5]  = (keyA[sectorNo][5]);\r
+                               bldata[10] = (keyB[sectorNo][0]);\r
+                               bldata[11] = (keyB[sectorNo][1]);\r
+                               bldata[12] = (keyB[sectorNo][2]);\r
+                               bldata[13] = (keyB[sectorNo][3]);\r
+                               bldata[14] = (keyB[sectorNo][4]);\r
+                               bldata[15] = (keyB[sectorNo][5]);\r
                        }               \r
                        \r
-                       PrintAndLog("Writing to block %2d: %s", i*4+j, sprint_hex(bldata, 16));\r
-                       \r
-                       /*\r
-                       PrintAndLog("Writing to block %2d: %s Confirm? [Y,N]", i*4+j, sprint_hex(bldata, 16));\r
-                       \r
-                       scanf("%c",&ch);\r
-                       if ((ch != 'y') && (ch != 'Y')){\r
-                               PrintAndLog("Aborting !");\r
-                               return 1;\r
-                       }\r
-                       */\r
+                       PrintAndLog("Writing to block %3d: %s", FirstBlockOfSector(sectorNo) + blockNo, sprint_hex(bldata, 16));\r
                        \r
                        memcpy(c.d.asBytes + 10, bldata, 16);\r
                        SendCommand(&c);\r
 \r
                        UsbCommand resp;\r
-      if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
+                       if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
                                uint8_t isOK  = resp.arg[0] & 0xff;\r
                                PrintAndLog("isOk:%02x", isOK);\r
                        } else {\r
@@ -723,22 +774,22 @@ int CmdHF14AMfRestore(const char *Cmd)
        return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfNested(const char *Cmd)\r
 {\r
        int i, j, res, iterations;\r
-       sector  *       e_sector = NULL;\r
+       sector *e_sector = NULL;\r
        uint8_t blockNo = 0;\r
        uint8_t keyType = 0;\r
        uint8_t trgBlockNo = 0;\r
        uint8_t trgKeyType = 0;\r
-       uint8_t blDiff = 0;\r
-       int  SectorsCnt = 0;\r
+       uint8_t SectorsCnt = 0;\r
        uint8_t key[6] = {0, 0, 0, 0, 0, 0};\r
        uint8_t keyBlock[6*6];\r
        uint64_t key64 = 0;\r
-       int transferToEml = 0;\r
+       bool transferToEml = false;\r
        \r
-       int createDumpFile = 0;\r
+       bool createDumpFile = false;\r
        FILE *fkeys;\r
        uint8_t standart[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};\r
        uint8_t tempkey[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};\r
@@ -755,16 +806,16 @@ int CmdHF14AMfNested(const char *Cmd)
                PrintAndLog("d - write keys to binary file");\r
                PrintAndLog(" ");\r
                PrintAndLog("      sample1: hf mf nested 1 0 A FFFFFFFFFFFF ");\r
-               PrintAndLog("      sample1: hf mf nested 1 0 A FFFFFFFFFFFF t ");\r
-               PrintAndLog("      sample1: hf mf nested 1 0 A FFFFFFFFFFFF d ");\r
-               PrintAndLog("      sample2: hf mf nested o 0 A FFFFFFFFFFFF 4 A");\r
+               PrintAndLog("      sample2: hf mf nested 1 0 A FFFFFFFFFFFF t ");\r
+               PrintAndLog("      sample3: hf mf nested 1 0 A FFFFFFFFFFFF d ");\r
+               PrintAndLog("      sample4: hf mf nested o 0 A FFFFFFFFFFFF 4 A");\r
                return 0;\r
        }       \r
        \r
        cmdp = param_getchar(Cmd, 0);\r
        blockNo = param_get8(Cmd, 1);\r
        ctmp = param_getchar(Cmd, 2);\r
-       if (ctmp == 0x00) {\r
+       if (ctmp != 'a' && ctmp != 'A' && ctmp != 'b' && ctmp != 'B') {\r
                PrintAndLog("Key type must be A or B");\r
                return 1;\r
        }\r
@@ -778,7 +829,7 @@ int CmdHF14AMfNested(const char *Cmd)
                cmdp = 'o';\r
                trgBlockNo = param_get8(Cmd, 4);\r
                ctmp = param_getchar(Cmd, 5);\r
-               if (ctmp == 0x00) {\r
+               if (ctmp != 'a' && ctmp != 'A' && ctmp != 'b' && ctmp != 'B') {\r
                        PrintAndLog("Target key type must be A or B");\r
                        return 1;\r
                }\r
@@ -788,24 +839,21 @@ int CmdHF14AMfNested(const char *Cmd)
                        case '0': SectorsCnt = 05; break;\r
                        case '1': SectorsCnt = 16; break;\r
                        case '2': SectorsCnt = 32; break;\r
-                       case '4': SectorsCnt = 64; break;\r
+                       case '4': SectorsCnt = 40; break;\r
                        default:  SectorsCnt = 16;\r
                }\r
        }\r
 \r
        ctmp = param_getchar(Cmd, 4);\r
-       if              (ctmp == 't' || ctmp == 'T') transferToEml = 1;\r
-       else if (ctmp == 'd' || ctmp == 'D') createDumpFile = 1;\r
+       if              (ctmp == 't' || ctmp == 'T') transferToEml = true;\r
+       else if (ctmp == 'd' || ctmp == 'D') createDumpFile = true;\r
        \r
        ctmp = param_getchar(Cmd, 6);\r
        transferToEml |= (ctmp == 't' || ctmp == 'T');\r
        transferToEml |= (ctmp == 'd' || ctmp == 'D');\r
        \r
-       PrintAndLog("--block no:%02x key type:%02x key:%s etrans:%d", blockNo, keyType, sprint_hex(key, 6), transferToEml);\r
-       if (cmdp == 'o')\r
-               PrintAndLog("--target block no:%02x target key type:%02x ", trgBlockNo, trgKeyType);\r
-\r
        if (cmdp == 'o') {\r
+               PrintAndLog("--target block no:%3d, target key type:%c ", trgBlockNo, trgKeyType?'B':'A');\r
                if (mfnested(blockNo, keyType, key, trgBlockNo, trgKeyType, keyBlock, true)) {\r
                        PrintAndLog("Nested error.");\r
                        return 2;\r
@@ -816,13 +864,19 @@ int CmdHF14AMfNested(const char *Cmd)
 \r
                        // transfer key to the emulator\r
                        if (transferToEml) {\r
-                               mfEmlGetMem(keyBlock, (trgBlockNo / 4) * 4 + 3, 1);\r
+                               uint8_t sectortrailer;\r
+                               if (trgBlockNo < 32*4) {        // 4 block sector\r
+                                       sectortrailer = (trgBlockNo & 0x03) + 3;\r
+                               } else {                                        // 16 block sector\r
+                                       sectortrailer = (trgBlockNo & 0x0f) + 15;\r
+                               }\r
+                               mfEmlGetMem(keyBlock, sectortrailer, 1);\r
                \r
                                if (!trgKeyType)\r
                                        num_to_bytes(key64, 6, keyBlock);\r
                                else\r
                                        num_to_bytes(key64, 6, &keyBlock[10]);\r
-                               mfEmlSetMem(keyBlock, (trgBlockNo / 4) * 4 + 3, 1);             \r
+                               mfEmlSetMem(keyBlock, sectortrailer, 1);                \r
                        }\r
                } else {\r
                        PrintAndLog("No valid key found");\r
@@ -832,12 +886,10 @@ int CmdHF14AMfNested(const char *Cmd)
                clock_t time1;\r
                time1 = clock();\r
 \r
-               blDiff = blockNo % 4;\r
-               PrintAndLog("Block shift=%d", blDiff);\r
                e_sector = calloc(SectorsCnt, sizeof(sector));\r
                if (e_sector == NULL) return 1;\r
                \r
-               //test current key 4 sectors\r
+               //test current key and additional standard keys first\r
                memcpy(keyBlock, key, 6);\r
                num_to_bytes(0xffffffffffff, 6, (uint8_t*)(keyBlock + 1 * 6));\r
                num_to_bytes(0x000000000000, 6, (uint8_t*)(keyBlock + 2 * 6));\r
@@ -850,7 +902,7 @@ int CmdHF14AMfNested(const char *Cmd)
                        for (j = 0; j < 2; j++) {\r
                                if (e_sector[i].foundKey[j]) continue;\r
                                \r
-                               res = mfCheckKeys(i * 4 + blDiff, j, 6, keyBlock, &key64);\r
+                               res = mfCheckKeys(FirstBlockOfSector(i), j, 6, keyBlock, &key64);\r
                                \r
                                if (!res) {\r
                                        e_sector[i].Key[j] = key64;\r
@@ -865,11 +917,11 @@ int CmdHF14AMfNested(const char *Cmd)
                PrintAndLog("nested...");\r
                bool calibrate = true;\r
                for (i = 0; i < NESTED_SECTOR_RETRY; i++) {\r
-                       for (trgBlockNo = blDiff; trgBlockNo < SectorsCnt * 4; trgBlockNo = trgBlockNo + 4) {\r
+                       for (uint8_t sectorNo = 0; sectorNo < SectorsCnt; sectorNo++) {\r
                                for (trgKeyType = 0; trgKeyType < 2; trgKeyType++) { \r
-                                       if (e_sector[trgBlockNo / 4].foundKey[trgKeyType]) continue;\r
+                                       if (e_sector[sectorNo].foundKey[trgKeyType]) continue;\r
                                        PrintAndLog("-----------------------------------------------");\r
-                                       if(mfnested(blockNo, keyType, key, trgBlockNo, trgKeyType, keyBlock, calibrate)) {\r
+                                       if(mfnested(blockNo, keyType, key, FirstBlockOfSector(sectorNo), trgKeyType, keyBlock, calibrate)) {\r
                                                PrintAndLog("Nested error.\n");\r
                                                return 2;\r
                                        }\r
@@ -882,8 +934,8 @@ int CmdHF14AMfNested(const char *Cmd)
                                        key64 = bytes_to_num(keyBlock, 6);\r
                                        if (key64) {\r
                                                PrintAndLog("Found valid key:%012"llx, key64);\r
-                                               e_sector[trgBlockNo / 4].foundKey[trgKeyType] = 1;\r
-                                               e_sector[trgBlockNo / 4].Key[trgKeyType] = key64;\r
+                                               e_sector[sectorNo].foundKey[trgKeyType] = 1;\r
+                                               e_sector[sectorNo].Key[trgKeyType] = key64;\r
                                        }\r
                                }\r
                        }\r
@@ -905,12 +957,12 @@ int CmdHF14AMfNested(const char *Cmd)
                // transfer them to the emulator\r
                if (transferToEml) {\r
                        for (i = 0; i < SectorsCnt; i++) {\r
-                               mfEmlGetMem(keyBlock, i * 4 + 3, 1);\r
+                               mfEmlGetMem(keyBlock, FirstBlockOfSector(i) + NumBlocksPerSector(i) - 1, 1);\r
                                if (e_sector[i].foundKey[0])\r
                                        num_to_bytes(e_sector[i].Key[0], 6, keyBlock);\r
                                if (e_sector[i].foundKey[1])\r
                                        num_to_bytes(e_sector[i].Key[1], 6, &keyBlock[10]);\r
-                               mfEmlSetMem(keyBlock, i * 4 + 3, 1);\r
+                               mfEmlSetMem(keyBlock, FirstBlockOfSector(i) + NumBlocksPerSector(i) - 1, 1);\r
                        }               \r
                }\r
                \r
@@ -921,8 +973,8 @@ int CmdHF14AMfNested(const char *Cmd)
                                free(e_sector);\r
                                return 1;\r
                        }\r
-                       PrintAndLog("Printing keys to bynary file dumpkeys.bin...");\r
-                       for(i=0; i<16; i++) {\r
+                       PrintAndLog("Printing keys to binary file dumpkeys.bin...");\r
+                       for(i=0; i<SectorsCnt; i++) {\r
                                if (e_sector[i].foundKey[0]){\r
                                        num_to_bytes(e_sector[i].Key[0], 6, tempkey);\r
                                        fwrite ( tempkey, 1, 6, fkeys );\r
@@ -931,7 +983,7 @@ int CmdHF14AMfNested(const char *Cmd)
                                        fwrite ( &standart, 1, 6, fkeys );\r
                                }\r
                        }\r
-                       for(i=0; i<16; i++) {\r
+                       for(i=0; i<SectorsCnt; i++) {\r
                                if (e_sector[i].foundKey[1]){\r
                                        num_to_bytes(e_sector[i].Key[1], 6, tempkey);\r
                                        fwrite ( tempkey, 1, 6, fkeys );\r
@@ -949,18 +1001,7 @@ int CmdHF14AMfNested(const char *Cmd)
        return 0;\r
 }\r
 \r
-static  uint32_t\r
-get_trailer_block (uint32_t uiBlock)\r
-{\r
-  // Test if we are in the small or big sectors\r
-  uint32_t trailer_block = 0;\r
-  if (uiBlock < 128) {\r
-    trailer_block = uiBlock + (3 - (uiBlock % 4));\r
-  } else {\r
-    trailer_block = uiBlock + (15 - (uiBlock % 16));\r
-  }\r
-  return trailer_block;\r
-}\r
+\r
 int CmdHF14AMfChk(const char *Cmd)\r
 {\r
        FILE * f;\r
@@ -999,7 +1040,7 @@ int CmdHF14AMfChk(const char *Cmd)
                0x533cb6c723f6,\r
                0x8fd0a4f256e9\r
        };\r
-       int defaultKeysSize = (sizeof(defaultKeys) / 7) - 1;\r
+       int defaultKeysSize = sizeof(defaultKeys) / sizeof(uint64_t);\r
 \r
        for (int defaultKeyCounter = 0; defaultKeyCounter < defaultKeysSize; defaultKeyCounter++)\r
        {\r
@@ -1007,11 +1048,10 @@ int CmdHF14AMfChk(const char *Cmd)
        }\r
        \r
        if (strlen(Cmd)<3) {\r
-               PrintAndLog("Usage:  hf mf chk <block number>/<*card memory> <key type (A/B/?)> [t] [<key (12 hex symbols)>] [<dic (*.dic)>]");\r
+               PrintAndLog("Usage:  hf mf chk <block number>|<*card memory> <key type (A/B/?)> [t] [<key (12 hex symbols)>] [<dic (*.dic)>]");\r
                PrintAndLog("          * - all sectors");\r
                PrintAndLog("card memory - 0 - MINI(320 bytes), 1 - 1K, 2 - 2K, 4 - 4K, <other> - 1K");\r
-//             PrintAndLog("d - write keys to binary file\n");\r
-               \r
+               PrintAndLog("d - write keys to binary file\n");\r
                PrintAndLog("      sample: hf mf chk 0 A 1234567890ab keys.dic");\r
                PrintAndLog("              hf mf chk *1 ? t");\r
                return 0;\r
@@ -1061,7 +1101,7 @@ int CmdHF14AMfChk(const char *Cmd)
                                }\r
                                keyBlock = p;\r
                        }\r
-                       PrintAndLog("chk key[%d] %02x%02x%02x%02x%02x%02x", keycnt,\r
+                       PrintAndLog("chk key[%2d] %02x%02x%02x%02x%02x%02x", keycnt,\r
                        (keyBlock + 6*keycnt)[0],(keyBlock + 6*keycnt)[1], (keyBlock + 6*keycnt)[2],\r
                        (keyBlock + 6*keycnt)[3], (keyBlock + 6*keycnt)[4],     (keyBlock + 6*keycnt)[5], 6);\r
                        keycnt++;\r
@@ -1100,7 +1140,7 @@ int CmdHF14AMfChk(const char *Cmd)
                                        }\r
                                        memset(keyBlock + 6 * keycnt, 0, 6);\r
                                        num_to_bytes(strtoll(buf, NULL, 16), 6, keyBlock + 6*keycnt);\r
-                                       PrintAndLog("chk custom key[%d] %012"llx, keycnt, bytes_to_num(keyBlock + 6*keycnt, 6));\r
+                                       PrintAndLog("chk custom key[%2d] %012"llx, keycnt, bytes_to_num(keyBlock + 6*keycnt, 6));\r
                                        keycnt++;\r
                                        memset(buf, 0, sizeof(buf));\r
                                }\r
@@ -1114,31 +1154,39 @@ int CmdHF14AMfChk(const char *Cmd)
        }\r
        \r
        if (keycnt == 0) {\r
-               PrintAndLog("No key specified,try default keys");\r
+               PrintAndLog("No key specified, trying default keys");\r
                for (;keycnt < defaultKeysSize; keycnt++)\r
-                       PrintAndLog("chk default key[%d] %02x%02x%02x%02x%02x%02x", keycnt,\r
-                       (keyBlock + 6*keycnt)[0],(keyBlock + 6*keycnt)[1], (keyBlock + 6*keycnt)[2],\r
-                       (keyBlock + 6*keycnt)[3], (keyBlock + 6*keycnt)[4],     (keyBlock + 6*keycnt)[5], 6);\r
+                       PrintAndLog("chk default key[%2d] %02x%02x%02x%02x%02x%02x", keycnt,\r
+                               (keyBlock + 6*keycnt)[0],(keyBlock + 6*keycnt)[1], (keyBlock + 6*keycnt)[2],\r
+                               (keyBlock + 6*keycnt)[3], (keyBlock + 6*keycnt)[4],     (keyBlock + 6*keycnt)[5], 6);\r
+       }\r
+       \r
+       // initialize storage for found keys\r
+       bool validKey[2][40];\r
+       uint8_t foundKey[2][40][6];\r
+       for (uint16_t t = 0; t < 2; t++) {\r
+               for (uint16_t sectorNo = 0; sectorNo < SectorsCnt; sectorNo++) {\r
+                       validKey[t][sectorNo] = false;\r
+                       for (uint16_t i = 0; i < 6; i++) {\r
+                               foundKey[t][sectorNo][i] = 0xff;\r
+                       }\r
+               }\r
        }\r
        \r
-       for ( int t = !keyType ; t < 2 ; keyType==2?(t++):(t=2) ) {\r
+       for ( int t = !keyType; t < 2; keyType==2?(t++):(t=2) ) {\r
                int b=blockNo;\r
-               for (int i=0; i<SectorsCnt; ++i) {\r
-                       PrintAndLog("--SectorsCnt:%d block no:0x%02x key type:%C key count:%d ", i,      b, t?'B':'A', keycnt);\r
+               for (int i = 0; i < SectorsCnt; ++i) {\r
+                       PrintAndLog("--sector:%2d, block:%3d, key type:%C, key count:%2d ", i, b, t?'B':'A', keycnt);\r
                        uint32_t max_keys = keycnt>USB_CMD_DATA_SIZE/6?USB_CMD_DATA_SIZE/6:keycnt;\r
                        for (uint32_t c = 0; c < keycnt; c+=max_keys) {\r
                                uint32_t size = keycnt-c>max_keys?max_keys:keycnt-c;\r
                                res = mfCheckKeys(b, t, size, &keyBlock[6*c], &key64);\r
-                               if (res !=1) {\r
+                               if (res != 1) {\r
                                        if (!res) {\r
                                                PrintAndLog("Found valid key:[%012"llx"]",key64);\r
-                                               if (transferToEml) {\r
-                                                       uint8_t block[16];\r
-                                                       mfEmlGetMem(block, get_trailer_block(b), 1);\r
-                                                       num_to_bytes(key64, 6, block + t*10);\r
-                                                       mfEmlSetMem(block, get_trailer_block(b), 1);\r
-                                               }\r
-                                       }\r
+                                               num_to_bytes(key64, 6, foundKey[t][i]);\r
+                                               validKey[t][i] = true;\r
+                                       } \r
                                } else {\r
                                        PrintAndLog("Command execute timeout");\r
                                }\r
@@ -1146,42 +1194,43 @@ int CmdHF14AMfChk(const char *Cmd)
                        b<127?(b+=4):(b+=16);   \r
                }\r
        }\r
-       \r
-       free(keyBlock);\r
 \r
-/*\r
-       // Create dump file\r
+       if (transferToEml) {\r
+               uint8_t block[16];\r
+               for (uint16_t sectorNo = 0; sectorNo < SectorsCnt; sectorNo++) {\r
+                       if (validKey[0][sectorNo] || validKey[1][sectorNo]) {\r
+                               mfEmlGetMem(block, FirstBlockOfSector(sectorNo) + NumBlocksPerSector(sectorNo) - 1, 1);\r
+                               for (uint16_t t = 0; t < 2; t++) {\r
+                                       if (validKey[t][sectorNo]) {\r
+                                               memcpy(block + t*10, foundKey[t][sectorNo], 6);\r
+                                       }\r
+                               }\r
+                               mfEmlSetMem(block, FirstBlockOfSector(sectorNo) + NumBlocksPerSector(sectorNo) - 1, 1);\r
+                       }\r
+               }\r
+               PrintAndLog("Found keys have been transferred to the emulator memory");\r
+       }\r
+\r
        if (createDumpFile) {\r
-               if ((fkeys = fopen("dumpkeys.bin","wb")) == NULL) { \r
+               FILE *fkeys = fopen("dumpkeys.bin","wb");\r
+               if (fkeys == NULL) { \r
                        PrintAndLog("Could not create file dumpkeys.bin");\r
-                       free(e_sector);\r
+                       free(keyBlock);\r
                        return 1;\r
                }\r
-               PrintAndLog("Printing keys to bynary file dumpkeys.bin...");\r
-               for(i=0; i<16; i++) {\r
-                       if (e_sector[i].foundKey[0]){\r
-                               num_to_bytes(e_sector[i].Key[0], 6, tempkey);\r
-                               fwrite ( tempkey, 1, 6, fkeys );\r
-                       }\r
-                       else{\r
-                               fwrite ( &standart, 1, 6, fkeys );\r
-                       }\r
-               }\r
-               for(i=0; i<16; i++) {\r
-                       if (e_sector[i].foundKey[1]){\r
-                               num_to_bytes(e_sector[i].Key[1], 6, tempkey);\r
-                               fwrite ( tempkey, 1, 6, fkeys );\r
-                       }\r
-                       else{\r
-                               fwrite ( &standart, 1, 6, fkeys );\r
-                       }\r
+               for (uint16_t t = 0; t < 2; t++) {\r
+                       fwrite(foundKey[t], 1, 6*SectorsCnt, fkeys);\r
                }\r
                fclose(fkeys);\r
+               PrintAndLog("Found keys have been dumped to file dumpkeys.bin. 0xffffffffffff has been inserted for unknown keys.");\r
        }\r
-*/\r
-  return 0;\r
+\r
+       free(keyBlock);\r
+\r
+       return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMf1kSim(const char *Cmd)\r
 {\r
        uint8_t uid[7] = {0, 0, 0, 0, 0, 0, 0};\r
@@ -1194,21 +1243,19 @@ int CmdHF14AMf1kSim(const char *Cmd)
                PrintAndLog("           n    (Optional) Automatically exit simulation after <numreads> blocks have been read by reader. 0 = infinite");\r
                PrintAndLog("           i    (Optional) Interactive, means that console will not be returned until simulation finishes or is aborted");\r
                PrintAndLog("           x    (Optional) Crack, performs the 'reader attack', nr/ar attack against a legitimate reader, fishes out the key(s)");\r
-               PrintAndLog("           sample: hf mf sim 0a0a0a0a ");\r
+               PrintAndLog("           sample: hf mf sim u 0a0a0a0a ");\r
                return 0;\r
        }\r
        uint8_t pnr = 0;\r
        if (param_getchar(Cmd, pnr) == 'u') {\r
                if(param_gethex(Cmd, pnr+1, uid, 8) == 0)\r
                {\r
-                       flags |=FLAG_4B_UID_IN_DATA; // UID from packet\r
-               }else if(param_gethex(Cmd,pnr+1,uid,14) == 0)\r
-               {\r
+                       flags |= FLAG_4B_UID_IN_DATA; // UID from packet\r
+               } else if(param_gethex(Cmd,pnr+1,uid,14) == 0) {\r
                        flags |= FLAG_7B_UID_IN_DATA;// UID from packet\r
-               }else\r
-               {\r
-                               PrintAndLog("UID, if specified, must include 8 or 14 HEX symbols");\r
-                               return 1;\r
+               } else {\r
+                       PrintAndLog("UID, if specified, must include 8 or 14 HEX symbols");\r
+                       return 1;\r
                }\r
                pnr +=2;\r
        }\r
@@ -1232,36 +1279,39 @@ int CmdHF14AMf1kSim(const char *Cmd)
                                , exitAfterNReads, flags,flags);\r
 \r
 \r
-  UsbCommand c = {CMD_SIMULATE_MIFARE_CARD, {flags, exitAfterNReads,0}};\r
-  memcpy(c.d.asBytes, uid, sizeof(uid));\r
-  SendCommand(&c);\r
-\r
-  if(flags & FLAG_INTERACTIVE)\r
-  {\r
-         UsbCommand resp;\r
-         PrintAndLog("Press pm3-button to abort simulation");\r
-         while(! WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
-               //We're waiting only 1.5 s at a time, otherwise we get the\r
-                 // annoying message about "Waiting for a response... "\r
-         }\r
-  }\r
+       UsbCommand c = {CMD_SIMULATE_MIFARE_CARD, {flags, exitAfterNReads,0}};\r
+       memcpy(c.d.asBytes, uid, sizeof(uid));\r
+       SendCommand(&c);\r
 \r
-  return 0;\r
+       if(flags & FLAG_INTERACTIVE)\r
+       {\r
+               UsbCommand resp;\r
+               PrintAndLog("Press pm3-button to abort simulation");\r
+               while(! WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
+                       //We're waiting only 1.5 s at a time, otherwise we get the\r
+                       // annoying message about "Waiting for a response... "\r
+               }\r
+       }\r
+       \r
+       return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfDbg(const char *Cmd)\r
 {\r
        int dbgMode = param_get32ex(Cmd, 0, 0, 10);\r
        if (dbgMode > 4) {\r
-               PrintAndLog("Max debud mode parameter is 4 \n");\r
+               PrintAndLog("Max debug mode parameter is 4 \n");\r
        }\r
 \r
        if (strlen(Cmd) < 1 || !param_getchar(Cmd, 0) || dbgMode > 4) {\r
                PrintAndLog("Usage:  hf mf dbg  <debug level>");\r
                PrintAndLog(" 0 - no debug messages");\r
                PrintAndLog(" 1 - error messages");\r
-               PrintAndLog(" 2 - all messages");\r
-               PrintAndLog(" 4 - extended debug mode");\r
+               PrintAndLog(" 2 - plus information messages");\r
+               PrintAndLog(" 3 - plus debug messages");\r
+               PrintAndLog(" 4 - print even debug messages in timing critical functions");\r
+               PrintAndLog("     Note: this option therefore may cause malfunction itself");\r
                return 0;\r
        }       \r
 \r
@@ -1271,11 +1321,11 @@ int CmdHF14AMfDbg(const char *Cmd)
   return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfEGet(const char *Cmd)\r
 {\r
        uint8_t blockNo = 0;\r
-       uint8_t data[3 * 16];\r
-       int i;\r
+       uint8_t data[16];\r
 \r
        if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
                PrintAndLog("Usage:  hf mf eget <block number>");\r
@@ -1286,10 +1336,8 @@ int CmdHF14AMfEGet(const char *Cmd)
        blockNo = param_get8(Cmd, 0);\r
 \r
        PrintAndLog(" ");\r
-       if (!mfEmlGetMem(data, blockNo, 3)) {\r
-               for (i = 0; i < 3; i++) {\r
-                       PrintAndLog("data[%d]:%s", blockNo + i, sprint_hex(data + i * 16, 16));\r
-               }\r
+       if (!mfEmlGetMem(data, blockNo, 1)) {\r
+               PrintAndLog("data[%3d]:%s", blockNo, sprint_hex(data, 16));\r
        } else {\r
                PrintAndLog("Command execute timeout");\r
        }\r
@@ -1297,6 +1345,7 @@ int CmdHF14AMfEGet(const char *Cmd)
   return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfEClear(const char *Cmd)\r
 {\r
        if (param_getchar(Cmd, 0) == 'h') {\r
@@ -1310,6 +1359,7 @@ int CmdHF14AMfEClear(const char *Cmd)
   return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfESet(const char *Cmd)\r
 {\r
        uint8_t memBlock[16];\r
@@ -1331,17 +1381,18 @@ int CmdHF14AMfESet(const char *Cmd)
        }\r
        \r
        //  1 - blocks count\r
-  UsbCommand c = {CMD_MIFARE_EML_MEMSET, {blockNo, 1, 0}};\r
+       UsbCommand c = {CMD_MIFARE_EML_MEMSET, {blockNo, 1, 0}};\r
        memcpy(c.d.asBytes, memBlock, 16);\r
-  SendCommand(&c);\r
-  return 0;\r
+       SendCommand(&c);\r
+       return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfELoad(const char *Cmd)\r
 {\r
        FILE * f;\r
        char filename[20];\r
-       char * fnameptr = filename;\r
+       char *fnameptr = filename;\r
        char buf[64];\r
        uint8_t buf8[64];\r
        int i, len, blockNum;\r
@@ -1375,42 +1426,41 @@ int CmdHF14AMfELoad(const char *Cmd)
        while(!feof(f)){\r
                memset(buf, 0, sizeof(buf));\r
                if (fgets(buf, sizeof(buf), f) == NULL) {\r
-                       if(blockNum == 16 * 4)\r
-                       {\r
+                       if((blockNum == 16*4) || (blockNum == 32*4 + 8*16)) {   // supports both old (1K) and new (4K) .eml files)\r
                                break;\r
                        }\r
                        PrintAndLog("File reading error.");\r
                        return 2;\r
-    }\r
-\r
+               }\r
                if (strlen(buf) < 32){\r
                        if(strlen(buf) && feof(f))\r
                                break;\r
                        PrintAndLog("File content error. Block data must include 32 HEX symbols");\r
                        return 2;\r
                }\r
-               for (i = 0; i < 32; i += 2)\r
-                 sscanf(&buf[i], "%02x", (unsigned int *)&buf8[i / 2]);\r
+               for (i = 0; i < 32; i += 2) {\r
+                       sscanf(&buf[i], "%02x", (unsigned int *)&buf8[i / 2]);\r
 //                     PrintAndLog("data[%02d]:%s", blockNum, sprint_hex(buf8, 16));\r
-\r
+               }\r
                if (mfEmlSetMem(buf8, blockNum, 1)) {\r
-                       PrintAndLog("Cant set emul block: %d", blockNum);\r
+                       PrintAndLog("Cant set emul block: %3d", blockNum);\r
                        return 3;\r
                }\r
                blockNum++;\r
                \r
-               if (blockNum >= 32 * 4 + 8 * 16) break;\r
+               if (blockNum >= 32*4 + 8*16) break;\r
        }\r
        fclose(f);\r
        \r
-       if (blockNum != 16 * 4 && blockNum != 32 * 4 + 8 * 16){\r
-               PrintAndLog("File content error. There must be 64 blocks");\r
+       if ((blockNum != 16*4) && (blockNum != 32*4 + 8*16)) {\r
+               PrintAndLog("File content error. There must be 64 or 256 blocks.");\r
                return 4;\r
        }\r
        PrintAndLog("Loaded %d blocks from file: %s", blockNum, filename);\r
-  return 0;\r
+       return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfESave(const char *Cmd)\r
 {\r
        FILE * f;\r
@@ -1452,7 +1502,7 @@ int CmdHF14AMfESave(const char *Cmd)
        f = fopen(filename, "w+");\r
 \r
        // put hex\r
-       for (i = 0; i < 32 * 4 + 8 * 16; i++) {\r
+       for (i = 0; i < 32*4 + 8*16; i++) {\r
                if (mfEmlGetMem(buf, i, 1)) {\r
                        PrintAndLog("Cant get block: %d", i);\r
                        break;\r
@@ -1468,33 +1518,50 @@ int CmdHF14AMfESave(const char *Cmd)
   return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfECFill(const char *Cmd)\r
 {\r
        uint8_t keyType = 0;\r
-\r
+       uint8_t numSectors = 16;\r
+       \r
        if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
-               PrintAndLog("Usage:  hf mf efill <key A/B>");\r
-               PrintAndLog("sample:  hf mf efill A");\r
-               PrintAndLog("Card data blocks transfers to card emulator memory.");\r
-               PrintAndLog("Keys must be laid in the simulator memory. \n");\r
+               PrintAndLog("Usage:  hf mf ecfill <key A/B> [card memory]");\r
+               PrintAndLog("  [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");\r
+               PrintAndLog("");\r
+               PrintAndLog("samples:  hf mf ecfill A");\r
+               PrintAndLog("          hf mf ecfill A 4");\r
+               PrintAndLog("Read card and transfer its data to emulator memory.");\r
+               PrintAndLog("Keys must be laid in the emulator memory. \n");\r
                return 0;\r
        }       \r
 \r
        char ctmp = param_getchar(Cmd, 0);\r
-       if (ctmp == 0x00) {\r
+       if (ctmp != 'a' && ctmp != 'A' && ctmp != 'b' && ctmp != 'B') {\r
                PrintAndLog("Key type must be A or B");\r
                return 1;\r
        }\r
        if (ctmp != 'A' && ctmp != 'a') keyType = 1;\r
 \r
-  UsbCommand c = {CMD_MIFARE_EML_CARDLOAD, {0, keyType, 0}};\r
-  SendCommand(&c);\r
-  return 0;\r
+       ctmp = param_getchar(Cmd, 1);\r
+       switch (ctmp) {\r
+               case '0' : numSectors = 5; break;\r
+               case '1' : \r
+               case '\0': numSectors = 16; break;\r
+               case '2' : numSectors = 32; break;\r
+               case '4' : numSectors = 40; break;\r
+               default:   numSectors = 16;\r
+       }       \r
+\r
+       printf("--params: numSectors: %d, keyType:%d", numSectors, keyType);\r
+       UsbCommand c = {CMD_MIFARE_EML_CARDLOAD, {numSectors, keyType, 0}};\r
+       SendCommand(&c);\r
+       return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfEKeyPrn(const char *Cmd)\r
 {\r
-       int i,b=-1;\r
+       int i;\r
        uint8_t data[16];\r
        uint64_t keyA, keyB;\r
        \r
@@ -1502,9 +1569,8 @@ int CmdHF14AMfEKeyPrn(const char *Cmd)
        PrintAndLog("|sec|key A           |key B           |");\r
        PrintAndLog("|---|----------------|----------------|");\r
        for (i = 0; i < 40; i++) {\r
-               b<127?(b+=4):(b+=16);\r
-               if (mfEmlGetMem(data, b, 1)) {\r
-                       PrintAndLog("error get block %d", b);\r
+               if (mfEmlGetMem(data, FirstBlockOfSector(i) + NumBlocksPerSector(i) - 1, 1)) {\r
+                       PrintAndLog("error get block %d", FirstBlockOfSector(i) + NumBlocksPerSector(i) - 1);\r
                        break;\r
                }\r
                keyA = bytes_to_num(data, 6);\r
@@ -1516,6 +1582,7 @@ int CmdHF14AMfEKeyPrn(const char *Cmd)
        return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfCSetUID(const char *Cmd)\r
 {\r
        uint8_t wipeCard = 0;\r
@@ -1551,6 +1618,7 @@ int CmdHF14AMfCSetUID(const char *Cmd)
        return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfCSetBlk(const char *Cmd)\r
 {\r
        uint8_t uid[8];\r
@@ -1574,7 +1642,7 @@ int CmdHF14AMfCSetBlk(const char *Cmd)
                return 1;\r
        }\r
 \r
-       PrintAndLog("--block number:%02x data:%s", blockNo, sprint_hex(memBlock, 16));\r
+       PrintAndLog("--block number:%2d data:%s", blockNo, sprint_hex(memBlock, 16));\r
 \r
        res = mfCSetBlock(blockNo, memBlock, uid, 0, CSETBLOCK_SINGLE_OPER);\r
        if (res) {\r
@@ -1586,6 +1654,7 @@ int CmdHF14AMfCSetBlk(const char *Cmd)
        return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfCLoad(const char *Cmd)\r
 {\r
        FILE * f;\r
@@ -1649,9 +1718,9 @@ int CmdHF14AMfCLoad(const char *Cmd)
                while(!feof(f)){\r
                        memset(buf, 0, sizeof(buf));\r
                        if (fgets(buf, sizeof(buf), f) == NULL) {\r
-        PrintAndLog("File reading error.");\r
-        return 2;\r
-      }\r
+                               PrintAndLog("File reading error.");\r
+                               return 2;\r
+                       }\r
 \r
                        if (strlen(buf) < 32){\r
                                if(strlen(buf) && feof(f))\r
@@ -1666,7 +1735,7 @@ int CmdHF14AMfCLoad(const char *Cmd)
                        if (blockNum == 16 * 4 - 1) flags = CSETBLOCK_HALT + CSETBLOCK_RESET_FIELD;\r
 \r
                        if (mfCSetBlock(blockNum, buf8, NULL, 0, flags)) {\r
-                               PrintAndLog("Cant set magic card block: %d", blockNum);\r
+                               PrintAndLog("Can't set magic card block: %d", blockNum);\r
                                return 3;\r
                        }\r
                        blockNum++;\r
@@ -1675,7 +1744,7 @@ int CmdHF14AMfCLoad(const char *Cmd)
                }\r
                fclose(f);\r
        \r
-               if (blockNum != 16 * 4 && blockNum != 32 * 4 + 8 * 16){\r
+               if (blockNum != 16 * 4){\r
                        PrintAndLog("File content error. There must be 64 blocks");\r
                        return 4;\r
                }\r
@@ -1684,6 +1753,7 @@ int CmdHF14AMfCLoad(const char *Cmd)
        }\r
 }\r
 \r
+\r
 int CmdHF14AMfCGetBlk(const char *Cmd) {\r
        uint8_t memBlock[16];\r
        uint8_t blockNo = 0;\r
@@ -1699,7 +1769,7 @@ int CmdHF14AMfCGetBlk(const char *Cmd) {
 \r
        blockNo = param_get8(Cmd, 0);\r
 \r
-       PrintAndLog("--block number:%02x ", blockNo);\r
+       PrintAndLog("--block number:%2d ", blockNo);\r
 \r
        res = mfCGetBlock(blockNo, memBlock, CSETBLOCK_SINGLE_OPER);\r
        if (res) {\r
@@ -1711,6 +1781,7 @@ int CmdHF14AMfCGetBlk(const char *Cmd) {
        return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfCGetSc(const char *Cmd) {\r
        uint8_t memBlock[16];\r
        uint8_t sectorNo = 0;\r
@@ -1730,7 +1801,7 @@ int CmdHF14AMfCGetSc(const char *Cmd) {
                return 1;\r
        }\r
 \r
-       PrintAndLog("--sector number:%02x ", sectorNo);\r
+       PrintAndLog("--sector number:%d ", sectorNo);\r
 \r
        flags = CSETBLOCK_INIT_FIELD + CSETBLOCK_WUPC;\r
        for (i = 0; i < 4; i++) {\r
@@ -1739,15 +1810,16 @@ int CmdHF14AMfCGetSc(const char *Cmd) {
 \r
                res = mfCGetBlock(sectorNo * 4 + i, memBlock, flags);\r
                if (res) {\r
-                       PrintAndLog("Can't read block. %02x error=%d", sectorNo * 4 + i, res);\r
+                       PrintAndLog("Can't read block. %d error=%d", sectorNo * 4 + i, res);\r
                        return 1;\r
                }\r
        \r
-               PrintAndLog("block %02x data:%s", sectorNo * 4 + i, sprint_hex(memBlock, 16));\r
+               PrintAndLog("block %3d data:%s", sectorNo * 4 + i, sprint_hex(memBlock, 16));\r
        }\r
        return 0;\r
 }\r
 \r
+\r
 int CmdHF14AMfCSave(const char *Cmd) {\r
 \r
        FILE * f;\r
@@ -1835,6 +1907,7 @@ int CmdHF14AMfCSave(const char *Cmd) {
        }\r
 }\r
 \r
+\r
 int CmdHF14AMfSniff(const char *Cmd){\r
        // params\r
        bool wantLogToFile = 0;\r
@@ -1848,7 +1921,8 @@ int CmdHF14AMfSniff(const char *Cmd){
        int blockLen = 0;\r
        int num = 0;\r
        int pckNum = 0;\r
-       uint8_t uid[8];\r
+       uint8_t uid[7];\r
+       uint8_t uid_len;\r
        uint8_t atqa[2];\r
        uint8_t sak;\r
        bool isTag;\r
@@ -1858,7 +1932,7 @@ int CmdHF14AMfSniff(const char *Cmd){
        memset(buf, 0x00, 3000);\r
        \r
        if (param_getchar(Cmd, 0) == 'h') {\r
-               PrintAndLog("It continuously get data from the field and saves it to: log, emulator, emulator file.");\r
+               PrintAndLog("It continuously gets data from the field and saves it to: log, emulator, emulator file.");\r
                PrintAndLog("You can specify:");\r
                PrintAndLog("    l - save encrypted sequence to logfile `uid.log`");\r
                PrintAndLog("    d - decrypt sequence and put it to log file `uid.log`");\r
@@ -1926,14 +2000,19 @@ int CmdHF14AMfSniff(const char *Cmd){
                                        bufPtr += 4;\r
                                        len = bufPtr[0];\r
                                        bufPtr++;\r
-                                       if ((len == 14) && (bufPtr[0] = 0xff) && (bufPtr[1] = 0xff)) {\r
+                                       if ((len == 14) && (bufPtr[0] == 0xff) && (bufPtr[1] == 0xff)) {\r
                                                memcpy(uid, bufPtr + 2, 7);\r
                                                memcpy(atqa, bufPtr + 2 + 7, 2);\r
+                                               uid_len = (atqa[0] & 0xC0) == 0x40 ? 7 : 4;\r
                                                sak = bufPtr[11];\r
                                                \r
-                                               PrintAndLog("tag select uid:%s atqa:%02x %02x sak:0x%02x", sprint_hex(uid, 7), atqa[0], atqa[1], sak);\r
+                                               PrintAndLog("tag select uid:%s atqa:0x%02x%02x sak:0x%02x", \r
+                                                       sprint_hex(uid + (7 - uid_len), uid_len),\r
+                                                       atqa[1], \r
+                                                       atqa[0], \r
+                                                       sak);\r
                                                if (wantLogToFile || wantDecrypt) {\r
-                                                       FillFileNameByUID(logHexFileName, uid, ".log", 7);\r
+                                                       FillFileNameByUID(logHexFileName, uid + (7 - uid_len), ".log", uid_len);\r
                                                        AddLogCurrentDT(logHexFileName);\r
                                                }                                               \r
                                                if (wantDecrypt) mfTraceInit(uid, atqa, sak, wantSaveToEmlFile);\r
@@ -1954,31 +2033,31 @@ int CmdHF14AMfSniff(const char *Cmd){
 \r
 static command_t CommandTable[] =\r
 {\r
-  {"help",             CmdHelp,                                                1, "This help"},\r
-  {"dbg",                      CmdHF14AMfDbg,                  0, "Set default debug mode"},\r
+  {"help",             CmdHelp,                                1, "This help"},\r
+  {"dbg",              CmdHF14AMfDbg,                  0, "Set default debug mode"},\r
   {"rdbl",             CmdHF14AMfRdBl,                 0, "Read MIFARE classic block"},\r
-  {"urdbl",              CmdHF14AMfURdBl,                 0, "Read MIFARE Ultralight block"},\r
-  {"urdcard",           CmdHF14AMfURdCard,               0,"Read MIFARE Ultralight Card"},\r
+  {"urdbl",     CmdHF14AMfURdBl,        0, "Read MIFARE Ultralight block"},\r
+  {"urdcard",   CmdHF14AMfURdCard,      0,"Read MIFARE Ultralight Card"},\r
   {"uwrbl",            CmdHF14AMfUWrBl,                0,"Write MIFARE Ultralight block"},\r
   {"rdsc",             CmdHF14AMfRdSc,                 0, "Read MIFARE classic sector"},\r
   {"dump",             CmdHF14AMfDump,                 0, "Dump MIFARE classic tag to binary file"},\r
-  {"restore",  CmdHF14AMfRestore,      0, "Restore MIFARE classic binary file to BLANK tag"},\r
+  {"restore",  CmdHF14AMfRestore,              0, "Restore MIFARE classic binary file to BLANK tag"},\r
   {"wrbl",             CmdHF14AMfWrBl,                 0, "Write MIFARE classic block"},\r
-  {"chk",                      CmdHF14AMfChk,                  0, "Test block keys"},\r
+  {"chk",              CmdHF14AMfChk,                  0, "Test block keys"},\r
   {"mifare",   CmdHF14AMifare,                 0, "Read parity error messages."},\r
   {"nested",   CmdHF14AMfNested,               0, "Test nested authentication"},\r
   {"sniff",            CmdHF14AMfSniff,                0, "Sniff card-reader communication"},\r
-  {"sim",                      CmdHF14AMf1kSim,                0, "Simulate MIFARE card"},\r
+  {"sim",              CmdHF14AMf1kSim,                0, "Simulate MIFARE card"},\r
   {"eclr",             CmdHF14AMfEClear,               0, "Clear simulator memory block"},\r
   {"eget",             CmdHF14AMfEGet,                 0, "Get simulator memory block"},\r
   {"eset",             CmdHF14AMfESet,                 0, "Set simulator memory block"},\r
   {"eload",            CmdHF14AMfELoad,                0, "Load from file emul dump"},\r
   {"esave",            CmdHF14AMfESave,                0, "Save to file emul dump"},\r
   {"ecfill",   CmdHF14AMfECFill,               0, "Fill simulator memory with help of keys from simulator"},\r
-  {"ekeyprn",  CmdHF14AMfEKeyPrn,      0, "Print keys from simulator memory"},\r
-  {"csetuid",  CmdHF14AMfCSetUID,      0, "Set UID for magic Chinese card"},\r
-  {"csetblk",  CmdHF14AMfCSetBlk,      0, "Write block into magic Chinese card"},\r
-  {"cgetblk",  CmdHF14AMfCGetBlk,      0, "Read block from magic Chinese card"},\r
+  {"ekeyprn",  CmdHF14AMfEKeyPrn,              0, "Print keys from simulator memory"},\r
+  {"csetuid",  CmdHF14AMfCSetUID,              0, "Set UID for magic Chinese card"},\r
+  {"csetblk",  CmdHF14AMfCSetBlk,              0, "Write block into magic Chinese card"},\r
+  {"cgetblk",  CmdHF14AMfCGetBlk,              0, "Read block from magic Chinese card"},\r
   {"cgetsc",   CmdHF14AMfCGetSc,               0, "Read sector from magic Chinese card"},\r
   {"cload",            CmdHF14AMfCLoad,                0, "Load dump into magic Chinese card"},\r
   {"csave",            CmdHF14AMfCSave,                0, "Save dump from magic Chinese card into file or emulator"},\r

diff --git a/client/default_keys.dic b/client/default_keys.dic
new file mode 100644 (file)
index 0000000..5c27730
--- /dev/null
+++ b/client/default_keys.dic
@@ -0,0 +1,79 @@
+# Default Keys as already in Proxmark.exe:
+ffffffffffff,//Defaultkey(firstkeyusedbyprogramifnouserdefinedkey)
+000000000000,//Blankkey
+a0a1a2a3a4a5,//NFCForumMADkey
+b0b1b2b3b4b5,
+aabbccddeeff,
+4d3a99c351dd,
+1a982c7e459a,
+d3f7d3f7d3f7,
+714c5c886e97,
+587ee5f9350f,
+a0478cc39091,
+533cb6c723f6,
+8fd0a4f256e9
+# more Keys from mf_default_keys.lua
+000000000001,
+000000000002,
+00000000000a,
+00000000000b,
+00000ffe2488,--VästtrafikenKeyB
+010203040506,
+0123456789ab,
+0297927c0f77,--VästtrafikenKeyA
+100000000000,
+111111111111,
+123456789abc,
+12f2ee3478c1,
+14d446e33363,
+1999a3554a55,
+200000000000,
+222222222222,
+26940b21ff5d,--RKFSLKeyA
+27dd91f1fcf1,
+2BA9621E0A36,--DirectoryandeventlogKeyB
+333333333333,
+33f974b42769,
+34d1df9934c5,
+434f4d4d4f41,--RKFJOJOGROUPKeyA
+434f4d4d4f42,--RKFJOJOGROUPKeyB
+43ab19ef5c31,
+444444444444,
+47524f555041,--RKFJOJOGROUPKeyA
+47524f555042,--RKFJOJOGROUPKeyB
+4AF9D7ADEBE4,--DirectoryandeventlogKeyA
+505249564141,--RKFJOJOPRIVAKeyA
+505249564142,--RKFJOJOPRIVAKeyB
+505249565441,
+505249565442,
+54726176656c,--VästtrafikenKeyA
+555555555555,
+55f5a5dd38c9,
+5c598c9c58b5,--RKFSLKeyB
+666666666666,
+722bfcc5375f,--RKFRejskortDanmarkKeyA
+776974687573,--VästtrafikenKeyB
+777777777777,
+888888888888,
+999999999999,
+99c636334433,
+a00000000000,
+a053a292a4af,
+a64598a77478,--RKFSLKeyA
+a94133013401,
+aaaaaaaaaaaa,
+abcdef123456,--Keyfromladyada.net
+b00000000000,
+b127c6f41436,
+bbbbbbbbbbbb,
+bd493a3962b6,
+c934fe34d934,
+cccccccccccc,
+dddddddddddd,
+e4d2770a89be,--RKFSLKeyB
+ee0042f88840,--VästtrafikenKeyB
+eeeeeeeeeeee,
+f1a97341a9fc,
+f1d83f964314,--RKFRejskortDanmarkKeyB
+fc00018778f7,--VästtrafikenKeyA
+fc0001877bf7,--RKFÖstgötaTrafikenKeyA

diff --git a/client/lualibs/html_dumplib.lua b/client/lualibs/html_dumplib.lua
index e730920c0dbc0b142fa35e015fe30ef220cf7253..b8c7ccaa2d509d60931c32b69cf4e00a9f5361b4 100644 (file)
--- a/client/lualibs/html_dumplib.lua
+++ b/client/lualibs/html_dumplib.lua
@@ -8,10 +8,17 @@ bin = require('bin')
 --- 
 -- A debug printout-function
 local function dbg(args)
-       if DEBUG then
+       
+    if type(args) == "table" then
+               local i = 1
+               while args[i] do
+                       print("###", args[i])
+                       i = i+1
+               end
+       else
                print("###", args)
-       end
-end 
+       end     
+end    
 --- 
 -- This is only meant to be used when errors occur
 local function oops(err)
@@ -40,20 +47,38 @@ local function save_HTML(javascript, filename)
 
 end
 
-
+local function save_BIN(data, filename)
+       -- Open the output file
+       
+       local outfile = io.open(filename, "wb")
+       if outfile == nil then 
+               return oops(string.format("Could not write to file %s",tostring(filename)))
+       end
+       
+       -- Write the data into it
+       local i = 1
+       while data[i] do
+               outfile:write(data[i])
+               i = i+1
+       end
+       
+       io.close(outfile)
+       return filename   
+end
 
 local function convert_ascii_dump_to_JS(infile)
        local t = infile:read("*all")
        
        local output = "[";
        for line in string.gmatch(t, "[^\n]+") do 
-               output = output .. "'"..line.."',\n"
+           if string.byte(line,1) ~= string.byte("+",1) then
+                  output = output .. "'"..line.."',\n"
+        end
        end
        output = output .. "]"
        return output
 end
 
-
 local function convert_binary_dump_to_JS(infile, blockLen)
         local bindata = infile:read("*all")
         len = string.len(bindata)
@@ -78,6 +103,21 @@ local function convert_binary_dump_to_JS(infile, blockLen)
        return js
 end
 
+local function convert_ascii_dump_to_BIN(infile)
+       local t = infile:read("*all")
+       
+       local output = {};
+       for line in string.gmatch(t, "[^\n]+") do 
+               if string.byte(line) ~= string.byte("+") then
+                       for c in (line or ''):gmatch('..') do
+                               output[#output+1] = string.char( tonumber(c,16) )
+                       end
+               end
+       end
+       return output
+end
+
+
 ---
 -- Converts a .eml-file into a HTML/Javascript file. 
 -- @param input the file to convert
@@ -118,7 +158,27 @@ local function convert_bin_to_html(input, output, blockLen)
        return save_HTML(javascript, output )
 end
 
+--- Converts a eml dump into a binary file
+-- @param input the file containing the eml-dump  (defaults to dumpdata.eml)
+-- @param output the file to write to  ( defaults to dumpdata.bin)
+local function convert_eml_to_bin(input, output)
+       input = input or 'dumpdata.eml'
+       output = output or 'dumpdata.bin'
+
+       local infile = io.open(input, "rb")
+       if infile == nil then 
+               return oops(string.format("Could not read file %s",tostring(input)))
+       end
+       -- Read file, get BIN
+       local data = convert_ascii_dump_to_BIN(infile)
+       io.close(infile)
+
+       return save_BIN(data, output )
+end
+
+
 return {
        convert_bin_to_html = convert_bin_to_html,
-       convert_eml_to_html = convert_eml_to_html,      
+       convert_eml_to_html = convert_eml_to_html,
+    convert_eml_to_bin = convert_eml_to_bin,   
 }

diff --git a/client/lualibs/mf_default_keys.lua b/client/lualibs/mf_default_keys.lua
index f6264a3364e017c492a06f2653d992b148fb4677..4859ff0c1781dd200aee59e232f89b4771284d4c 100644 (file)
--- a/client/lualibs/mf_default_keys.lua
+++ b/client/lualibs/mf_default_keys.lua
@@ -126,6 +126,21 @@ local _keys = {
     'eeeeeeeeeeee',
     '0123456789ab',
     '123456789abc',
+       
+       --[[
+    The keys below are taken from from https://github.com/4ZM/mfterm/blob/master/dictionary.txt
+    --]]
+       
+       'abcdef123456', -- Key from ladyada.net
+
+       '000000000001',
+       '000000000002',
+       '00000000000a',
+       '00000000000b',
+       '100000000000',
+       '200000000000',
+       'a00000000000',
+       'b00000000000', 
   }
 
 ---
@@ -148,4 +163,4 @@ local function uniq(list)
     return foobar
 end
 
-return uniq(_keys)
\ No newline at end of file
+return uniq(_keys)

diff --git a/client/lualibs/utils.lua b/client/lualibs/utils.lua
new file mode 100644 (file)
index 0000000..3d27d5b
--- /dev/null
+++ b/client/lualibs/utils.lua
@@ -0,0 +1,57 @@
+--[[\r
+       This may be moved to a separate library at some point (Holiman)\r
+--]]\r
+local Utils = \r
+{\r
+       -- Asks the user for Yes or No\r
+       confirm = function(message, ...)\r
+               local answer\r
+               message = message .. " [y/n] ?"\r
+               repeat\r
+                       io.write(message)\r
+                       io.flush()\r
+                       answer=io.read()\r
+                       if answer == 'Y' or answer == "y" then\r
+                               return true\r
+                       elseif answer == 'N' or answer == 'n' then \r
+                               return false\r
+                       end\r
+               until false\r
+       end,\r
+       ---\r
+       -- Asks the user for input\r
+       input = function (message , default)\r
+               local answer\r
+               if default ~= nil then\r
+                       message = message .. " (default: ".. default.. " )"\r
+               end\r
+               message = message .." \n > "\r
+               io.write(message)\r
+               io.flush()\r
+               answer=io.read()\r
+               if answer == '' then answer = default end\r
+\r
+               return answer\r
+       end,\r
+       --\r
+       -- Converts DECIMAL to HEX\r
+    ConvertDec2Hex = function(IN)\r
+               local B,K,OUT,I,D=16,"0123456789ABCDEF","",0\r
+               while IN>0 do\r
+                       I=I+1\r
+                       IN,D=math.floor(IN/B),math.mod(IN,B)+1\r
+                       OUT=string.sub(K,D,D)..OUT\r
+               end\r
+               return OUT\r
+       end,\r
+       ---\r
+       -- Convert Byte array to string of hex\r
+       ConvertBytes2String = function(bytes)\r
+               s = {}\r
+               for i = 1, #(bytes) do\r
+                       s[i] =   string.format("%02X",bytes[i]) \r
+               end\r
+               return table.concat(s)\r
+       end,    \r
+}\r
+return Utils
\ No newline at end of file

diff --git a/client/scripts/dumptoemul.lua b/client/scripts/dumptoemul.lua
index f4f919313d2da3fa0d90337c41fb1bef0396d7dc..f9b715091c7e2ebe92b2532d02f4249c13538501 100644 (file)
--- a/client/scripts/dumptoemul.lua
+++ b/client/scripts/dumptoemul.lua
@@ -13,7 +13,7 @@ by the emulator
 Arguments:
        -h                              This help
        -i <file>               Specifies the dump-file (input). If omitted, 'dumpdata.bin' is used     
-       -o <filename>   Speciies the output file. If omitted, <uid>.eml is used.        
+       -o <filename>   Specifies the output file. If omitted, <uid>.eml is used.       
 
 ]]
 

diff --git a/client/scripts/emul2dump.lua b/client/scripts/emul2dump.lua
new file mode 100644 (file)
index 0000000..315ad99
--- /dev/null
+++ b/client/scripts/emul2dump.lua
@@ -0,0 +1,60 @@
+local getopt = require('getopt')\r
+local bin = require('bin')\r
+local dumplib = require('html_dumplib')\r
+\r
+example =[[\r
+       1. script run emul2dump\r
+       2. script run emul2dump -i myfile.eml\r
+       3. script run emul2dump -i myfile.eml -o myfile.bin\r
+]]\r
+author = "Iceman"\r
+usage = "script run emul2dump [-i <file>] [-o <file>]"\r
+desc =[[\r
+This script takes an dumpfile on EML (ASCII) format and converts it to the PM3 dumpbin file to be used with "hf mf restore"\r
+\r
+Arguments:\r
+       -h              This help\r
+       -i <filename>   Specifies the dump-file (input). If omitted, 'dumpdata.eml' is used     \r
+       -o <filename>   Specifies the output file. If omitted, <currdate>.bin is used.  \r
+]]\r
+\r
+--- \r
+-- This is only meant to be used when errors occur\r
+function oops(err)\r
+       print("ERROR: ",err)\r
+end\r
+--- \r
+-- Usage help\r
+function help()\r
+       print(desc)\r
+       print("Example usage")\r
+       print(example)\r
+end\r
+--\r
+-- Exit message\r
+function ExitMsg(msg)\r
+       print( string.rep('--',20) )\r
+       print( string.rep('--',20) )\r
+       print(msg)\r
+       print()\r
+end\r
+\r
+local function main(args)\r
+       \r
+       local input = "dumpdata.eml"\r
+       local output  = os.date("%Y-%m-%d_%H%M%S.bin");\r
+       \r
+       -- Arguments for the script\r
+       for o, a in getopt.getopt(args, 'hi:o:') do\r
+               if o == "h" then return help() end              \r
+               if o == "i" then input = a      end\r
+               if o == "o" then output = a end\r
+       end\r
+\r
+       local filename, err = dumplib.convert_eml_to_bin(input,output)\r
+       if err then return oops(err) end\r
+\r
+       ExitMsg(("Wrote a BIN dump to the file %s"):format(filename))\r
+end\r
+\r
+main(args)
\ No newline at end of file

diff --git a/client/scripts/formatMifare.lua b/client/scripts/formatMifare.lua
new file mode 100644 (file)
index 0000000..1ced0c2
--- /dev/null
+++ b/client/scripts/formatMifare.lua
@@ -0,0 +1,196 @@
+local cmds = require('commands')\r
+local getopt = require('getopt')\r
+local bin = require('bin')\r
+local lib14a = require('read14a')\r
+local utils = require('utils')\r
+\r
+example =[[\r
+       1. script run formatMifare\r
+       2. script run formatMifare -k aabbccddeeff -n 112233445566 -a FF0780\r
+]]\r
+author = "Iceman"\r
+usage = "script run formatMifare -k <key>"\r
+desc =[[\r
+This script will generate 'hf mf wrbl' commands for each block to format a Mifare card.\r
+\r
+Alla datablocks gets 0x00\r
+As default the script sets the keys A/B to 0xFFFFFFFFFFFF\r
+and the access bytes will become 0x78,0x77,0x88\r
+The GDB will become 0x00\r
+\r
+The script will skip the manufactoring block 0.\r
+\r
+Arguments:\r
+       -h             - this help\r
+       -k <key>       - the current six byte key with write access\r
+       -n <key>       - the new key that will be written to the card\r
+       -a <access>    - the new access bytes that will be written to the card\r
+]]\r
+local TIMEOUT = 2000 -- Shouldn't take longer than 2 seconds\r
+local DEBUG = true -- the debug flag\r
+local CmdString = 'hf mf wrbl %d B %s %s'\r
+local numBlocks = 64\r
+local numSectors = 16\r
+--- \r
+-- A debug printout-function\r
+function dbg(args)\r
+       if not DEBUG then\r
+               return\r
+       end\r
+       \r
+    if type(args) == "table" then\r
+               local i = 1\r
+               while result[i] do\r
+                       dbg(result[i])\r
+                       i = i+1\r
+               end\r
+       else\r
+               print("###", args)\r
+       end     \r
+end    \r
+--- \r
+-- This is only meant to be used when errors occur\r
+function oops(err)\r
+       print("ERROR: ",err)\r
+end\r
+--- \r
+-- Usage help\r
+function help()\r
+       print(desc)\r
+       print("Example usage")\r
+       print(example)\r
+end\r
+--\r
+-- Exit message\r
+function ExitMsg(msg)\r
+       print( string.rep('--',20) )\r
+       print( string.rep('--',20) )\r
+       print(msg)\r
+       print()\r
+end\r
+--\r
+-- Read information from a card\r
+function GetCardInfo()\r
+       result, err = lib14a.read1443a(false)\r
+       if not result then\r
+               print(err)\r
+               return\r
+       end\r
+       print(("Found:  %s"):format(result.name))\r
+\r
+       core.clearCommandBuffer()\r
+       \r
+       if 0x18 == result.sak then --NXP MIFARE Classic 4k | Plus 4k\r
+               -- IFARE Classic 4K offers 4096 bytes split into forty sectors, \r
+               -- of which 32 are same size as in the 1K with eight more that are quadruple size sectors. \r
+               numSectors = 40\r
+       elseif 0x08 == result.sak then -- NXP MIFARE CLASSIC 1k | Plus 2k\r
+               -- 1K offers 1024 bytes of data storage, split into 16 sector\r
+               numSectors = 16\r
+       elseif 0x09 == result.sak then -- NXP MIFARE Mini 0.3k\r
+               -- MIFARE Classic mini offers 320 bytes split into five sectors.\r
+               numSectors = 5\r
+       elseif  0x10 == result.sak then-- "NXP MIFARE Plus 2k"\r
+               numSectors = 32\r
+       else\r
+               print("I don't know how many sectors there are on this type of card, defaulting to 16")\r
+       end     \r
+       --[[\r
+        The mifare Classic 1k card has 16 sectors of 4 data blocks each. \r
+        The first 32 sectors of a mifare Classic 4k card consists of 4 data blocks and the remaining\r
+        8 sectors consist of 16 data blocks. \r
+       --]]\r
+       \r
+       -- Defaults to 16 * 4 = 64  - 1 = 63\r
+    numBlocks = numSectors * 4 - 1  \r
+               \r
+       if numSectors > 32 then\r
+               numBlocks = 32*4+ (numSectors-32)*16 -1\r
+       end\r
+       \r
+end\r
+\r
+local function main(args)\r
+\r
+       print( string.rep('--',20) )\r
+       print( string.rep('--',20) )\r
+       print()\r
+       \r
+       local OldKey \r
+       local NewKey\r
+       local Accessbytes\r
+       \r
+       -- Arguments for the script\r
+       for o, a in getopt.getopt(args, 'hk:n:a:') do\r
+               if o == "h" then return help() end              \r
+               if o == "k" then OldKey = a end\r
+               if o == "n" then NewKey = a     end\r
+               if o == "a" then Accessbytes = a end\r
+       end\r
+\r
+       -- validate input args.\r
+       OldKey =  OldKey or 'FFFFFFFFFFFF'\r
+       if #(OldKey) ~= 12 then\r
+               return oops( string.format('Wrong length of write key (was %d) expected 12', #OldKey))\r
+       end\r
+       \r
+       NewKey =  NewKey or 'FFFFFFFFFFFF'\r
+       if #(NewKey) ~= 12 then\r
+               return oops( string.format('Wrong length of new key (was %d) expected 12', #NewKey))\r
+       end\r
+\r
+       --Accessbytes =  Accessbytes or '787788'\r
+       Accessbytes =  Accessbytes or 'FF0780'\r
+       if #(Accessbytes) ~= 6 then\r
+               return oops( string.format('Wrong length of accessbytes (was %d) expected 12', #Accessbytes))\r
+       end\r
+\r
+       GetCardInfo()\r
+       \r
+       -- Show info\r
+       print( string.format('Estimating number of blocks: %d', numBlocks))\r
+       print( string.format('Old key:    %s', OldKey))\r
+       print( string.format('New key:    %s', NewKey))\r
+       print( string.format('New Access: %s', Accessbytes))\r
+       print( string.rep('--',20) )\r
+\r
+               -- Set new block data\r
+       local EMPTY_BL = string.rep('00',16)\r
+       local EMPTY_SECTORTRAIL = string.format('%s%s%s%s',NewKey,Accessbytes,'00',NewKey)\r
+       \r
+       dbg( string.format('New sector-trailer : %s',EMPTY_SECTORTRAIL))\r
+       dbg( string.format('New emptyblock: %s',EMPTY_BL))\r
+       dbg('')\r
+       \r
+       -- Ask\r
+       local dialogResult = utils.confirm("Do you want to erase this card")\r
+       if dialogResult == false then \r
+               return ExitMsg('Quiting it is then. Your wish is my command...')\r
+       end     \r
+\r
+       print( string.rep('--',20) )\r
+       \r
+       -- main loop\r
+       for block=0,numBlocks,1 do\r
+\r
+               local reminder = (block+1) % 4\r
+               local cmd\r
+               if reminder == 0 then\r
+                       cmd = CmdString:format(block, OldKey , EMPTY_SECTORTRAIL)\r
+               else\r
+                       cmd = CmdString:format(block, OldKey , EMPTY_BL)                \r
+               end     \r
+       \r
+               if block ~= 0 then\r
+                       print(cmd)\r
+                       --core.console(cmd)\r
+               end\r
+               \r
+               if core.ukbhit() then\r
+                       print("aborted by user")\r
+                       break\r
+               end\r
+       end\r
+end\r
+\r
+main(args)
\ No newline at end of file