git.zerfleddert.de Git - proxmark3-svn/blobdiff

-//-----------------------------------------------------------------------------\r

-// Merlok - 2012\r

-//\r

-// This code is licensed to you under the terms of the GNU GPL, version 2 or,\r

-// at your option, any later version. See the LICENSE.txt file for the text of\r

-// the license.\r

-//-----------------------------------------------------------------------------\r

-// Routines to support mifare classic sniffer.\r

-//-----------------------------------------------------------------------------\r

-\r

-#include "mifaresniff.h"\r

-#include "apps.h"\r

-\r

-static int sniffState = SNF_INIT;\r

-static uint8_t sniffUIDType;\r

-static uint8_t sniffUID[8];\r

-static uint8_t sniffATQA[2];\r

-static uint8_t sniffSAK;\r

-static uint8_t sniffBuf[16];\r

-static uint32_t timerData = 0;\r

-\r

-bool MfSniffInit(void){\r

- memset(sniffUID, 0x00, 8);\r

- memset(sniffATQA, 0x00, 2);\r

- sniffSAK = 0;\r

- sniffUIDType = SNF_UID_4;\r

-\r

- return FALSE;\r

-}\r

-\r

-bool MfSniffEnd(void){\r

- LED_B_ON();\r

- cmd_send(CMD_ACK,0,0,0,0,0);\r

- LED_B_OFF();\r

-\r

- return FALSE;\r

-}\r

-\r

-bool RAMFUNC MfSniffLogic(const uint8_t *data, uint16_t len, uint32_t parity, uint16_t bitCnt, bool reader) {\r

-\r

- if (reader && (len == 1) && (bitCnt == 7)) { // reset on 7-Bit commands from reader\r

- sniffState = SNF_INIT;\r

- }\r

-\r

- switch (sniffState) {\r

- case SNF_INIT:{\r

- if ((len == 1) && (reader) && (bitCnt == 7) ) { // REQA or WUPA from reader\r

- sniffUIDType = SNF_UID_4;\r

- memset(sniffUID, 0x00, 8);\r

- memset(sniffATQA, 0x00, 2);\r

- sniffSAK = 0;\r

- sniffState = SNF_WUPREQ;\r

- }\r

- break;\r

- }\r

- case SNF_WUPREQ:{\r

- if ((!reader) && (len == 2)) { // ATQA from tag\r

- memcpy(sniffATQA, data, 2);\r

- sniffState = SNF_ATQA;\r

- }\r

- break;\r

- }\r

- case SNF_ATQA:{\r

- if ((reader) && (len == 2) && (data[0] == 0x93) && (data[1] == 0x20)) { // Select ALL from reader\r

- sniffState = SNF_ANTICOL1;\r

- }\r

- break;\r

- }\r

- case SNF_ANTICOL1:{\r

- if ((!reader) && (len == 5) && ((data[0] ^ data[1] ^ data[2] ^ data[3]) == data[4])) { // UID from tag (CL1) \r

- memcpy(sniffUID + 3, data, 4);\r

- sniffState = SNF_UID1;\r

- }\r

- break;\r

- }\r

+//-----------------------------------------------------------------------------

+// Merlok - 2012

+//

+// This code is licensed to you under the terms of the GNU GPL, version 2 or,

+// at your option, any later version. See the LICENSE.txt file for the text of

+// the license.

+//-----------------------------------------------------------------------------

+// Routines to support mifare classic sniffer.

+//-----------------------------------------------------------------------------

+

+#include "mifaresniff.h"

+

+#include "proxmark3.h"

+#include "util.h"

+#include "string.h"

+#include "iso14443crc.h"

+#include "iso14443a.h"

+#include "crapto1/crapto1.h"

+#include "mifareutil.h"

+#include "common.h"

+#include "usb_cdc.h"

+#include "BigBuf.h"

+#include "fpgaloader.h"

+

+static int sniffState = SNF_INIT;

+static uint8_t sniffUIDType;

+static uint8_t sniffUID[8] = {0x00};

+static uint8_t sniffATQA[2] = {0x00};

+static uint8_t sniffSAK;

+static uint8_t sniffBuf[16] = {0x00};

+static uint32_t timerData = 0;

+

+bool MfSniffInit(void){

+ memset(sniffUID, 0x00, 8);

+ memset(sniffATQA, 0x00, 2);

+ sniffSAK = 0;

+ sniffUIDType = SNF_UID_4;

+

+ return false;

+}

+

+bool MfSniffEnd(void){

+ LED_B_ON();

+ cmd_send(CMD_ACK,0,0,0,0,0);

+ LED_B_OFF();

+

+ return false;

+}

+

+bool RAMFUNC MfSniffLogic(const uint8_t *data, uint16_t len, uint8_t *parity, uint16_t bitCnt, bool reader) {

+

+ if (reader && (len == 1) && (bitCnt == 7)) { // reset on 7-Bit commands from reader

+ sniffState = SNF_INIT;

+ }

+

+ switch (sniffState) {

+ case SNF_INIT:{

+ if ((len == 1) && (reader) && (bitCnt == 7) ) { // REQA or WUPA from reader

+ sniffUIDType = SNF_UID_4;

+ memset(sniffUID, 0x00, 8);

+ memset(sniffATQA, 0x00, 2);

+ sniffSAK = 0;

+ sniffState = SNF_ATQA;

+ if (data[0] == 0x40)

+ sniffState = SNF_MAGIC_WUPC2;

+ }

+ break;

+ }

+ case SNF_MAGIC_WUPC2:

+ if ((len == 1) && (reader) && (data[0] == 0x43) ) {

+ sniffState = SNF_CARD_IDLE;

+ }

+ break;

+ case SNF_ATQA:{

+ if ((!reader) && (len == 2)) { // ATQA from tag

+ memcpy(sniffATQA, data, 2);

+ sniffState = SNF_UID1;

+ }

+ break;

+ }

case SNF_UID1:{\r

if ((reader) && (len == 9) && (data[0] == 0x93) && (data[1] == 0x70) && (CheckCrc14443(CRC_14443_A, data, 9))) { // Select 4 Byte UID from reader\r

case SNF_UID1:{\r

if ((reader) && (len == 9) && (data[0] == 0x93) && (data[1] == 0x70) && (CheckCrc14443(CRC_14443_A, data, 9))) { // Select 4 Byte UID from reader\r

+ memcpy(sniffUID + 3, &data[2], 4);\r

sniffState = SNF_SAK;\r

}\r

sniffState = SNF_SAK;\r

}\r

- break;\r

- }\r

- case SNF_SAK:{\r

- if ((!reader) && (len == 3) && (CheckCrc14443(CRC_14443_A, data, 3))) { // SAK from card?\r

- sniffSAK = data[0];\r

- if (sniffUID[3] == 0x88) { // CL2 UID part to be expected\r

- sniffState = SNF_ANTICOL2;\r

- } else { // select completed\r

- sniffState = SNF_CARD_IDLE;\r

- }\r

- break;\r

- }\r

- case SNF_ANTICOL2:{\r

- if ((!reader) && (len == 5) && ((data[0] ^ data[1] ^ data[2] ^ data[3]) == data[4])) { // CL2 UID \r

- memcpy(sniffUID, sniffUID+4, 3);\r

- memcpy(sniffUID+3, data, 4);\r

- sniffUIDType = SNF_UID_7;\r

- sniffState = SNF_UID2;\r

- }\r

- break;\r

+ break;

}\r

+ case SNF_SAK:{

+ if ((!reader) && (len == 3) && (CheckCrc14443(CRC_14443_A, data, 3))) { // SAK from card?

+ sniffSAK = data[0];

+ if ((sniffUID[3] == 0x88) && (sniffUIDType == SNF_UID_4)) { // CL2 UID part to be expected

+ sniffUIDType = SNF_UID_7;\r

+ memcpy(sniffUID, sniffUID + 4, 3);\r

+ sniffState = SNF_UID2;

+ } else { // select completed

+ sniffState = SNF_CARD_IDLE;

+ }

+ break;

+ }

case SNF_UID2:{\r

- if ((reader) && (len == 9) && (data[0] == 0x95) && (data[1] == 0x70) && (CheckCrc14443(CRC_14443_A, data, 9))) { // Select 2nd part of 7 Byte UID\r

+ if ((reader) && (len == 9) && (data[0] == 0x95) && (data[1] == 0x70) && (CheckCrc14443(CRC_14443_A, data, 9))) {\r

+ memcpy(sniffUID + 3, &data[2], 4);\r

sniffState = SNF_SAK;\r

}\r

break;\r

}\r

sniffState = SNF_SAK;\r

}\r

break;\r

}\r

- case SNF_CARD_IDLE:{ // trace the card select sequence\r

- sniffBuf[0] = 0xFF;\r

- sniffBuf[1] = 0xFF;\r

- memcpy(sniffBuf + 2, sniffUID, 7);\r

- memcpy(sniffBuf + 9, sniffATQA, 2);\r

- sniffBuf[11] = sniffSAK;\r

- sniffBuf[12] = 0xFF;\r

- sniffBuf[13] = 0xFF;\r

- LogTrace(sniffBuf, 14, 0, parity, true);\r

- } // intentionally no break;\r

- case SNF_CARD_CMD:{ \r

- LogTrace(data, len, 0, parity, true);\r

- sniffState = SNF_CARD_RESP;\r

- timerData = GetTickCount();\r

- break;\r

- }\r

- case SNF_CARD_RESP:{\r

- LogTrace(data, len, 0, parity, false);\r

- sniffState = SNF_CARD_CMD;\r

- timerData = GetTickCount();\r

- break;\r

- }\r

- \r

- default:\r

- sniffState = SNF_INIT;\r

- break;\r

- }\r

-\r

- return FALSE;\r

-}\r

-\r

-bool RAMFUNC MfSniffSend(uint16_t maxTimeoutMs) {\r

- if (traceLen && (GetTickCount() > timerData + maxTimeoutMs)) {\r

- return intMfSniffSend();\r

- }\r

- return FALSE;\r

-}\r

-\r

-// internal sending function. not a RAMFUNC.\r

-bool intMfSniffSend() {\r

-\r

- int pckSize = 0;\r

- int pckLen = traceLen;\r

- int pckNum = 0;\r

-\r

- FpgaDisableSscDma();\r

- while (pckLen > 0) {\r

- pckSize = MIN(USB_CMD_DATA_SIZE, pckLen);\r

- LED_B_ON();\r

- cmd_send(CMD_ACK, 1, pckSize, pckNum, trace + traceLen - pckLen, pckSize);\r

- LED_B_OFF();\r

-\r

- pckLen -= pckSize;\r

- pckNum++;\r

- }\r

-\r

- LED_B_ON();\r

- cmd_send(CMD_ACK,2,0,0,0,0);\r

- LED_B_OFF();\r

-\r

- iso14a_clear_trace();\r

- \r

- return TRUE;\r

-}\r

+ case SNF_CARD_IDLE:{ // trace the card select sequence

+ sniffBuf[0] = 0xFF;

+ sniffBuf[1] = 0xFF;

+ memcpy(sniffBuf + 2, sniffUID, 7);

+ memcpy(sniffBuf + 9, sniffATQA, 2);

+ sniffBuf[11] = sniffSAK;

+ sniffBuf[12] = 0xFF;

+ sniffBuf[13] = 0xFF;

+ LogTrace(sniffBuf, 14, 0, 0, NULL, true);

+ sniffState = SNF_CARD_CMD;

+ } // intentionally no break;

+ case SNF_CARD_CMD:{

+ LogTrace(data, len, 0, 0, parity, reader);

+ timerData = GetTickCount();

+ break;

+ }

+

+ default:

+ sniffState = SNF_INIT;

+ break;

+ }

+

+ return false;

+}

+

+bool RAMFUNC MfSniffSend(uint16_t maxTimeoutMs) {

+ if (BigBuf_get_traceLen() && (GetTickCount() > timerData + maxTimeoutMs)) {

+ return intMfSniffSend();

+ }

+ return false;

+}

+

+// internal sending function. not a RAMFUNC.

+bool intMfSniffSend() {

+

+ int pckSize = 0;

+ int pckLen = BigBuf_get_traceLen();

+ int pckNum = 0;

+ uint8_t *trace = BigBuf_get_addr();

+

+ FpgaDisableSscDma();

+ while (pckLen > 0) {

+ pckSize = MIN(USB_CMD_DATA_SIZE, pckLen);

+ LED_B_ON();

+ cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K, 1, BigBuf_get_traceLen(), pckSize, trace + BigBuf_get_traceLen() - pckLen, pckSize);

+ LED_B_OFF();

+

+ pckLen -= pckSize;

+ pckNum++;

+ }

+

+ LED_B_ON();

+ cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K,2,0,0,0,0);

+ LED_B_OFF();

+

+ clear_trace();

+

+ return true;

+}