Proxmark/proxmark3
1
1
Fork 0
mirror of https://github.com/Proxmark/proxmark3.git synced 2024-09-20 23:06:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #876 from pwpiwi/fix_iclass_reader

Browse source 
fix 'hf iclass reader'
* code deduplication. Use functions from iso15693.c
* speedup CodeIso15693AsReader()
* invert reader command coding. 0 now means 'unmodulated' ( = field on)
* decode SOF only as a valid tag response in Handle15693SamplesFromTag()
* complete decoding of EOF in Handle15693SamplesFromTag()
* determine and write correct times to trace
* FPGA-change: generate shorter frame signal to allow proper sync in StartCountSspClk()
* modify StartCountSspClk() for 16bit SSC transfers
* whitespace in util.c
* add specific LogTrace_ISO15693() with scaled down duration. Modify cmdhflist.c accordingly.
* allow 'hf 15 raw' with single byte commands
* check for buffer overflow, card timeout and single SOF in 'hf 15 raw'
* decode and handle SOF only responses in Handle14443bSamplesDemod()
* allow 1 byte commands with 'hf 14b raw'
* don't do READCHECK when not trying to authenticate
* standard LED handling
* remove unused FLAG_ICLASS_READER_ONLY_ONCE and FLAG_ICLASS_READER_ONE_TRY
* sanity check for negative times in TransmitTo15693Tag()
* increase reader timeout for 'hf 15' functions to be enough for slot 7 answers to ACTALL
* add 'hf iclass permute' inspired by RRG repository
* whitespace in cmdhficlass.c
This commit is contained in:
pwpiwi 2019-10-30 18:55:13 +01:00 committed by GitHub
parent b41be3cb11 ece38ef311
commit e55b441992
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
19 changed files with 1346 additions and 1278 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
armsrc/appmain.c
View file

@ -1327,8 +1327,11 @@ void UsbPacketReceived(uint8_t *packet, int len)
case CMD_ICLASS_READBLOCK: case CMD_ICLASS_READBLOCK:
iClass_ReadBlk(c->arg[0]); iClass_ReadBlk(c->arg[0]);
break; break;
case CMD_ICLASS_AUTHENTICATION: //check case CMD_ICLASS_CHECK:
iClass_Authentication(c->d.asBytes); iClass_Check(c->d.asBytes);
break;
case CMD_ICLASS_READCHECK:
iClass_Readcheck(c->arg[0], c->arg[1]);
break; break;
case CMD_ICLASS_DUMP: case CMD_ICLASS_DUMP:
iClass_Dump(c->arg[0], c->arg[1]); iClass_Dump(c->arg[0], c->arg[1]);

541
armsrc/iclass.c
View file

@ -57,14 +57,17 @@
#include "usb_cdc.h" // for usb_poll_validate_length #include "usb_cdc.h" // for usb_poll_validate_length
#include "fpgaloader.h" #include "fpgaloader.h"
static int timeout = 4096;
// iCLASS has a slightly different timing compared to ISO15693. According to the picopass data sheet the tag response is expected 330us after // iCLASS has a slightly different timing compared to ISO15693. According to the picopass data sheet the tag response is expected 330us after
// the reader command. This is measured from end of reader EOF to first modulation of the tag's SOF which starts with a 56,64us unmodulated period. // the reader command. This is measured from end of reader EOF to first modulation of the tag's SOF which starts with a 56,64us unmodulated period.
// 330us = 140 ssp_clk cycles @ 423,75kHz when simulating. // 330us = 140 ssp_clk cycles @ 423,75kHz when simulating.
// 56,64us = 24 ssp_clk_cycles // 56,64us = 24 ssp_clk_cycles
#define DELAY_ICLASS_VCD_TO_VICC_SIM 140 #define DELAY_ICLASS_VCD_TO_VICC_SIM (140 - 24)
#define TAG_SOF_UNMODULATED 24 // times in ssp_clk_cycles @ 3,3625MHz when acting as reader
#define DELAY_ICLASS_VICC_TO_VCD_READER DELAY_ISO15693_VICC_TO_VCD_READER
// times in samples @ 212kHz when acting as reader
#define ICLASS_READER_TIMEOUT_ACTALL 330 // 1558us, nominal 330us + 7slots*160us = 1450us
#define ICLASS_READER_TIMEOUT_OTHERS 80 // 380us, nominal 330us
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// The software UART that receives commands from the reader, and its state // The software UART that receives commands from the reader, and its state
@ -692,20 +695,18 @@ void RAMFUNC SnoopIClass(void) {
if (OutOfNDecoding((smpl & 0xF0) >> 4)) { if (OutOfNDecoding((smpl & 0xF0) >> 4)) {
rsamples = samples - Uart.samples; rsamples = samples - Uart.samples;
time_stop = (GetCountSspClk()-time_0) << 4; time_stop = (GetCountSspClk()-time_0) << 4;
LED_C_ON();
//if (!LogTrace(Uart.output, Uart.byteCnt, rsamples, Uart.parityBits,true)) break; //if (!LogTrace(Uart.output, Uart.byteCnt, rsamples, Uart.parityBits,true)) break;
//if (!LogTrace(NULL, 0, Uart.endTime*16 - DELAY_READER_AIR2ARM_AS_SNIFFER, 0, true)) break; //if (!LogTrace(NULL, 0, Uart.endTime*16 - DELAY_READER_AIR2ARM_AS_SNIFFER, 0, true)) break;
uint8_t parity[MAX_PARITY_SIZE]; uint8_t parity[MAX_PARITY_SIZE];
GetParity(Uart.output, Uart.byteCnt, parity); GetParity(Uart.output, Uart.byteCnt, parity);
LogTrace(Uart.output, Uart.byteCnt, time_start, time_stop, parity, true); LogTrace_ISO15693(Uart.output, Uart.byteCnt, time_start*32, time_stop*32, parity, true);
/* And ready to receive another command. */ /* And ready to receive another command. */
Uart.state = STATE_UNSYNCD; Uart.state = STATE_UNSYNCD;
/* And also reset the demod code, which might have been */ /* And also reset the demod code, which might have been */
/* false-triggered by the commands from the reader. */ /* false-triggered by the commands from the reader. */
Demod.state = DEMOD_UNSYNCD; Demod.state = DEMOD_UNSYNCD;
LED_B_OFF();
Uart.byteCnt = 0; Uart.byteCnt = 0;
} else { } else {
time_start = (GetCountSspClk()-time_0) << 4; time_start = (GetCountSspClk()-time_0) << 4;
@ -719,17 +720,15 @@ void RAMFUNC SnoopIClass(void) {
time_stop = (GetCountSspClk()-time_0) << 4; time_stop = (GetCountSspClk()-time_0) << 4;
rsamples = samples - Demod.samples; rsamples = samples - Demod.samples;
LED_B_ON();
uint8_t parity[MAX_PARITY_SIZE]; uint8_t parity[MAX_PARITY_SIZE];
GetParity(Demod.output, Demod.len, parity); GetParity(Demod.output, Demod.len, parity);
LogTrace(Demod.output, Demod.len, time_start, time_stop, parity, false); LogTrace_ISO15693(Demod.output, Demod.len, time_start*32, time_stop*32, parity, false);
// And ready to receive another response. // And ready to receive another response.
memset(&Demod, 0, sizeof(Demod)); memset(&Demod, 0, sizeof(Demod));
Demod.output = tagToReaderResponse; Demod.output = tagToReaderResponse;
Demod.state = DEMOD_UNSYNCD; Demod.state = DEMOD_UNSYNCD;
LED_C_OFF();
} else { } else {
time_start = (GetCountSspClk()-time_0) << 4; time_start = (GetCountSspClk()-time_0) << 4;
} }
@ -1230,9 +1229,9 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
A legit tag has about 273,4us delay between reader EOT and tag SOF. A legit tag has about 273,4us delay between reader EOT and tag SOF.
**/ **/
if (modulated_response_size > 0) { if (modulated_response_size > 0) {
uint32_t response_time = reader_eof_time + DELAY_ICLASS_VCD_TO_VICC_SIM - TAG_SOF_UNMODULATED - DELAY_ARM_TO_READER_SIM; uint32_t response_time = reader_eof_time + DELAY_ICLASS_VCD_TO_VICC_SIM;
TransmitTo15693Reader(modulated_response, modulated_response_size, &response_time, 0, false); TransmitTo15693Reader(modulated_response, modulated_response_size, &response_time, 0, false);
LogTrace(trace_data, trace_data_size, response_time + DELAY_ARM_TO_READER_SIM, response_time + (modulated_response_size << 6) + DELAY_ARM_TO_READER_SIM, NULL, false); LogTrace_ISO15693(trace_data, trace_data_size, response_time*32, response_time*32 + modulated_response_size/2, NULL, false);
} }
} }
@ -1327,214 +1326,22 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
/// THE READER CODE /// THE READER CODE
//----------------------------------------------------------------------------- static void ReaderTransmitIClass(uint8_t *frame, int len, uint32_t *start_time) {
// Transmit the command (to the tag) that was placed in ToSend[].
//-----------------------------------------------------------------------------
static void TransmitIClassCommand(const uint8_t *cmd, int len, int *samples, int *wait) {
int c;
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
AT91C_BASE_SSC->SSC_THR = 0x00;
FpgaSetupSsc(FPGA_MAJOR_MODE_HF_ISO14443A);
if (wait) { CodeIso15693AsReader(frame, len);
if (*wait < 10) *wait = 10;
for (c = 0; c < *wait;) { TransmitTo15693Tag(ToSend, ToSendMax, start_time);
if (AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
AT91C_BASE_SSC->SSC_THR = 0x00; // For exact timing!
c++;
}
if (AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
(void)r;
}
WDT_HIT();
}
}
uint8_t sendbyte; uint32_t end_time = *start_time + 32*(8*ToSendMax-4); // substract the 4 padding bits after EOF
bool firstpart = true; LogTrace_ISO15693(frame, len, *start_time*4, end_time*4, NULL, true);
c = 0;
for (;;) {
if (AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
// DOUBLE THE SAMPLES!
if (firstpart) {
sendbyte = (cmd[c] & 0xf0) | (cmd[c] >> 4);
} else {
sendbyte = (cmd[c] & 0x0f) | (cmd[c] << 4);
c++;
}
if (sendbyte == 0xff) {
sendbyte = 0xfe;
}
AT91C_BASE_SSC->SSC_THR = sendbyte;
firstpart = !firstpart;
if (c >= len) {
break;
}
}
if (AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
(void)r;
}
WDT_HIT();
}
if (samples && wait) *samples = (c + *wait) << 3;
} }
//----------------------------------------------------------------------------- static bool sendCmdGetResponseWithRetries(uint8_t* command, size_t cmdsize, uint8_t* resp, size_t max_resp_size,
// Prepare iClass reader command to send to FPGA uint8_t expected_size, uint8_t retries, uint32_t start_time, uint32_t *eof_time) {
//-----------------------------------------------------------------------------
void CodeIClassCommand(const uint8_t *cmd, int len) {
int i, j, k;
ToSendReset();
// Start of Communication: 1 out of 4
ToSend[++ToSendMax] = 0xf0;
ToSend[++ToSendMax] = 0x00;
ToSend[++ToSendMax] = 0x0f;
ToSend[++ToSendMax] = 0x00;
// Modulate the bytes
for (i = 0; i < len; i++) {
uint8_t b = cmd[i];
for (j = 0; j < 4; j++) {
for (k = 0; k < 4; k++) {
if (k == (b & 3)) {
ToSend[++ToSendMax] = 0x0f;
} else {
ToSend[++ToSendMax] = 0x00;
}
}
b >>= 2;
}
}
// End of Communication
ToSend[++ToSendMax] = 0x00;
ToSend[++ToSendMax] = 0x00;
ToSend[++ToSendMax] = 0xf0;
ToSend[++ToSendMax] = 0x00;
// Convert from last character reference to length
ToSendMax++;
}
static void ReaderTransmitIClass(uint8_t *frame, int len) {
int wait = 0;
int samples = 0;
// This is tied to other size changes
CodeIClassCommand(frame, len);
// Select the card
TransmitIClassCommand(ToSend, ToSendMax, &samples, &wait);
if (trigger)
LED_A_ON();
// Store reader command in buffer
uint8_t par[MAX_PARITY_SIZE];
GetParity(frame, len, par);
LogTrace(frame, len, rsamples, rsamples, par, true);
}
//-----------------------------------------------------------------------------
// Wait a certain time for tag response
// If a response is captured return true
// If it takes too long return false
//-----------------------------------------------------------------------------
static int GetIClassAnswer(uint8_t *receivedResponse, int maxLen, int *samples, int *elapsed) {
//uint8_t *buffer
// buffer needs to be 512 bytes
int c;
// Set FPGA mode to "reader listen mode", no modulation (listen
// only, since we are receiving, not transmitting).
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_LISTEN);
// Now get the answer from the card
Demod.output = receivedResponse;
Demod.len = 0;
Demod.state = DEMOD_UNSYNCD;
uint8_t b;
if (elapsed) *elapsed = 0;
bool skip = false;
c = 0;
for (;;) {
WDT_HIT();
if (BUTTON_PRESS()) return false;
if (AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
AT91C_BASE_SSC->SSC_THR = 0x00; // To make use of exact timing of next command from reader!!
if (elapsed) (*elapsed)++;
}
if (AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
if (c < timeout) {
c++;
} else {
return false;
}
b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
skip = !skip;
if (skip) continue;
if (ManchesterDecoding(b & 0x0f)) {
*samples = c << 3;
return true;
}
}
}
}
static int ReaderReceiveIClass(uint8_t *receivedAnswer) {
int samples = 0;
if (!GetIClassAnswer(receivedAnswer, 160, &samples, 0)) {
return false;
}
rsamples += samples;
uint8_t parity[MAX_PARITY_SIZE];
GetParity(receivedAnswer, Demod.len, parity);
LogTrace(receivedAnswer, Demod.len, rsamples, rsamples, parity, false);
if (samples == 0) return false;
return Demod.len;
}
static void setupIclassReader() {
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
// Reset trace buffer
set_tracing(true);
clear_trace();
// Setup SSC
FpgaSetupSsc(FPGA_MAJOR_MODE_HF_ISO14443A);
// Start from off (no field generated)
// Signal field is off with the appropriate LED
LED_D_OFF();
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
SpinDelay(200);
SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
// Now give it time to spin up.
// Signal field is on with the appropriate LED
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
SpinDelay(200);
LED_A_ON();
}
static bool sendCmdGetResponseWithRetries(uint8_t* command, size_t cmdsize, uint8_t* resp, uint8_t expected_size, uint8_t retries) {
while (retries-- > 0) { while (retries-- > 0) {
ReaderTransmitIClass(command, cmdsize); ReaderTransmitIClass(command, cmdsize, &start_time);
if (expected_size == ReaderReceiveIClass(resp)) { if (expected_size == GetIso15693AnswerFromTag(resp, max_resp_size, ICLASS_READER_TIMEOUT_OTHERS, eof_time)) {
return true; return true;
} }
} }
@ -1542,183 +1349,129 @@ static bool sendCmdGetResponseWithRetries(uint8_t* command, size_t cmdsize, uint
} }
/** /**
* @brief Talks to an iclass tag, sends the commands to get CSN and CC. * @brief Selects an iclass tag
* @param card_data where the CSN and CC are stored for return * @param card_data where the CSN is stored for return
* @return 0 = fail * @return false = fail
* 1 = Got CSN * true = success
* 2 = Got CSN and CC
*/ */
static uint8_t handshakeIclassTag_ext(uint8_t *card_data, bool use_credit_key) { static bool selectIclassTag(uint8_t *card_data, uint32_t *eof_time) {
static uint8_t act_all[] = { 0x0a }; uint8_t act_all[] = { 0x0a };
//static uint8_t identify[] = { 0x0c }; uint8_t identify[] = { 0x0c };
static uint8_t identify[] = { 0x0c, 0x00, 0x73, 0x33 }; uint8_t select[] = { 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
static uint8_t select[] = { 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
static uint8_t readcheck_cc[]= { 0x88, 0x02 };
if (use_credit_key)
readcheck_cc[0] = 0x18;
else
readcheck_cc[0] = 0x88;
uint8_t resp[ICLASS_BUFFER_SIZE]; uint8_t resp[ICLASS_BUFFER_SIZE];
uint8_t read_status = 0; uint32_t start_time = GetCountSspClk();
// Send act_all // Send act_all
ReaderTransmitIClass(act_all, 1); ReaderTransmitIClass(act_all, 1, &start_time);
// Card present? // Card present?
if (!ReaderReceiveIClass(resp)) return read_status;//Fail if (GetIso15693AnswerFromTag(resp, sizeof(resp), ICLASS_READER_TIMEOUT_ACTALL, eof_time) < 0) return false;//Fail
//Send Identify //Send Identify
ReaderTransmitIClass(identify, 1); start_time = *eof_time + DELAY_ICLASS_VICC_TO_VCD_READER;
ReaderTransmitIClass(identify, 1, &start_time);
//We expect a 10-byte response here, 8 byte anticollision-CSN and 2 byte CRC //We expect a 10-byte response here, 8 byte anticollision-CSN and 2 byte CRC
uint8_t len = ReaderReceiveIClass(resp); uint8_t len = GetIso15693AnswerFromTag(resp, sizeof(resp), ICLASS_READER_TIMEOUT_OTHERS, eof_time);
if (len != 10) return read_status;//Fail if (len != 10) return false;//Fail
//Copy the Anti-collision CSN to our select-packet //Copy the Anti-collision CSN to our select-packet
memcpy(&select[1], resp, 8); memcpy(&select[1], resp, 8);
//Select the card //Select the card
ReaderTransmitIClass(select, sizeof(select)); start_time = *eof_time + DELAY_ICLASS_VICC_TO_VCD_READER;
ReaderTransmitIClass(select, sizeof(select), &start_time);
//We expect a 10-byte response here, 8 byte CSN and 2 byte CRC //We expect a 10-byte response here, 8 byte CSN and 2 byte CRC
len = ReaderReceiveIClass(resp); len = GetIso15693AnswerFromTag(resp, sizeof(resp), ICLASS_READER_TIMEOUT_OTHERS, eof_time);
if (len != 10) return read_status;//Fail if (len != 10) return false;//Fail
//Success - level 1, we got CSN //Success - we got CSN
//Save CSN in response data //Save CSN in response data
memcpy(card_data, resp, 8); memcpy(card_data, resp, 8);
//Flag that we got to at least stage 1, read CSN return true;
read_status = 1;
// Card selected, now read e-purse (cc) (only 8 bytes no CRC)
ReaderTransmitIClass(readcheck_cc, sizeof(readcheck_cc));
if (ReaderReceiveIClass(resp) == 8) {
//Save CC (e-purse) in response data
memcpy(card_data+8, resp, 8);
read_status++;
}
return read_status;
}
static uint8_t handshakeIclassTag(uint8_t *card_data) {
return handshakeIclassTag_ext(card_data, false);
} }
// Reader iClass Anticollission // Select an iClass tag and read all blocks which are always readable without authentication
void ReaderIClass(uint8_t arg0) { void ReaderIClass(uint8_t arg0) {
LED_A_ON();
uint8_t card_data[6 * 8] = {0}; uint8_t card_data[6 * 8] = {0};
memset(card_data, 0xFF, sizeof(card_data)); memset(card_data, 0xFF, sizeof(card_data));
uint8_t last_csn[8] = {0,0,0,0,0,0,0,0};
uint8_t resp[ICLASS_BUFFER_SIZE]; uint8_t resp[ICLASS_BUFFER_SIZE];
memset(resp, 0xFF, sizeof(resp));
//Read conf block CRC(0x01) => 0xfa 0x22 //Read conf block CRC(0x01) => 0xfa 0x22
uint8_t readConf[] = { ICLASS_CMD_READ_OR_IDENTIFY, 0x01, 0xfa, 0x22}; uint8_t readConf[] = {ICLASS_CMD_READ_OR_IDENTIFY, 0x01, 0xfa, 0x22};
//Read e-purse block CRC(0x02) => 0x61 0x10
uint8_t readEpurse[] = {ICLASS_CMD_READ_OR_IDENTIFY, 0x02, 0x61, 0x10};
//Read App Issuer Area block CRC(0x05) => 0xde 0x64 //Read App Issuer Area block CRC(0x05) => 0xde 0x64
uint8_t readAA[] = { ICLASS_CMD_READ_OR_IDENTIFY, 0x05, 0xde, 0x64}; uint8_t readAA[] = {ICLASS_CMD_READ_OR_IDENTIFY, 0x05, 0xde, 0x64};
int read_status= 0;
uint8_t result_status = 0; uint8_t result_status = 0;
// flag to read until one tag is found successfully
bool abort_after_read = arg0 & FLAG_ICLASS_READER_ONLY_ONCE;
// flag to only try 5 times to find one tag then return
bool try_once = arg0 & FLAG_ICLASS_READER_ONE_TRY;
// if neither abort_after_read nor try_once then continue reading until button pressed.
bool use_credit_key = arg0 & FLAG_ICLASS_READER_CEDITKEY;
// test flags for what blocks to be sure to read // test flags for what blocks to be sure to read
uint8_t flagReadConfig = arg0 & FLAG_ICLASS_READER_CONF; uint8_t flagReadConfig = arg0 & FLAG_ICLASS_READER_CONF;
uint8_t flagReadCC = arg0 & FLAG_ICLASS_READER_CC; uint8_t flagReadCC = arg0 & FLAG_ICLASS_READER_CC;
uint8_t flagReadAA = arg0 & FLAG_ICLASS_READER_AA; uint8_t flagReadAA = arg0 & FLAG_ICLASS_READER_AA;
set_tracing(true); set_tracing(true);
setupIclassReader(); clear_trace();
Iso15693InitReader();
uint16_t tryCnt = 0; StartCountSspClk();
bool userCancelled = BUTTON_PRESS() || usb_poll_validate_length(); uint32_t start_time = 0;
while (!userCancelled) { uint32_t eof_time = 0;
// if only looking for one card try 2 times if we missed it the first time
if (try_once && tryCnt > 2) {
break;
}
tryCnt++;
if (!get_tracing()) {
DbpString("Trace full");
break;
}
WDT_HIT();
read_status = handshakeIclassTag_ext(card_data, use_credit_key); if (selectIclassTag(resp, &eof_time)) {
result_status = FLAG_ICLASS_READER_CSN;
if (read_status == 0) continue; memcpy(card_data, resp, 8);
if (read_status == 1) result_status = FLAG_ICLASS_READER_CSN;
if (read_status == 2) result_status = FLAG_ICLASS_READER_CSN | FLAG_ICLASS_READER_CC;
// handshakeIclass returns CSN|CC, but the actual block
// layout is CSN|CONFIG|CC, so here we reorder the data,
// moving CC forward 8 bytes
memcpy(card_data+16, card_data+8, 8);
//Read block 1, config
if (flagReadConfig) {
if (sendCmdGetResponseWithRetries(readConf, sizeof(readConf), resp, 10, 10)) {
result_status |= FLAG_ICLASS_READER_CONF;
memcpy(card_data+8, resp, 8);
} else {
Dbprintf("Failed to dump config block");
}
}
//Read block 5, AA
if (flagReadAA) {
if (sendCmdGetResponseWithRetries(readAA, sizeof(readAA), resp, 10, 10)) {
result_status |= FLAG_ICLASS_READER_AA;
memcpy(card_data + (8*5), resp, 8);
} else {
//Dbprintf("Failed to dump AA block");
}
}
// 0 : CSN
// 1 : Configuration
// 2 : e-purse
// 3 : kd / debit / aa2 (write-only)
// 4 : kc / credit / aa1 (write-only)
// 5 : AIA, Application issuer area
//Then we can 'ship' back the 6 * 8 bytes of data,
// with 0xFF:s in block 3 and 4.
LED_B_ON();
//Send back to client, but don't bother if we already sent this -
// only useful if looping in arm (not try_once && not abort_after_read)
if (memcmp(last_csn, card_data, 8) != 0) {
// If caller requires that we get Conf, CC, AA, continue until we got it
if ( (result_status ^ FLAG_ICLASS_READER_CSN ^ flagReadConfig ^ flagReadCC ^ flagReadAA) == 0) {
cmd_send(CMD_ACK, result_status, 0, 0, card_data, sizeof(card_data));
if (abort_after_read) {
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LED_A_OFF();
LED_B_OFF();
return;
}
//Save that we already sent this....
memcpy(last_csn, card_data, 8);
}
}
LED_B_OFF();
userCancelled = BUTTON_PRESS() || usb_poll_validate_length();
} }
if (userCancelled) {
cmd_send(CMD_ACK, 0xFF, 0, 0, card_data, 0); start_time = eof_time + DELAY_ICLASS_VICC_TO_VCD_READER;
} else {
cmd_send(CMD_ACK, 0, 0, 0, card_data, 0); //Read block 1, config
if (flagReadConfig) {
if (sendCmdGetResponseWithRetries(readConf, sizeof(readConf), resp, sizeof(resp), 10, 10, start_time, &eof_time)) {
result_status |= FLAG_ICLASS_READER_CONF;
memcpy(card_data+8, resp, 8);
} else {
Dbprintf("Failed to read config block");
}
start_time = eof_time + DELAY_ICLASS_VICC_TO_VCD_READER;
} }
//Read block 2, e-purse
if (flagReadCC) {
if (sendCmdGetResponseWithRetries(readEpurse, sizeof(readEpurse), resp, sizeof(resp), 10, 10, start_time, &eof_time)) {
result_status |= FLAG_ICLASS_READER_CC;
memcpy(card_data + (8*2), resp, 8);
} else {
Dbprintf("Failed to read e-purse");
}
start_time = eof_time + DELAY_ICLASS_VICC_TO_VCD_READER;
}
//Read block 5, AA
if (flagReadAA) {
if (sendCmdGetResponseWithRetries(readAA, sizeof(readAA), resp, sizeof(resp), 10, 10, start_time, &eof_time)) {
result_status |= FLAG_ICLASS_READER_AA;
memcpy(card_data + (8*5), resp, 8);
} else {
Dbprintf("Failed to read AA block");
}
}
cmd_send(CMD_ACK, result_status, 0, 0, card_data, sizeof(card_data));
LED_A_OFF(); LED_A_OFF();
} }
void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) { void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
LED_A_ON();
bool use_credit_key = false;
uint8_t card_data[USB_CMD_DATA_SIZE]={0}; uint8_t card_data[USB_CMD_DATA_SIZE]={0};
uint16_t block_crc_LUT[255] = {0}; uint16_t block_crc_LUT[255] = {0};
@ -1729,6 +1482,9 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
} }
//Dbprintf("Lookup table: %02x %02x %02x" ,block_crc_LUT[0],block_crc_LUT[1],block_crc_LUT[2]); //Dbprintf("Lookup table: %02x %02x %02x" ,block_crc_LUT[0],block_crc_LUT[1],block_crc_LUT[2]);
uint8_t readcheck_cc[] = { ICLASS_CMD_READCHECK_KD, 0x02 };
if (use_credit_key)
readcheck_cc[0] = ICLASS_CMD_READCHECK_KC;
uint8_t check[] = { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; uint8_t check[] = { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t read[] = { 0x0c, 0x00, 0x00, 0x00 }; uint8_t read[] = { 0x0c, 0x00, 0x00, 0x00 };
@ -1746,8 +1502,13 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
uint8_t resp[ICLASS_BUFFER_SIZE]; uint8_t resp[ICLASS_BUFFER_SIZE];
setupIclassReader();
set_tracing(true); set_tracing(true);
clear_trace();
Iso15693InitReader();
StartCountSspClk();
uint32_t start_time = 0;
uint32_t eof_time = 0;
while (!BUTTON_PRESS()) { while (!BUTTON_PRESS()) {
@ -1758,13 +1519,16 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
break; break;
} }
uint8_t read_status = handshakeIclassTag(card_data); if (!selectIclassTag(card_data, &eof_time)) continue;
if (read_status < 2) continue;
//for now replay captured auth (as cc not updated) start_time = eof_time + DELAY_ICLASS_VICC_TO_VCD_READER;
if (!sendCmdGetResponseWithRetries(readcheck_cc, sizeof(readcheck_cc), resp, sizeof(resp), 8, 3, start_time, &eof_time)) continue;
// replay captured auth (cc must not have been updated)
memcpy(check+5, MAC, 4); memcpy(check+5, MAC, 4);
if (!sendCmdGetResponseWithRetries(check, sizeof(check), resp, 4, 5)) { start_time = eof_time + DELAY_ICLASS_VICC_TO_VCD_READER;
if (!sendCmdGetResponseWithRetries(check, sizeof(check), resp, sizeof(resp), 4, 5, start_time, &eof_time)) {
Dbprintf("Error: Authentication Fail!"); Dbprintf("Error: Authentication Fail!");
continue; continue;
} }
@ -1775,7 +1539,9 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
read[2] = crc >> 8; read[2] = crc >> 8;
read[3] = crc & 0xff; read[3] = crc & 0xff;
if (!sendCmdGetResponseWithRetries(read, sizeof(read),resp, 10, 10)) { start_time = eof_time + DELAY_ICLASS_VICC_TO_VCD_READER;
if (!sendCmdGetResponseWithRetries(read, sizeof(read), resp, sizeof(resp), 10, 10, start_time, &eof_time)) {
start_time = eof_time + DELAY_ICLASS_VICC_TO_VCD_READER;
Dbprintf("Dump config (block 1) failed"); Dbprintf("Dump config (block 1) failed");
continue; continue;
} }
@ -1800,7 +1566,8 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
read[2] = crc >> 8; read[2] = crc >> 8;
read[3] = crc & 0xff; read[3] = crc & 0xff;
if (sendCmdGetResponseWithRetries(read, sizeof(read), resp, 10, 10)) { start_time = eof_time + DELAY_ICLASS_VICC_TO_VCD_READER;
if (sendCmdGetResponseWithRetries(read, sizeof(read), resp, sizeof(resp), 10, 10, start_time, &eof_time)) {
Dbprintf(" %02x: %02x %02x %02x %02x %02x %02x %02x %02x", Dbprintf(" %02x: %02x %02x %02x %02x %02x %02x %02x %02x",
block, resp[0], resp[1], resp[2], block, resp[0], resp[1], resp[2],
resp[3], resp[4], resp[5], resp[3], resp[4], resp[5],
@ -1849,43 +1616,68 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
0); 0);
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LED_D_OFF();
LED_A_OFF(); LED_A_OFF();
} }
void iClass_Authentication(uint8_t *MAC) {
uint8_t check[] = { ICLASS_CMD_CHECK_KD, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; void iClass_Check(uint8_t *MAC) {
uint8_t resp[ICLASS_BUFFER_SIZE]; uint8_t check[9] = {ICLASS_CMD_CHECK_KD, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
uint8_t resp[4];
memcpy(check+5, MAC, 4); memcpy(check+5, MAC, 4);
bool isOK; uint32_t eof_time;
isOK = sendCmdGetResponseWithRetries(check, sizeof(check), resp, 4, 6); bool isOK = sendCmdGetResponseWithRetries(check, sizeof(check), resp, sizeof(resp), 4, 6, 0, &eof_time);
cmd_send(CMD_ACK,isOK, 0, 0, 0, 0); cmd_send(CMD_ACK, isOK, 0, 0, resp, sizeof(resp));
} }
void iClass_Readcheck(uint8_t block, bool use_credit_key) {
uint8_t readcheck[2] = {ICLASS_CMD_READCHECK_KD, block};
if (use_credit_key) {
readcheck[0] = ICLASS_CMD_READCHECK_KC;
}
uint8_t resp[8];
uint32_t eof_time;
bool isOK = sendCmdGetResponseWithRetries(readcheck, sizeof(readcheck), resp, sizeof(resp), 8, 6, 0, &eof_time);
cmd_send(CMD_ACK, isOK, 0, 0, resp, sizeof(resp));
}
static bool iClass_ReadBlock(uint8_t blockNo, uint8_t *readdata) { static bool iClass_ReadBlock(uint8_t blockNo, uint8_t *readdata) {
uint8_t readcmd[] = {ICLASS_CMD_READ_OR_IDENTIFY, blockNo, 0x00, 0x00}; //0x88, 0x00 // can i use 0C? uint8_t readcmd[] = {ICLASS_CMD_READ_OR_IDENTIFY, blockNo, 0x00, 0x00}; //0x88, 0x00 // can i use 0C?
char bl = blockNo; char bl = blockNo;
uint16_t rdCrc = iclass_crc16(&bl, 1); uint16_t rdCrc = iclass_crc16(&bl, 1);
readcmd[2] = rdCrc >> 8; readcmd[2] = rdCrc >> 8;
readcmd[3] = rdCrc & 0xff; readcmd[3] = rdCrc & 0xff;
uint8_t resp[] = {0,0,0,0,0,0,0,0,0,0}; uint8_t resp[10];
bool isOK = false; bool isOK = false;
uint32_t eof_time;
//readcmd[1] = blockNo; isOK = sendCmdGetResponseWithRetries(readcmd, sizeof(readcmd), resp, sizeof(resp), 10, 10, 0, &eof_time);
isOK = sendCmdGetResponseWithRetries(readcmd, sizeof(readcmd), resp, 10, 10);
memcpy(readdata, resp, sizeof(resp)); memcpy(readdata, resp, sizeof(resp));
return isOK; return isOK;
} }
void iClass_ReadBlk(uint8_t blockno) { void iClass_ReadBlk(uint8_t blockno) {
LED_A_ON();
uint8_t readblockdata[] = {0,0,0,0,0,0,0,0,0,0}; uint8_t readblockdata[] = {0,0,0,0,0,0,0,0,0,0};
bool isOK = false; bool isOK = false;
isOK = iClass_ReadBlock(blockno, readblockdata); isOK = iClass_ReadBlock(blockno, readblockdata);
cmd_send(CMD_ACK, isOK, 0, 0, readblockdata, 8); cmd_send(CMD_ACK, isOK, 0, 0, readblockdata, 8);
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LED_D_OFF();
LED_A_OFF();
} }
void iClass_Dump(uint8_t blockno, uint8_t numblks) { void iClass_Dump(uint8_t blockno, uint8_t numblks) {
LED_A_ON();
uint8_t readblockdata[] = {0,0,0,0,0,0,0,0,0,0}; uint8_t readblockdata[] = {0,0,0,0,0,0,0,0,0,0};
bool isOK = false; bool isOK = false;
uint8_t blkCnt = 0; uint8_t blkCnt = 0;
@ -1915,12 +1707,19 @@ void iClass_Dump(uint8_t blockno, uint8_t numblks) {
} }
//return pointer to dump memory in arg3 //return pointer to dump memory in arg3
cmd_send(CMD_ACK, isOK, blkCnt, BigBuf_max_traceLen(), 0, 0); cmd_send(CMD_ACK, isOK, blkCnt, BigBuf_max_traceLen(), 0, 0);
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LEDsoff(); LED_D_OFF();
BigBuf_free(); BigBuf_free();
LED_A_OFF();
} }
static bool iClass_WriteBlock_ext(uint8_t blockNo, uint8_t *data) { static bool iClass_WriteBlock_ext(uint8_t blockNo, uint8_t *data) {
LED_A_ON();
uint8_t write[] = { ICLASS_CMD_UPDATE, blockNo, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; uint8_t write[] = { ICLASS_CMD_UPDATE, blockNo, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
//uint8_t readblockdata[10]; //uint8_t readblockdata[10];
//write[1] = blockNo; //write[1] = blockNo;
@ -1929,23 +1728,32 @@ static bool iClass_WriteBlock_ext(uint8_t blockNo, uint8_t *data) {
uint16_t wrCrc = iclass_crc16(wrCmd, 13); uint16_t wrCrc = iclass_crc16(wrCmd, 13);
write[14] = wrCrc >> 8; write[14] = wrCrc >> 8;
write[15] = wrCrc & 0xff; write[15] = wrCrc & 0xff;
uint8_t resp[] = {0,0,0,0,0,0,0,0,0,0}; uint8_t resp[10];
bool isOK = false; bool isOK = false;
uint32_t eof_time = 0;
isOK = sendCmdGetResponseWithRetries(write, sizeof(write), resp, sizeof(resp), 10); isOK = sendCmdGetResponseWithRetries(write, sizeof(write), resp, sizeof(resp), 10, 10, 0, &eof_time);
uint32_t start_time = eof_time + DELAY_ICLASS_VICC_TO_VCD_READER;
if (isOK) { //if reader responded correctly if (isOK) { //if reader responded correctly
//Dbprintf("WriteResp: %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",resp[0],resp[1],resp[2],resp[3],resp[4],resp[5],resp[6],resp[7],resp[8],resp[9]); //Dbprintf("WriteResp: %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",resp[0],resp[1],resp[2],resp[3],resp[4],resp[5],resp[6],resp[7],resp[8],resp[9]);
if (memcmp(write+2, resp, 8)) { //if response is not equal to write values if (memcmp(write+2, resp, 8)) { //if response is not equal to write values
if (blockNo != 3 && blockNo != 4) { //if not programming key areas (note key blocks don't get programmed with actual key data it is xor data) if (blockNo != 3 && blockNo != 4) { //if not programming key areas (note key blocks don't get programmed with actual key data it is xor data)
//error try again //error try again
isOK = sendCmdGetResponseWithRetries(write, sizeof(write), resp, sizeof(resp), 10); isOK = sendCmdGetResponseWithRetries(write, sizeof(write), resp, sizeof(resp), 10, 10, start_time, &eof_time);
} }
} }
} }
LED_A_OFF();
return isOK; return isOK;
} }
void iClass_WriteBlock(uint8_t blockNo, uint8_t *data) { void iClass_WriteBlock(uint8_t blockNo, uint8_t *data) {
LED_A_ON();
bool isOK = iClass_WriteBlock_ext(blockNo, data); bool isOK = iClass_WriteBlock_ext(blockNo, data);
if (isOK){ if (isOK){
Dbprintf("Write block [%02x] successful", blockNo); Dbprintf("Write block [%02x] successful", blockNo);
@ -1953,7 +1761,11 @@ void iClass_WriteBlock(uint8_t blockNo, uint8_t *data) {
Dbprintf("Write block [%02x] failed", blockNo); Dbprintf("Write block [%02x] failed", blockNo);
} }
cmd_send(CMD_ACK, isOK, 0, 0, 0, 0); cmd_send(CMD_ACK, isOK, 0, 0, 0, 0);
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LED_D_OFF();
LED_A_OFF();
} }
void iClass_Clone(uint8_t startblock, uint8_t endblock, uint8_t *data) { void iClass_Clone(uint8_t startblock, uint8_t endblock, uint8_t *data) {
@ -1981,5 +1793,6 @@ void iClass_Clone(uint8_t startblock, uint8_t endblock, uint8_t *data) {
cmd_send(CMD_ACK, 1, 0, 0, 0, 0); cmd_send(CMD_ACK, 1, 0, 0, 0, 0);
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LEDsoff(); LED_D_OFF();
LED_A_OFF();
} }

4
armsrc/iclass.h
View file

@ -15,6 +15,7 @@
#define ICLASS_H__ #define ICLASS_H__
#include <stdint.h> #include <stdint.h>
#include <stdbool.h>
#include "common.h" // for RAMFUNC #include "common.h" // for RAMFUNC
extern void RAMFUNC SnoopIClass(void); extern void RAMFUNC SnoopIClass(void);
@ -22,7 +23,8 @@ extern void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t
extern void ReaderIClass(uint8_t arg0); extern void ReaderIClass(uint8_t arg0);
extern void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC); extern void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC);
extern void IClass_iso14443A_GetPublic(uint8_t arg0); extern void IClass_iso14443A_GetPublic(uint8_t arg0);
extern void iClass_Authentication(uint8_t *MAC); extern void iClass_Readcheck(uint8_t block, bool use_credit_key);
extern void iClass_Check(uint8_t *MAC);
extern void iClass_WriteBlock(uint8_t blockNo, uint8_t *data); extern void iClass_WriteBlock(uint8_t blockNo, uint8_t *data);
extern void iClass_ReadBlk(uint8_t blockNo); extern void iClass_ReadBlk(uint8_t blockNo);
extern void iClass_Dump(uint8_t blockno, uint8_t numblks); extern void iClass_Dump(uint8_t blockno, uint8_t numblks);

94
armsrc/iso14443b.c
View file

@ -586,9 +586,10 @@ static RAMFUNC int Handle14443bSamplesDemod(int ci, int cq)
Demod.state = DEMOD_UNSYNCD; Demod.state = DEMOD_UNSYNCD;
} else { } else {
LED_C_ON(); // Got SOF LED_C_ON(); // Got SOF
Demod.state = DEMOD_AWAITING_START_BIT;
Demod.posCount = 0; Demod.posCount = 0;
Demod.bitCount = 0;
Demod.len = 0; Demod.len = 0;
Demod.state = DEMOD_AWAITING_START_BIT;
/* this had been used to add RSSI (Received Signal Strength Indication) to traces. Currently not implemented. /* this had been used to add RSSI (Received Signal Strength Indication) to traces. Currently not implemented.
Demod.metricN = 0; Demod.metricN = 0;
Demod.metric = 0; Demod.metric = 0;
@ -605,13 +606,16 @@ static RAMFUNC int Handle14443bSamplesDemod(int ci, int cq)
case DEMOD_AWAITING_START_BIT: case DEMOD_AWAITING_START_BIT:
Demod.posCount++; Demod.posCount++;
MAKE_SOFT_DECISION(); MAKE_SOFT_DECISION();
if(v > 0) { if (v > 0) {
if(Demod.posCount > 3*2) { // max 19us between characters = 16 1/fs, max 3 etu after low phase of SOF = 24 1/fs if (Demod.posCount > 3*2) { // max 19us between characters = 16 1/fs, max 3 etu after low phase of SOF = 24 1/fs
Demod.state = DEMOD_UNSYNCD;
LED_C_OFF(); LED_C_OFF();
if (Demod.bitCount == 0 && Demod.len == 0) { // received SOF only, this is valid for iClass/Picopass
return true;
} else {
Demod.state = DEMOD_UNSYNCD;
}
} }
} else { // start bit detected } else { // start bit detected
Demod.bitCount = 0;
Demod.posCount = 1; // this was the first half Demod.posCount = 1; // this was the first half
Demod.thisBit = v; Demod.thisBit = v;
Demod.shiftReg = 0; Demod.shiftReg = 0;
@ -621,7 +625,7 @@ static RAMFUNC int Handle14443bSamplesDemod(int ci, int cq)
case DEMOD_RECEIVING_DATA: case DEMOD_RECEIVING_DATA:
MAKE_SOFT_DECISION(); MAKE_SOFT_DECISION();
if(Demod.posCount == 0) { // first half of bit if (Demod.posCount == 0) { // first half of bit
Demod.thisBit = v; Demod.thisBit = v;
Demod.posCount = 1; Demod.posCount = 1;
} else { // second half of bit } else { // second half of bit
@ -637,22 +641,23 @@ static RAMFUNC int Handle14443bSamplesDemod(int ci, int cq)
*/ */
Demod.shiftReg >>= 1; Demod.shiftReg >>= 1;
if(Demod.thisBit > 0) { // logic '1' if (Demod.thisBit > 0) { // logic '1'
Demod.shiftReg |= 0x200; Demod.shiftReg |= 0x200;
} }
Demod.bitCount++; Demod.bitCount++;
if(Demod.bitCount == 10) { if (Demod.bitCount == 10) {
uint16_t s = Demod.shiftReg; uint16_t s = Demod.shiftReg;
if((s & 0x200) && !(s & 0x001)) { // stop bit == '1', start bit == '0' if ((s & 0x200) && !(s & 0x001)) { // stop bit == '1', start bit == '0'
uint8_t b = (s >> 1); uint8_t b = (s >> 1);
Demod.output[Demod.len] = b; Demod.output[Demod.len] = b;
Demod.len++; Demod.len++;
Demod.bitCount = 0;
Demod.state = DEMOD_AWAITING_START_BIT; Demod.state = DEMOD_AWAITING_START_BIT;
} else { } else {
Demod.state = DEMOD_UNSYNCD; Demod.state = DEMOD_UNSYNCD;
LED_C_OFF(); LED_C_OFF();
if(s == 0x000) { if (s == 0x000) {
// This is EOF (start, stop and all data bits == '0' // This is EOF (start, stop and all data bits == '0'
return true; return true;
} }
@ -693,8 +698,8 @@ static void DemodInit(uint8_t *data)
* Demodulate the samples we received from the tag, also log to tracebuffer * Demodulate the samples we received from the tag, also log to tracebuffer
* quiet: set to 'true' to disable debug output * quiet: set to 'true' to disable debug output
*/ */
static void GetSamplesFor14443bDemod(int timeout, bool quiet) static int GetSamplesFor14443bDemod(int timeout, bool quiet) {
{ int ret = 0;
int maxBehindBy = 0; int maxBehindBy = 0;
bool gotFrame = false; bool gotFrame = false;
int lastRxCounter, samples = 0; int lastRxCounter, samples = 0;
@ -750,12 +755,14 @@ static void GetSamplesFor14443bDemod(int timeout, bool quiet)
} }
samples++; samples++;
if(Handle14443bSamplesDemod(ci, cq)) { if (Handle14443bSamplesDemod(ci, cq)) {
ret = Demod.len;
gotFrame = true; gotFrame = true;
break; break;
} }
if(samples > timeout && Demod.state < DEMOD_PHASE_REF_TRAINING) { if(samples > timeout && Demod.state < DEMOD_PHASE_REF_TRAINING) {
ret = -1;
LED_C_OFF(); LED_C_OFF();
break; break;
} }
@ -764,10 +771,14 @@ static void GetSamplesFor14443bDemod(int timeout, bool quiet)
FpgaDisableSscDma(); FpgaDisableSscDma();
if (!quiet) Dbprintf("max behindby = %d, samples = %d, gotFrame = %d, Demod.len = %d, Demod.sumI = %d, Demod.sumQ = %d", maxBehindBy, samples, gotFrame, Demod.len, Demod.sumI, Demod.sumQ); if (!quiet) Dbprintf("max behindby = %d, samples = %d, gotFrame = %d, Demod.len = %d, Demod.sumI = %d, Demod.sumQ = %d", maxBehindBy, samples, gotFrame, Demod.len, Demod.sumI, Demod.sumQ);
//Tracing
if (Demod.len > 0) { if (ret < 0) {
LogTrace(Demod.output, Demod.len, 0, 0, NULL, false); return ret;
} }
//Tracing
LogTrace(Demod.output, Demod.len, 0, 0, NULL, false);
return ret;
} }
@ -858,8 +869,7 @@ static void CodeAndTransmit14443bAsReader(const uint8_t *cmd, int len)
/* Sends an APDU to the tag /* Sends an APDU to the tag
* TODO: check CRC and preamble * TODO: check CRC and preamble
*/ */
int iso14443b_apdu(uint8_t const *message, size_t message_length, uint8_t *response) int iso14443b_apdu(uint8_t const *message, size_t message_length, uint8_t *response) {
{
LED_A_ON(); LED_A_ON();
uint8_t message_frame[message_length + 4]; uint8_t message_frame[message_length + 4];
// PCB // PCB
@ -874,21 +884,19 @@ int iso14443b_apdu(uint8_t const *message, size_t message_length, uint8_t *respo
// send // send
CodeAndTransmit14443bAsReader(message_frame, message_length + 4); CodeAndTransmit14443bAsReader(message_frame, message_length + 4);
// get response // get response
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true); int ret = GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
FpgaDisableTracing(); FpgaDisableTracing();
if(Demod.len < 3) if (ret < 3) {
{
LED_A_OFF(); LED_A_OFF();
return 0; return 0;
} }
// TODO: Check CRC // TODO: Check CRC
// copy response contents // copy response contents
if(response != NULL) if (response != NULL) {
{
memcpy(response, Demod.output, Demod.len); memcpy(response, Demod.output, Demod.len);
} }
LED_A_OFF(); LED_A_OFF();
return Demod.len; return ret;
} }
/* Perform the ISO 14443 B Card Selection procedure /* Perform the ISO 14443 B Card Selection procedure
@ -907,10 +915,9 @@ int iso14443b_select_card()
// first, wake up the tag // first, wake up the tag
CodeAndTransmit14443bAsReader(wupb, sizeof(wupb)); CodeAndTransmit14443bAsReader(wupb, sizeof(wupb));
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true); int ret = GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
// ATQB too short? // ATQB too short?
if (Demod.len < 14) if (ret < 14) {
{
return 2; return 2;
} }
@ -922,10 +929,9 @@ int iso14443b_select_card()
attrib[7] = Demod.output[10] & 0x0F; attrib[7] = Demod.output[10] & 0x0F;
ComputeCrc14443(CRC_14443_B, attrib, 9, attrib + 9, attrib + 10); ComputeCrc14443(CRC_14443_B, attrib, 9, attrib + 9, attrib + 10);
CodeAndTransmit14443bAsReader(attrib, sizeof(attrib)); CodeAndTransmit14443bAsReader(attrib, sizeof(attrib));
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true); ret = GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
// Answer to ATTRIB too short? // Answer to ATTRIB too short?
if(Demod.len < 3) if (ret < 3) {
{
return 2; return 2;
} }
// reset PCB block number // reset PCB block number
@ -985,9 +991,9 @@ void ReadSTMemoryIso14443b(uint32_t dwLast)
// First command: wake up the tag using the INITIATE command // First command: wake up the tag using the INITIATE command
uint8_t cmd1[] = {0x06, 0x00, 0x97, 0x5b}; uint8_t cmd1[] = {0x06, 0x00, 0x97, 0x5b};
CodeAndTransmit14443bAsReader(cmd1, sizeof(cmd1)); CodeAndTransmit14443bAsReader(cmd1, sizeof(cmd1));
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true); int ret = GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
if (Demod.len == 0) { if (ret < 0) {
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
DbpString("No response from tag"); DbpString("No response from tag");
LEDsoff(); LEDsoff();
@ -1003,7 +1009,7 @@ void ReadSTMemoryIso14443b(uint32_t dwLast)
cmd1[1] = Demod.output[0]; cmd1[1] = Demod.output[0];
ComputeCrc14443(CRC_14443_B, cmd1, 2, &cmd1[2], &cmd1[3]); ComputeCrc14443(CRC_14443_B, cmd1, 2, &cmd1[2], &cmd1[3]);
CodeAndTransmit14443bAsReader(cmd1, sizeof(cmd1)); CodeAndTransmit14443bAsReader(cmd1, sizeof(cmd1));
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true); ret = GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
if (Demod.len != 3) { if (Demod.len != 3) {
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
Dbprintf("Expected 3 bytes from tag, got %d", Demod.len); Dbprintf("Expected 3 bytes from tag, got %d", Demod.len);
@ -1031,8 +1037,8 @@ void ReadSTMemoryIso14443b(uint32_t dwLast)
cmd1[0] = 0x0B; cmd1[0] = 0x0B;
ComputeCrc14443(CRC_14443_B, cmd1, 1 , &cmd1[1], &cmd1[2]); ComputeCrc14443(CRC_14443_B, cmd1, 1 , &cmd1[1], &cmd1[2]);
CodeAndTransmit14443bAsReader(cmd1, 3); // Only first three bytes for this one CodeAndTransmit14443bAsReader(cmd1, 3); // Only first three bytes for this one
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true); ret = GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
if (Demod.len != 10) { if (ret != 10) {
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
Dbprintf("Expected 10 bytes from tag, got %d", Demod.len); Dbprintf("Expected 10 bytes from tag, got %d", Demod.len);
LEDsoff(); LEDsoff();
@ -1062,8 +1068,8 @@ void ReadSTMemoryIso14443b(uint32_t dwLast)
cmd1[1] = i; cmd1[1] = i;
ComputeCrc14443(CRC_14443_B, cmd1, 2, &cmd1[2], &cmd1[3]); ComputeCrc14443(CRC_14443_B, cmd1, 2, &cmd1[2], &cmd1[3]);
CodeAndTransmit14443bAsReader(cmd1, sizeof(cmd1)); CodeAndTransmit14443bAsReader(cmd1, sizeof(cmd1));
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true); ret = GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
if (Demod.len != 6) { // Check if we got an answer from the tag if (ret != 6) { // Check if we got an answer from the tag
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
DbpString("Expected 6 bytes from tag, got less..."); DbpString("Expected 6 bytes from tag, got less...");
LEDsoff(); LEDsoff();
@ -1071,7 +1077,7 @@ void ReadSTMemoryIso14443b(uint32_t dwLast)
} }
// The check the CRC of the answer (use cmd1 as temporary variable): // The check the CRC of the answer (use cmd1 as temporary variable):
ComputeCrc14443(CRC_14443_B, Demod.output, 4, &cmd1[2], &cmd1[3]); ComputeCrc14443(CRC_14443_B, Demod.output, 4, &cmd1[2], &cmd1[3]);
if(cmd1[2] != Demod.output[4] || cmd1[3] != Demod.output[5]) { if (cmd1[2] != Demod.output[4] || cmd1[3] != Demod.output[5]) {
Dbprintf("CRC Error reading block! Expected: %04x got: %04x", Dbprintf("CRC Error reading block! Expected: %04x got: %04x",
(cmd1[2]<<8)+cmd1[3], (Demod.output[4]<<8)+Demod.output[5]); (cmd1[2]<<8)+cmd1[3], (Demod.output[4]<<8)+Demod.output[5]);
// Do not return;, let's go on... (we should retry, maybe ?) // Do not return;, let's go on... (we should retry, maybe ?)
@ -1213,8 +1219,8 @@ void RAMFUNC SnoopIso14443b(void)
ReaderIsActive = (Uart.state > STATE_GOT_FALLING_EDGE_OF_SOF); ReaderIsActive = (Uart.state > STATE_GOT_FALLING_EDGE_OF_SOF);
} }
if(!ReaderIsActive && triggered) { // no need to try decoding tag data if the reader is sending or not yet triggered if (!ReaderIsActive && triggered) { // no need to try decoding tag data if the reader is sending or not yet triggered
if(Handle14443bSamplesDemod(ci/2, cq/2)) { if (Handle14443bSamplesDemod(ci/2, cq/2) >= 0) {
//Use samples as a time measurement //Use samples as a time measurement
LogTrace(Demod.output, Demod.len, samples, samples, NULL, false); LogTrace(Demod.output, Demod.len, samples, samples, NULL, false);
// And ready to receive another response. // And ready to receive another response.
@ -1265,17 +1271,17 @@ void SendRawCommand14443B(uint32_t datalen, uint32_t recv, uint8_t powerfield, u
CodeAndTransmit14443bAsReader(data, datalen); CodeAndTransmit14443bAsReader(data, datalen);
if(recv) { if (recv) {
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true); int ret = GetSamplesFor14443bDemod(5*RECEIVE_SAMPLES_TIMEOUT, true);
FpgaDisableTracing(); FpgaDisableTracing();
uint16_t iLen = MIN(Demod.len, USB_CMD_DATA_SIZE); uint16_t iLen = MIN(Demod.len, USB_CMD_DATA_SIZE);
cmd_send(CMD_ACK, iLen, 0, 0, Demod.output, iLen); cmd_send(CMD_ACK, ret, 0, 0, Demod.output, iLen);
} }
FpgaDisableTracing(); FpgaDisableTracing();
} }
if(!powerfield) { if (!powerfield) {
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LED_D_OFF(); LED_D_OFF();
} }

490
armsrc/iso15693.c
View file

@ -64,8 +64,26 @@
#define arraylen(x) (sizeof(x)/sizeof((x)[0])) #define arraylen(x) (sizeof(x)/sizeof((x)[0]))
// Delays in SSP_CLK ticks.
// SSP_CLK runs at 13,56MHz / 32 = 423.75kHz when simulating a tag
#define DELAY_READER_TO_ARM 8
#define DELAY_ARM_TO_READER 0
//SSP_CLK runs at 13.56MHz / 4 = 3,39MHz when acting as reader. All values should be multiples of 16
#define DELAY_TAG_TO_ARM 32
#define DELAY_ARM_TO_TAG 16
static int DEBUG = 0; static int DEBUG = 0;
// specific LogTrace function for ISO15693: the duration needs to be scaled because otherwise it won't fit into a uint16_t
bool LogTrace_ISO15693(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_start, uint32_t timestamp_end, uint8_t *parity, bool readerToTag) {
uint32_t duration = timestamp_end - timestamp_start;
duration /= 32;
timestamp_end = timestamp_start + duration;
return LogTrace(btBytes, iLen, timestamp_start, timestamp_end, parity, readerToTag);
}
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
// ISO 15693 Part 2 - Air Interface // ISO 15693 Part 2 - Air Interface
// This section basically contains transmission and receiving of bits // This section basically contains transmission and receiving of bits
@ -84,83 +102,36 @@ static int DEBUG = 0;
// resulting data rate is 26.48 kbit/s (fc/512) // resulting data rate is 26.48 kbit/s (fc/512)
// cmd ... data // cmd ... data
// n ... length of data // n ... length of data
static void CodeIso15693AsReader(uint8_t *cmd, int n) void CodeIso15693AsReader(uint8_t *cmd, int n) {
{
int i, j;
ToSendReset(); ToSendReset();
// Give it a bit of slack at the beginning
for(i = 0; i < 24; i++) {
ToSendStuffBit(1);
}
// SOF for 1of4 // SOF for 1of4
ToSendStuffBit(0); ToSend[++ToSendMax] = 0x84; //10000100
ToSendStuffBit(1);
ToSendStuffBit(1); // data
ToSendStuffBit(1); for (int i = 0; i < n; i++) {
ToSendStuffBit(1); for (int j = 0; j < 8; j += 2) {
ToSendStuffBit(0); int these = (cmd[i] >> j) & 0x03;
ToSendStuffBit(1);
ToSendStuffBit(1);
for(i = 0; i < n; i++) {
for(j = 0; j < 8; j += 2) {
int these = (cmd[i] >> j) & 3;
switch(these) { switch(these) {
case 0: case 0:
ToSendStuffBit(1); ToSend[++ToSendMax] = 0x40; //01000000
ToSendStuffBit(0);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
break; break;
case 1: case 1:
ToSendStuffBit(1); ToSend[++ToSendMax] = 0x10; //00010000
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(0);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
break; break;
case 2: case 2:
ToSendStuffBit(1); ToSend[++ToSendMax] = 0x04; //00000100
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(0);
ToSendStuffBit(1);
ToSendStuffBit(1);
break; break;
case 3: case 3:
ToSendStuffBit(1); ToSend[++ToSendMax] = 0x01; //00000001
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(0);
break; break;
} }
} }
} }
// EOF
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(0);
ToSendStuffBit(1);
// Fill remainder of last byte with 1 // EOF
for(i = 0; i < 4; i++) { ToSend[++ToSendMax] = 0x20; //0010 + 0000 padding
ToSendStuffBit(1);
}
ToSendMax++; ToSendMax++;
} }
@ -170,46 +141,26 @@ static void CodeIso15693AsReader(uint8_t *cmd, int n)
// is designed for more robust communication over longer distances // is designed for more robust communication over longer distances
static void CodeIso15693AsReader256(uint8_t *cmd, int n) static void CodeIso15693AsReader256(uint8_t *cmd, int n)
{ {
int i, j;
ToSendReset(); ToSendReset();
// Give it a bit of slack at the beginning
for(i = 0; i < 24; i++) {
ToSendStuffBit(1);
}
// SOF for 1of256 // SOF for 1of256
ToSendStuffBit(0); ToSend[++ToSendMax] = 0x81; //10000001
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(0);
for(i = 0; i < n; i++) { // data
for (j = 0; j<=255; j++) { for(int i = 0; i < n; i++) {
if (cmd[i]==j) { for (int j = 0; j <= 255; j++) {
ToSendStuffBit(1); if (cmd[i] == j) {
ToSendStuffBit(0); ToSendStuffBit(0);
ToSendStuffBit(1);
} else { } else {
ToSendStuffBit(1); ToSendStuffBit(0);
ToSendStuffBit(1); ToSendStuffBit(0);
} }
} }
} }
// EOF
ToSendStuffBit(1);
ToSendStuffBit(1);
ToSendStuffBit(0);
ToSendStuffBit(1);
// Fill remainder of last byte with 1 // EOF
for(i = 0; i < 4; i++) { ToSend[++ToSendMax] = 0x20; //0010 + 0000 padding
ToSendStuffBit(1);
}
ToSendMax++; ToSendMax++;
} }
@ -295,27 +246,42 @@ void CodeIso15693AsTag(uint8_t *cmd, size_t len) {
// Transmit the command (to the tag) that was placed in cmd[]. // Transmit the command (to the tag) that was placed in cmd[].
static void TransmitTo15693Tag(const uint8_t *cmd, int len, uint32_t start_time) void TransmitTo15693Tag(const uint8_t *cmd, int len, uint32_t *start_time) {
{
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER | FPGA_HF_READER_MODE_SEND_FULL_MOD);
FpgaSetupSsc(FPGA_MAJOR_MODE_HF_READER);
while (GetCountSspClk() < start_time) ; FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER | FPGA_HF_READER_MODE_SEND_FULL_MOD);
if (*start_time < DELAY_ARM_TO_TAG) {
*start_time = DELAY_ARM_TO_TAG;
}
*start_time = (*start_time - DELAY_ARM_TO_TAG) & 0xfffffff0;
while (GetCountSspClk() > *start_time) { // we may miss the intended time
*start_time += 16; // next possible time
}
while (GetCountSspClk() < *start_time)
/* wait */ ;
LED_B_ON(); LED_B_ON();
for(int c = 0; c < len; c++) { for (int c = 0; c < len; c++) {
uint8_t data = cmd[c]; uint8_t data = cmd[c];
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
uint16_t send_word = (data & 0x80) ? 0x0000 : 0xffff; uint16_t send_word = (data & 0x80) ? 0xffff : 0x0000;
while (!(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY))) ; while (!(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY))) ;
AT91C_BASE_SSC->SSC_THR = send_word; AT91C_BASE_SSC->SSC_THR = send_word;
while (!(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY))) ; while (!(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY))) ;
AT91C_BASE_SSC->SSC_THR = send_word; AT91C_BASE_SSC->SSC_THR = send_word;
data <<= 1; data <<= 1;
} }
WDT_HIT(); WDT_HIT();
} }
LED_B_OFF(); LED_B_OFF();
*start_time = *start_time + DELAY_ARM_TO_TAG;
} }
@ -326,8 +292,8 @@ void TransmitTo15693Reader(const uint8_t *cmd, size_t len, uint32_t *start_time,
// don't use the FPGA_HF_SIMULATOR_MODULATE_424K_8BIT minor mode. It would spoil GetCountSspClk() // don't use the FPGA_HF_SIMULATOR_MODULATE_424K_8BIT minor mode. It would spoil GetCountSspClk()
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_SIMULATOR | FPGA_HF_SIMULATOR_MODULATE_424K); FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_SIMULATOR | FPGA_HF_SIMULATOR_MODULATE_424K);
uint32_t modulation_start_time = *start_time + 3 * 8; // no need to transfer the unmodulated start of SOF uint32_t modulation_start_time = *start_time - DELAY_ARM_TO_READER + 3 * 8; // no need to transfer the unmodulated start of SOF
while (GetCountSspClk() > (modulation_start_time & 0xfffffff8) + 3) { // we will miss the intended time while (GetCountSspClk() > (modulation_start_time & 0xfffffff8) + 3) { // we will miss the intended time
if (slot_time) { if (slot_time) {
modulation_start_time += slot_time; // use next available slot modulation_start_time += slot_time; // use next available slot
@ -336,12 +302,12 @@ void TransmitTo15693Reader(const uint8_t *cmd, size_t len, uint32_t *start_time,
} }
} }
while (GetCountSspClk() < (modulation_start_time & 0xfffffff8)) while (GetCountSspClk() < (modulation_start_time & 0xfffffff8))
/* wait */ ; /* wait */ ;
uint8_t shift_delay = modulation_start_time & 0x00000007; uint8_t shift_delay = modulation_start_time & 0x00000007;
*start_time = modulation_start_time - 3 * 8; *start_time = modulation_start_time + DELAY_ARM_TO_READER - 3 * 8;
LED_C_ON(); LED_C_ON();
uint8_t bits_to_shift = 0x00; uint8_t bits_to_shift = 0x00;
@ -386,15 +352,18 @@ void TransmitTo15693Reader(const uint8_t *cmd, size_t len, uint32_t *start_time,
// false if we are still waiting for some more // false if we are still waiting for some more
//============================================================================= //=============================================================================
#define NOISE_THRESHOLD 160 // don't try to correlate noise #define NOISE_THRESHOLD 160 // don't try to correlate noise
#define MAX_PREVIOUS_AMPLITUDE (-1 - NOISE_THRESHOLD)
typedef struct DecodeTag { typedef struct DecodeTag {
enum { enum {
STATE_TAG_SOF_LOW, STATE_TAG_SOF_LOW,
STATE_TAG_SOF_RISING_EDGE,
STATE_TAG_SOF_HIGH, STATE_TAG_SOF_HIGH,
STATE_TAG_SOF_HIGH_END, STATE_TAG_SOF_HIGH_END,
STATE_TAG_RECEIVING_DATA, STATE_TAG_RECEIVING_DATA,
STATE_TAG_EOF STATE_TAG_EOF,
STATE_TAG_EOF_TAIL
} state; } state;
int bitCount; int bitCount;
int posCount; int posCount;
@ -409,6 +378,9 @@ typedef struct DecodeTag {
uint8_t *output; uint8_t *output;
int len; int len;
int sum1, sum2; int sum1, sum2;
int threshold_sof;
int threshold_half;
uint16_t previous_amplitude;
} DecodeTag_t; } DecodeTag_t;
@ -416,40 +388,58 @@ static int inline __attribute__((always_inline)) Handle15693SamplesFromTag(uint1
{ {
switch(DecodeTag->state) { switch(DecodeTag->state) {
case STATE_TAG_SOF_LOW: case STATE_TAG_SOF_LOW:
// waiting for 12 times low (11 times low is accepted as well) // waiting for a rising edge
if (amplitude < NOISE_THRESHOLD) { if (amplitude > NOISE_THRESHOLD + DecodeTag->previous_amplitude) {
DecodeTag->posCount++;
} else {
if (DecodeTag->posCount > 10) { if (DecodeTag->posCount > 10) {
DecodeTag->posCount = 1; DecodeTag->threshold_sof = amplitude - DecodeTag->previous_amplitude;
DecodeTag->sum1 = 0; DecodeTag->threshold_half = 0;
DecodeTag->state = STATE_TAG_SOF_HIGH; DecodeTag->state = STATE_TAG_SOF_RISING_EDGE;
} else { } else {
DecodeTag->posCount = 0; DecodeTag->posCount = 0;
} }
} else {
DecodeTag->posCount++;
DecodeTag->previous_amplitude = amplitude;
} }
break; break;
case STATE_TAG_SOF_RISING_EDGE:
if (amplitude - DecodeTag->previous_amplitude > DecodeTag->threshold_sof) { // edge still rising
if (amplitude - DecodeTag->threshold_sof > DecodeTag->threshold_sof) { // steeper edge, take this as time reference
DecodeTag->posCount = 1;
} else {
DecodeTag->posCount = 2;
}
DecodeTag->threshold_sof = (amplitude - DecodeTag->previous_amplitude) / 2;
} else {
DecodeTag->posCount = 2;
DecodeTag->threshold_sof = DecodeTag->threshold_sof/2;
}
// DecodeTag->posCount = 2;
DecodeTag->state = STATE_TAG_SOF_HIGH;
break;
case STATE_TAG_SOF_HIGH: case STATE_TAG_SOF_HIGH:
// waiting for 10 times high. Take average over the last 8 // waiting for 10 times high. Take average over the last 8
if (amplitude > NOISE_THRESHOLD) { if (amplitude > DecodeTag->threshold_sof) {
DecodeTag->posCount++; DecodeTag->posCount++;
if (DecodeTag->posCount > 2) { if (DecodeTag->posCount > 2) {
DecodeTag->sum1 += amplitude; // keep track of average high value DecodeTag->threshold_half += amplitude; // keep track of average high value
} }
if (DecodeTag->posCount == 10) { if (DecodeTag->posCount == 10) {
DecodeTag->sum1 >>= 4; // calculate half of average high value (8 samples) DecodeTag->threshold_half >>= 2; // (4 times 1/2 average)
DecodeTag->state = STATE_TAG_SOF_HIGH_END; DecodeTag->state = STATE_TAG_SOF_HIGH_END;
} }
} else { // high phase was too short } else { // high phase was too short
DecodeTag->posCount = 1; DecodeTag->posCount = 1;
DecodeTag->previous_amplitude = amplitude;
DecodeTag->state = STATE_TAG_SOF_LOW; DecodeTag->state = STATE_TAG_SOF_LOW;
} }
break; break;
case STATE_TAG_SOF_HIGH_END: case STATE_TAG_SOF_HIGH_END:
// waiting for a falling edge // check for falling edge
if (amplitude < DecodeTag->sum1) { // signal drops below 50% average high: a falling edge if (DecodeTag->posCount == 13 && amplitude < DecodeTag->threshold_sof) {
DecodeTag->lastBit = SOF_PART1; // detected 1st part of SOF (12 samples low and 12 samples high) DecodeTag->lastBit = SOF_PART1; // detected 1st part of SOF (12 samples low and 12 samples high)
DecodeTag->shiftReg = 0; DecodeTag->shiftReg = 0;
DecodeTag->bitCount = 0; DecodeTag->bitCount = 0;
@ -458,11 +448,18 @@ static int inline __attribute__((always_inline)) Handle15693SamplesFromTag(uint1
DecodeTag->sum2 = 0; DecodeTag->sum2 = 0;
DecodeTag->posCount = 2; DecodeTag->posCount = 2;
DecodeTag->state = STATE_TAG_RECEIVING_DATA; DecodeTag->state = STATE_TAG_RECEIVING_DATA;
FpgaDisableTracing(); // DEBUGGING
Dbprintf("amplitude = %d, threshold_sof = %d, threshold_half/4 = %d, previous_amplitude = %d",
amplitude,
DecodeTag->threshold_sof,
DecodeTag->threshold_half/4,
DecodeTag->previous_amplitude); // DEBUGGING
LED_C_ON(); LED_C_ON();
} else { } else {
DecodeTag->posCount++; DecodeTag->posCount++;
if (DecodeTag->posCount > 13) { // high phase too long if (DecodeTag->posCount > 13) { // high phase too long
DecodeTag->posCount = 0; DecodeTag->posCount = 0;
DecodeTag->previous_amplitude = amplitude;
DecodeTag->state = STATE_TAG_SOF_LOW; DecodeTag->state = STATE_TAG_SOF_LOW;
LED_C_OFF(); LED_C_OFF();
} }
@ -480,18 +477,16 @@ static int inline __attribute__((always_inline)) Handle15693SamplesFromTag(uint1
DecodeTag->sum2 += amplitude; DecodeTag->sum2 += amplitude;
} }
if (DecodeTag->posCount == 8) { if (DecodeTag->posCount == 8) {
int32_t corr_1 = DecodeTag->sum2 - DecodeTag->sum1; if (DecodeTag->sum1 > DecodeTag->threshold_half && DecodeTag->sum2 > DecodeTag->threshold_half) { // modulation in both halves
int32_t corr_0 = -corr_1;
int32_t corr_EOF = (DecodeTag->sum1 + DecodeTag->sum2) / 2;
if (corr_EOF > corr_0 && corr_EOF > corr_1) {
if (DecodeTag->lastBit == LOGIC0) { // this was already part of EOF if (DecodeTag->lastBit == LOGIC0) { // this was already part of EOF
DecodeTag->state = STATE_TAG_EOF; DecodeTag->state = STATE_TAG_EOF;
} else { } else {
DecodeTag->posCount = 0; DecodeTag->posCount = 0;
DecodeTag->previous_amplitude = amplitude;
DecodeTag->state = STATE_TAG_SOF_LOW; DecodeTag->state = STATE_TAG_SOF_LOW;
LED_C_OFF(); LED_C_OFF();
} }
} else if (corr_1 > corr_0) { } else if (DecodeTag->sum1 < DecodeTag->threshold_half && DecodeTag->sum2 > DecodeTag->threshold_half) { // modulation in second half
// logic 1 // logic 1
if (DecodeTag->lastBit == SOF_PART1) { // still part of SOF if (DecodeTag->lastBit == SOF_PART1) { // still part of SOF
DecodeTag->lastBit = SOF_PART2; // SOF completed DecodeTag->lastBit = SOF_PART2; // SOF completed
@ -503,20 +498,21 @@ static int inline __attribute__((always_inline)) Handle15693SamplesFromTag(uint1
if (DecodeTag->bitCount == 8) { if (DecodeTag->bitCount == 8) {
DecodeTag->output[DecodeTag->len] = DecodeTag->shiftReg; DecodeTag->output[DecodeTag->len] = DecodeTag->shiftReg;
DecodeTag->len++; DecodeTag->len++;
// if (DecodeTag->shiftReg == 0x12 && DecodeTag->len == 1) FpgaDisableTracing(); // DEBUGGING
if (DecodeTag->len > DecodeTag->max_len) { if (DecodeTag->len > DecodeTag->max_len) {
// buffer overflow, give up // buffer overflow, give up
DecodeTag->posCount = 0;
DecodeTag->state = STATE_TAG_SOF_LOW;
LED_C_OFF(); LED_C_OFF();
return true;
} }
DecodeTag->bitCount = 0; DecodeTag->bitCount = 0;
DecodeTag->shiftReg = 0; DecodeTag->shiftReg = 0;
} }
} }
} else { } else if (DecodeTag->sum1 > DecodeTag->threshold_half && DecodeTag->sum2 < DecodeTag->threshold_half) { // modulation in first half
// logic 0 // logic 0
if (DecodeTag->lastBit == SOF_PART1) { // incomplete SOF if (DecodeTag->lastBit == SOF_PART1) { // incomplete SOF
DecodeTag->posCount = 0; DecodeTag->posCount = 0;
DecodeTag->previous_amplitude = amplitude;
DecodeTag->state = STATE_TAG_SOF_LOW; DecodeTag->state = STATE_TAG_SOF_LOW;
LED_C_OFF(); LED_C_OFF();
} else { } else {
@ -526,9 +522,11 @@ static int inline __attribute__((always_inline)) Handle15693SamplesFromTag(uint1
if (DecodeTag->bitCount == 8) { if (DecodeTag->bitCount == 8) {
DecodeTag->output[DecodeTag->len] = DecodeTag->shiftReg; DecodeTag->output[DecodeTag->len] = DecodeTag->shiftReg;
DecodeTag->len++; DecodeTag->len++;
// if (DecodeTag->shiftReg == 0x12 && DecodeTag->len == 1) FpgaDisableTracing(); // DEBUGGING
if (DecodeTag->len > DecodeTag->max_len) { if (DecodeTag->len > DecodeTag->max_len) {
// buffer overflow, give up // buffer overflow, give up
DecodeTag->posCount = 0; DecodeTag->posCount = 0;
DecodeTag->previous_amplitude = amplitude;
DecodeTag->state = STATE_TAG_SOF_LOW; DecodeTag->state = STATE_TAG_SOF_LOW;
LED_C_OFF(); LED_C_OFF();
} }
@ -536,6 +534,15 @@ static int inline __attribute__((always_inline)) Handle15693SamplesFromTag(uint1
DecodeTag->shiftReg = 0; DecodeTag->shiftReg = 0;
} }
} }
} else { // no modulation
if (DecodeTag->lastBit == SOF_PART2) { // only SOF (this is OK for iClass)
LED_C_OFF();
return true;
} else {
DecodeTag->posCount = 0;
DecodeTag->state = STATE_TAG_SOF_LOW;
LED_C_OFF();
}
} }
DecodeTag->posCount = 0; DecodeTag->posCount = 0;
} }
@ -553,29 +560,50 @@ static int inline __attribute__((always_inline)) Handle15693SamplesFromTag(uint1
DecodeTag->sum2 += amplitude; DecodeTag->sum2 += amplitude;
} }
if (DecodeTag->posCount == 8) { if (DecodeTag->posCount == 8) {
int32_t corr_1 = DecodeTag->sum2 - DecodeTag->sum1; if (DecodeTag->sum1 > DecodeTag->threshold_half && DecodeTag->sum2 < DecodeTag->threshold_half) { // modulation in first half
int32_t corr_0 = -corr_1;
int32_t corr_EOF = (DecodeTag->sum1 + DecodeTag->sum2) / 2;
if (corr_EOF > corr_0 || corr_1 > corr_0) {
DecodeTag->posCount = 0; DecodeTag->posCount = 0;
DecodeTag->state = STATE_TAG_EOF_TAIL;
} else {
DecodeTag->posCount = 0;
DecodeTag->previous_amplitude = amplitude;
DecodeTag->state = STATE_TAG_SOF_LOW; DecodeTag->state = STATE_TAG_SOF_LOW;
LED_C_OFF(); LED_C_OFF();
} else {
LED_C_OFF();
return true;
} }
} }
DecodeTag->posCount++; DecodeTag->posCount++;
break; break;
case STATE_TAG_EOF_TAIL:
if (DecodeTag->posCount == 1) {
DecodeTag->sum1 = 0;
DecodeTag->sum2 = 0;
}
if (DecodeTag->posCount <= 4) {
DecodeTag->sum1 += amplitude;
} else {
DecodeTag->sum2 += amplitude;
}
if (DecodeTag->posCount == 8) {
if (DecodeTag->sum1 < DecodeTag->threshold_half && DecodeTag->sum2 < DecodeTag->threshold_half) { // no modulation in both halves
LED_C_OFF();
return true;
} else {
DecodeTag->posCount = 0;
DecodeTag->previous_amplitude = amplitude;
DecodeTag->state = STATE_TAG_SOF_LOW;
LED_C_OFF();
}
}
DecodeTag->posCount++;
break;
} }
return false; return false;
} }
static void DecodeTagInit(DecodeTag_t *DecodeTag, uint8_t *data, uint16_t max_len) static void DecodeTagInit(DecodeTag_t *DecodeTag, uint8_t *data, uint16_t max_len) {
{ DecodeTag->previous_amplitude = MAX_PREVIOUS_AMPLITUDE;
DecodeTag->posCount = 0; DecodeTag->posCount = 0;
DecodeTag->state = STATE_TAG_SOF_LOW; DecodeTag->state = STATE_TAG_SOF_LOW;
DecodeTag->output = data; DecodeTag->output = data;
@ -583,22 +611,22 @@ static void DecodeTagInit(DecodeTag_t *DecodeTag, uint8_t *data, uint16_t max_le
} }
static void DecodeTagReset(DecodeTag_t *DecodeTag) static void DecodeTagReset(DecodeTag_t *DecodeTag) {
{
DecodeTag->posCount = 0; DecodeTag->posCount = 0;
DecodeTag->state = STATE_TAG_SOF_LOW; DecodeTag->state = STATE_TAG_SOF_LOW;
DecodeTag->previous_amplitude = MAX_PREVIOUS_AMPLITUDE;
} }
/* /*
* Receive and decode the tag response, also log to tracebuffer * Receive and decode the tag response, also log to tracebuffer
*/ */
static int GetIso15693AnswerFromTag(uint8_t* response, uint16_t max_len, int timeout) int GetIso15693AnswerFromTag(uint8_t* response, uint16_t max_len, uint16_t timeout, uint32_t *eof_time) {
{
int samples = 0;
bool gotFrame = false;
uint16_t *dmaBuf = (uint16_t*)BigBuf_malloc(ISO15693_DMA_BUFFER_SIZE*sizeof(uint16_t)); int samples = 0;
int ret = 0;
uint16_t dmaBuf[ISO15693_DMA_BUFFER_SIZE];
// the Decoder data structure // the Decoder data structure
DecodeTag_t DecodeTag = { 0 }; DecodeTag_t DecodeTag = { 0 };
@ -613,6 +641,7 @@ static int GetIso15693AnswerFromTag(uint8_t* response, uint16_t max_len, int tim
// Setup and start DMA. // Setup and start DMA.
FpgaSetupSsc(FPGA_MAJOR_MODE_HF_READER); FpgaSetupSsc(FPGA_MAJOR_MODE_HF_READER);
FpgaSetupSscDma((uint8_t*) dmaBuf, ISO15693_DMA_BUFFER_SIZE); FpgaSetupSscDma((uint8_t*) dmaBuf, ISO15693_DMA_BUFFER_SIZE);
uint32_t dma_start_time = 0;
uint16_t *upTo = dmaBuf; uint16_t *upTo = dmaBuf;
for(;;) { for(;;) {
@ -620,12 +649,19 @@ static int GetIso15693AnswerFromTag(uint8_t* response, uint16_t max_len, int tim
if (behindBy == 0) continue; if (behindBy == 0) continue;
samples++;
if (samples == 1) {
// DMA has transferred the very first data
dma_start_time = GetCountSspClk() & 0xfffffff0;
}
uint16_t tagdata = *upTo++; uint16_t tagdata = *upTo++;
if(upTo >= dmaBuf + ISO15693_DMA_BUFFER_SIZE) { // we have read all of the DMA buffer content. if(upTo >= dmaBuf + ISO15693_DMA_BUFFER_SIZE) { // we have read all of the DMA buffer content.
upTo = dmaBuf; // start reading the circular buffer from the beginning upTo = dmaBuf; // start reading the circular buffer from the beginning
if(behindBy > (9*ISO15693_DMA_BUFFER_SIZE/10)) { if(behindBy > (9*ISO15693_DMA_BUFFER_SIZE/10)) {
Dbprintf("About to blow circular buffer - aborted! behindBy=%d", behindBy); Dbprintf("About to blow circular buffer - aborted! behindBy=%d", behindBy);
ret = -1;
break; break;
} }
} }
@ -634,30 +670,42 @@ static int GetIso15693AnswerFromTag(uint8_t* response, uint16_t max_len, int tim
AT91C_BASE_PDC_SSC->PDC_RNCR = ISO15693_DMA_BUFFER_SIZE; // DMA Next Counter registers AT91C_BASE_PDC_SSC->PDC_RNCR = ISO15693_DMA_BUFFER_SIZE; // DMA Next Counter registers
} }
samples++;
if (Handle15693SamplesFromTag(tagdata, &DecodeTag)) { if (Handle15693SamplesFromTag(tagdata, &DecodeTag)) {
gotFrame = true; *eof_time = dma_start_time + samples*16 - DELAY_TAG_TO_ARM; // end of EOF
if (DecodeTag.lastBit == SOF_PART2) {
*eof_time -= 8*16; // needed 8 additional samples to confirm single SOF (iCLASS)
}
if (DecodeTag.len > DecodeTag.max_len) {
ret = -2; // buffer overflow
}
break; break;
} }
if (samples > timeout && DecodeTag.state < STATE_TAG_RECEIVING_DATA) { if (samples > timeout && DecodeTag.state < STATE_TAG_RECEIVING_DATA) {
DecodeTag.len = 0; ret = -1; // timeout
break; break;
} }
} }
FpgaDisableSscDma(); FpgaDisableSscDma();
BigBuf_free();
if (DEBUG) Dbprintf("samples = %d, gotFrame = %d, Decoder: state = %d, len = %d, bitCount = %d, posCount = %d", if (DEBUG) Dbprintf("samples = %d, ret = %d, Decoder: state = %d, lastBit = %d, len = %d, bitCount = %d, posCount = %d",
samples, gotFrame, DecodeTag.state, DecodeTag.len, DecodeTag.bitCount, DecodeTag.posCount); samples, ret, DecodeTag.state, DecodeTag.lastBit, DecodeTag.len, DecodeTag.bitCount, DecodeTag.posCount);
if (DecodeTag.len > 0) { if (ret < 0) {
LogTrace(DecodeTag.output, DecodeTag.len, 0, 0, NULL, false); return ret;
} }
uint32_t sof_time = *eof_time
- DecodeTag.len * 8 * 8 * 16 // time for byte transfers
- 32 * 16 // time for SOF transfer
- (DecodeTag.lastBit != SOF_PART2?32*16:0); // time for EOF transfer
if (DEBUG) Dbprintf("timing: sof_time = %d, eof_time = %d", sof_time, *eof_time);
LogTrace_ISO15693(DecodeTag.output, DecodeTag.len, sof_time*4, *eof_time*4, NULL, false);
return DecodeTag.len; return DecodeTag.len;
} }
@ -977,7 +1025,7 @@ int GetIso15693CommandFromReader(uint8_t *received, size_t max_len, uint32_t *eo
for (int i = 7; i >= 0; i--) { for (int i = 7; i >= 0; i--) {
if (Handle15693SampleFromReader((b >> i) & 0x01, &DecodeReader)) { if (Handle15693SampleFromReader((b >> i) & 0x01, &DecodeReader)) {
*eof_time = dma_start_time + samples - DELAY_READER_TO_ARM_SIM; // end of EOF *eof_time = dma_start_time + samples - DELAY_READER_TO_ARM; // end of EOF
gotFrame = true; gotFrame = true;
break; break;
} }
@ -1006,7 +1054,7 @@ int GetIso15693CommandFromReader(uint8_t *received, size_t max_len, uint32_t *eo
- DecodeReader.byteCount * (DecodeReader.Coding==CODING_1_OUT_OF_4?128:2048) // time for byte transfers - DecodeReader.byteCount * (DecodeReader.Coding==CODING_1_OUT_OF_4?128:2048) // time for byte transfers
- 32 // time for SOF transfer - 32 // time for SOF transfer
- 16; // time for EOF transfer - 16; // time for EOF transfer
LogTrace(DecodeReader.output, DecodeReader.byteCount, sof_time, *eof_time, NULL, true); LogTrace_ISO15693(DecodeReader.output, DecodeReader.byteCount, sof_time*32, *eof_time*32, NULL, true);
} }
return DecodeReader.byteCount; return DecodeReader.byteCount;
@ -1043,24 +1091,24 @@ static void BuildIdentifyRequest(void)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void AcquireRawAdcSamplesIso15693(void) void AcquireRawAdcSamplesIso15693(void)
{ {
LEDsoff();
LED_A_ON(); LED_A_ON();
uint8_t *dest = BigBuf_get_addr(); uint8_t *dest = BigBuf_get_addr();
FpgaDownloadAndGo(FPGA_BITSTREAM_HF); FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER); FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER);
LED_D_ON();
FpgaSetupSsc(FPGA_MAJOR_MODE_HF_READER); FpgaSetupSsc(FPGA_MAJOR_MODE_HF_READER);
SetAdcMuxFor(GPIO_MUXSEL_HIPKD); SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
BuildIdentifyRequest(); BuildIdentifyRequest();
// Give the tags time to energize // Give the tags time to energize
LED_D_ON();
SpinDelay(100); SpinDelay(100);
// Now send the command // Now send the command
TransmitTo15693Tag(ToSend, ToSendMax, 0); uint32_t start_time = 0;
TransmitTo15693Tag(ToSend, ToSendMax, &start_time);
// wait for last transfer to complete // wait for last transfer to complete
while (!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXEMPTY)) ; while (!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXEMPTY)) ;
@ -1082,6 +1130,7 @@ void AcquireRawAdcSamplesIso15693(void)
void SnoopIso15693(void) void SnoopIso15693(void)
{ {
LED_A_ON(); LED_A_ON();
FpgaDownloadAndGo(FPGA_BITSTREAM_HF); FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
BigBuf_free(); BigBuf_free();
@ -1156,7 +1205,7 @@ void SnoopIso15693(void)
if (Handle15693SampleFromReader(snoopdata & 0x02, &DecodeReader)) { if (Handle15693SampleFromReader(snoopdata & 0x02, &DecodeReader)) {
FpgaDisableSscDma(); FpgaDisableSscDma();
ExpectTagAnswer = true; ExpectTagAnswer = true;
LogTrace(DecodeReader.output, DecodeReader.byteCount, samples, samples, NULL, true); LogTrace_ISO15693(DecodeReader.output, DecodeReader.byteCount, samples*64, samples*64, NULL, true);
/* And ready to receive another command. */ /* And ready to receive another command. */
DecodeReaderReset(&DecodeReader); DecodeReaderReset(&DecodeReader);
/* And also reset the demod code, which might have been */ /* And also reset the demod code, which might have been */
@ -1168,7 +1217,7 @@ void SnoopIso15693(void)
if (Handle15693SampleFromReader(snoopdata & 0x01, &DecodeReader)) { if (Handle15693SampleFromReader(snoopdata & 0x01, &DecodeReader)) {
FpgaDisableSscDma(); FpgaDisableSscDma();
ExpectTagAnswer = true; ExpectTagAnswer = true;
LogTrace(DecodeReader.output, DecodeReader.byteCount, samples, samples, NULL, true); LogTrace_ISO15693(DecodeReader.output, DecodeReader.byteCount, samples*64, samples*64, NULL, true);
/* And ready to receive another command. */ /* And ready to receive another command. */
DecodeReaderReset(&DecodeReader); DecodeReaderReset(&DecodeReader);
/* And also reset the demod code, which might have been */ /* And also reset the demod code, which might have been */
@ -1184,7 +1233,7 @@ void SnoopIso15693(void)
if (Handle15693SamplesFromTag(snoopdata >> 2, &DecodeTag)) { if (Handle15693SamplesFromTag(snoopdata >> 2, &DecodeTag)) {
FpgaDisableSscDma(); FpgaDisableSscDma();
//Use samples as a time measurement //Use samples as a time measurement
LogTrace(DecodeTag.output, DecodeTag.len, samples, samples, NULL, false); LogTrace_ISO15693(DecodeTag.output, DecodeTag.len, samples*64, samples*64, NULL, false);
// And ready to receive another response. // And ready to receive another response.
DecodeTagReset(&DecodeTag); DecodeTagReset(&DecodeTag);
DecodeReaderReset(&DecodeReader); DecodeReaderReset(&DecodeReader);
@ -1213,10 +1262,8 @@ void SnoopIso15693(void)
// Initialize the proxmark as iso15k reader // Initialize the proxmark as iso15k reader
static void Iso15693InitReader() { void Iso15693InitReader() {
FpgaDownloadAndGo(FPGA_BITSTREAM_HF); FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
// Setup SSC
// FpgaSetupSsc();
// Start from off (no field generated) // Start from off (no field generated)
LED_D_OFF(); LED_D_OFF();
@ -1300,16 +1347,15 @@ static void BuildInventoryResponse(uint8_t *uid)
// init ... should we initialize the reader? // init ... should we initialize the reader?
// speed ... 0 low speed, 1 hi speed // speed ... 0 low speed, 1 hi speed
// *recv will contain the tag's answer // *recv will contain the tag's answer
// return: lenght of received data // return: length of received data, or -1 for timeout
int SendDataTag(uint8_t *send, int sendlen, bool init, int speed, uint8_t *recv, uint16_t max_recv_len, uint32_t start_time) { int SendDataTag(uint8_t *send, int sendlen, bool init, int speed, uint8_t *recv, uint16_t max_recv_len, uint32_t start_time, uint32_t *eof_time) {
LED_A_ON(); if (init) {
LED_B_OFF(); Iso15693InitReader();
LED_C_OFF(); StartCountSspClk();
}
if (init) Iso15693InitReader(); int answerLen = 0;
int answerLen=0;
if (!speed) { if (!speed) {
// low speed (1 out of 256) // low speed (1 out of 256)
@ -1319,15 +1365,13 @@ int SendDataTag(uint8_t *send, int sendlen, bool init, int speed, uint8_t *recv,
CodeIso15693AsReader(send, sendlen); CodeIso15693AsReader(send, sendlen);
} }
TransmitTo15693Tag(ToSend, ToSendMax, start_time); TransmitTo15693Tag(ToSend, ToSendMax, &start_time);
// Now wait for a response // Now wait for a response
if (recv != NULL) { if (recv != NULL) {
answerLen = GetIso15693AnswerFromTag(recv, max_recv_len, DELAY_ISO15693_VCD_TO_VICC_READER * 2); answerLen = GetIso15693AnswerFromTag(recv, max_recv_len, ISO15693_READER_TIMEOUT, eof_time);
} }
LED_A_OFF();
return answerLen; return answerLen;
} }
@ -1411,9 +1455,8 @@ void SetDebugIso15693(uint32_t debug) {
// Simulate an ISO15693 reader, perform anti-collision and then attempt to read a sector. // Simulate an ISO15693 reader, perform anti-collision and then attempt to read a sector.
// all demodulation performed in arm rather than host. - greg // all demodulation performed in arm rather than host. - greg
//--------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------
void ReaderIso15693(uint32_t parameter) void ReaderIso15693(uint32_t parameter) {
{
LEDsoff();
LED_A_ON(); LED_A_ON();
set_tracing(true); set_tracing(true);
@ -1445,11 +1488,13 @@ void ReaderIso15693(uint32_t parameter)
// Now send the IDENTIFY command // Now send the IDENTIFY command
BuildIdentifyRequest(); BuildIdentifyRequest();
TransmitTo15693Tag(ToSend, ToSendMax, 0); uint32_t start_time = 0;
TransmitTo15693Tag(ToSend, ToSendMax, &start_time);
// Now wait for a response // Now wait for a response
answerLen = GetIso15693AnswerFromTag(answer, sizeof(answer), DELAY_ISO15693_VCD_TO_VICC_READER * 2) ; uint32_t eof_time;
uint32_t start_time = GetCountSspClk() + DELAY_ISO15693_VICC_TO_VCD_READER; answerLen = GetIso15693AnswerFromTag(answer, sizeof(answer), DELAY_ISO15693_VCD_TO_VICC_READER * 2, &eof_time) ;
start_time = eof_time + DELAY_ISO15693_VICC_TO_VCD_READER;
if (answerLen >=12) // we should do a better check than this if (answerLen >=12) // we should do a better check than this
{ {
@ -1487,9 +1532,9 @@ void ReaderIso15693(uint32_t parameter)
if (answerLen >= 12 && DEBUG) { if (answerLen >= 12 && DEBUG) {
for (int i = 0; i < 32; i++) { // sanity check, assume max 32 pages for (int i = 0; i < 32; i++) { // sanity check, assume max 32 pages
BuildReadBlockRequest(TagUID, i); BuildReadBlockRequest(TagUID, i);
TransmitTo15693Tag(ToSend, ToSendMax, start_time); TransmitTo15693Tag(ToSend, ToSendMax, &start_time);
int answerLen = GetIso15693AnswerFromTag(answer, sizeof(answer), DELAY_ISO15693_VCD_TO_VICC_READER * 2); int answerLen = GetIso15693AnswerFromTag(answer, sizeof(answer), DELAY_ISO15693_VCD_TO_VICC_READER * 2, &eof_time);
start_time = GetCountSspClk() + DELAY_ISO15693_VICC_TO_VCD_READER; start_time = eof_time + DELAY_ISO15693_VICC_TO_VCD_READER;
if (answerLen > 0) { if (answerLen > 0) {
Dbprintf("READ SINGLE BLOCK %d returned %d octets:", i, answerLen); Dbprintf("READ SINGLE BLOCK %d returned %d octets:", i, answerLen);
DbdecodeIso15693Answer(answerLen, answer); DbdecodeIso15693Answer(answerLen, answer);
@ -1511,9 +1556,8 @@ void ReaderIso15693(uint32_t parameter)
// Simulate an ISO15693 TAG. // Simulate an ISO15693 TAG.
// For Inventory command: print command and send Inventory Response with given UID // For Inventory command: print command and send Inventory Response with given UID
// TODO: interpret other reader commands and send appropriate response // TODO: interpret other reader commands and send appropriate response
void SimTagIso15693(uint32_t parameter, uint8_t *uid) void SimTagIso15693(uint32_t parameter, uint8_t *uid) {
{
LEDsoff();
LED_A_ON(); LED_A_ON();
FpgaDownloadAndGo(FPGA_BITSTREAM_HF); FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
@ -1535,7 +1579,7 @@ void SimTagIso15693(uint32_t parameter, uint8_t *uid)
if ((cmd_len >= 5) && (cmd[0] & ISO15693_REQ_INVENTORY) && (cmd[1] == ISO15693_INVENTORY)) { // TODO: check more flags if ((cmd_len >= 5) && (cmd[0] & ISO15693_REQ_INVENTORY) && (cmd[1] == ISO15693_INVENTORY)) { // TODO: check more flags
bool slow = !(cmd[0] & ISO15693_REQ_DATARATE_HIGH); bool slow = !(cmd[0] & ISO15693_REQ_DATARATE_HIGH);
start_time = eof_time + DELAY_ISO15693_VCD_TO_VICC_SIM - DELAY_ARM_TO_READER_SIM; start_time = eof_time + DELAY_ISO15693_VCD_TO_VICC_SIM;
TransmitTo15693Reader(ToSend, ToSendMax, &start_time, 0, slow); TransmitTo15693Reader(ToSend, ToSendMax, &start_time, 0, slow);
} }
@ -1544,7 +1588,8 @@ void SimTagIso15693(uint32_t parameter, uint8_t *uid)
} }
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LEDsoff(); LED_D_OFF();
LED_A_OFF();
} }
@ -1552,16 +1597,12 @@ void SimTagIso15693(uint32_t parameter, uint8_t *uid)
// (some manufactures offer a way to read the AFI, though) // (some manufactures offer a way to read the AFI, though)
void BruteforceIso15693Afi(uint32_t speed) void BruteforceIso15693Afi(uint32_t speed)
{ {
LEDsoff();
LED_A_ON(); LED_A_ON();
uint8_t data[6]; uint8_t data[6];
uint8_t recv[ISO15693_MAX_RESPONSE_LENGTH]; uint8_t recv[ISO15693_MAX_RESPONSE_LENGTH];
int datalen = 0, recvlen = 0;
int datalen=0, recvlen=0; uint32_t eof_time;
Iso15693InitReader();
StartCountSspClk();
// first without AFI // first without AFI
// Tags should respond without AFI and with AFI=0 even when AFI is active // Tags should respond without AFI and with AFI=0 even when AFI is active
@ -1570,8 +1611,9 @@ void BruteforceIso15693Afi(uint32_t speed)
data[1] = ISO15693_INVENTORY; data[1] = ISO15693_INVENTORY;
data[2] = 0; // mask length data[2] = 0; // mask length
datalen = Iso15693AddCrc(data,3); datalen = Iso15693AddCrc(data,3);
recvlen = SendDataTag(data, datalen, false, speed, recv, sizeof(recv), 0); uint32_t start_time = GetCountSspClk();
uint32_t start_time = GetCountSspClk() + DELAY_ISO15693_VICC_TO_VCD_READER; recvlen = SendDataTag(data, datalen, true, speed, recv, sizeof(recv), 0, &eof_time);
start_time = eof_time + DELAY_ISO15693_VICC_TO_VCD_READER;
WDT_HIT(); WDT_HIT();
if (recvlen>=12) { if (recvlen>=12) {
Dbprintf("NoAFI UID=%s", Iso15693sprintUID(NULL, &recv[2])); Dbprintf("NoAFI UID=%s", Iso15693sprintUID(NULL, &recv[2]));
@ -1587,8 +1629,8 @@ void BruteforceIso15693Afi(uint32_t speed)
for (int i = 0; i < 256; i++) { for (int i = 0; i < 256; i++) {
data[2] = i & 0xFF; data[2] = i & 0xFF;
datalen = Iso15693AddCrc(data,4); datalen = Iso15693AddCrc(data,4);
recvlen = SendDataTag(data, datalen, false, speed, recv, sizeof(recv), start_time); recvlen = SendDataTag(data, datalen, false, speed, recv, sizeof(recv), start_time, &eof_time);
start_time = GetCountSspClk() + DELAY_ISO15693_VICC_TO_VCD_READER; start_time = eof_time + DELAY_ISO15693_VICC_TO_VCD_READER;
WDT_HIT(); WDT_HIT();
if (recvlen >= 12) { if (recvlen >= 12) {
Dbprintf("AFI=%i UID=%s", i, Iso15693sprintUID(NULL, &recv[2])); Dbprintf("AFI=%i UID=%s", i, Iso15693sprintUID(NULL, &recv[2]));
@ -1597,40 +1639,46 @@ void BruteforceIso15693Afi(uint32_t speed)
Dbprintf("AFI Bruteforcing done."); Dbprintf("AFI Bruteforcing done.");
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LEDsoff(); LED_D_OFF();
LED_A_OFF();
} }
// Allows to directly send commands to the tag via the client // Allows to directly send commands to the tag via the client
void DirectTag15693Command(uint32_t datalen, uint32_t speed, uint32_t recv, uint8_t data[]) { void DirectTag15693Command(uint32_t datalen, uint32_t speed, uint32_t recv, uint8_t data[]) {
LED_A_ON();
int recvlen = 0; int recvlen = 0;
uint8_t recvbuf[ISO15693_MAX_RESPONSE_LENGTH]; uint8_t recvbuf[ISO15693_MAX_RESPONSE_LENGTH];
uint32_t eof_time;
LED_A_ON();
if (DEBUG) { if (DEBUG) {
Dbprintf("SEND:"); Dbprintf("SEND:");
Dbhexdump(datalen, data, false); Dbhexdump(datalen, data, false);
} }
recvlen = SendDataTag(data, datalen, true, speed, (recv?recvbuf:NULL), sizeof(recvbuf), 0); recvlen = SendDataTag(data, datalen, true, speed, (recv?recvbuf:NULL), sizeof(recvbuf), 0, &eof_time);
if (recv) {
if (DEBUG) {
Dbprintf("RECV:");
Dbhexdump(recvlen, recvbuf, false);
DbdecodeIso15693Answer(recvlen, recvbuf);
}
cmd_send(CMD_ACK, recvlen>ISO15693_MAX_RESPONSE_LENGTH?ISO15693_MAX_RESPONSE_LENGTH:recvlen, 0, 0, recvbuf, ISO15693_MAX_RESPONSE_LENGTH);
}
// for the time being, switch field off to protect rdv4.0 // for the time being, switch field off to protect rdv4.0
// note: this prevents using hf 15 cmd with s option - which isn't implemented yet anyway // note: this prevents using hf 15 cmd with s option - which isn't implemented yet anyway
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LED_D_OFF(); LED_D_OFF();
if (recv) {
if (DEBUG) {
Dbprintf("RECV:");
if (recvlen > 0) {
Dbhexdump(recvlen, recvbuf, false);
DbdecodeIso15693Answer(recvlen, recvbuf);
}
}
if (recvlen > ISO15693_MAX_RESPONSE_LENGTH) {
recvlen = ISO15693_MAX_RESPONSE_LENGTH;
}
cmd_send(CMD_ACK, recvlen, 0, 0, recvbuf, ISO15693_MAX_RESPONSE_LENGTH);
}
LED_A_OFF(); LED_A_OFF();
} }
@ -1640,16 +1688,16 @@ void DirectTag15693Command(uint32_t datalen, uint32_t speed, uint32_t recv, uint
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Set the UID to the tag (based on Iceman work). // Set the UID to the tag (based on Iceman work).
void SetTag15693Uid(uint8_t *uid) void SetTag15693Uid(uint8_t *uid) {
{
uint8_t cmd[4][9] = {0x00};
LED_A_ON();
uint8_t cmd[4][9] = {0x00};
uint16_t crc; uint16_t crc;
int recvlen = 0; int recvlen = 0;
uint8_t recvbuf[ISO15693_MAX_RESPONSE_LENGTH]; uint8_t recvbuf[ISO15693_MAX_RESPONSE_LENGTH];
uint32_t eof_time;
LED_A_ON();
// Command 1 : 02213E00000000 // Command 1 : 02213E00000000
cmd[0][0] = 0x02; cmd[0][0] = 0x02;
@ -1687,7 +1735,7 @@ void SetTag15693Uid(uint8_t *uid)
cmd[3][5] = uid[1]; cmd[3][5] = uid[1];
cmd[3][6] = uid[0]; cmd[3][6] = uid[0];
for (int i=0; i<4; i++) { for (int i = 0; i < 4; i++) {
// Add the CRC // Add the CRC
crc = Iso15693Crc(cmd[i], 7); crc = Iso15693Crc(cmd[i], 7);
cmd[i][7] = crc & 0xff; cmd[i][7] = crc & 0xff;
@ -1698,19 +1746,19 @@ void SetTag15693Uid(uint8_t *uid)
Dbhexdump(sizeof(cmd[i]), cmd[i], false); Dbhexdump(sizeof(cmd[i]), cmd[i], false);
} }
recvlen = SendDataTag(cmd[i], sizeof(cmd[i]), true, 1, recvbuf, sizeof(recvbuf), 0); recvlen = SendDataTag(cmd[i], sizeof(cmd[i]), true, 1, recvbuf, sizeof(recvbuf), 0, &eof_time);
if (DEBUG) { if (DEBUG) {
Dbprintf("RECV:"); Dbprintf("RECV:");
Dbhexdump(recvlen, recvbuf, false); if (recvlen > 0) {
DbdecodeIso15693Answer(recvlen, recvbuf); Dbhexdump(recvlen, recvbuf, false);
DbdecodeIso15693Answer(recvlen, recvbuf);
}
} }
cmd_send(CMD_ACK, recvlen>ISO15693_MAX_RESPONSE_LENGTH?ISO15693_MAX_RESPONSE_LENGTH:recvlen, 0, 0, recvbuf, ISO15693_MAX_RESPONSE_LENGTH); cmd_send(CMD_ACK, recvlen>ISO15693_MAX_RESPONSE_LENGTH?ISO15693_MAX_RESPONSE_LENGTH:recvlen, 0, 0, recvbuf, ISO15693_MAX_RESPONSE_LENGTH);
} }
LED_D_OFF();
LED_A_OFF(); LED_A_OFF();
} }

17
armsrc/iso15693.h
View file

@ -17,16 +17,20 @@
// Delays in SSP_CLK ticks. // Delays in SSP_CLK ticks.
// SSP_CLK runs at 13,56MHz / 32 = 423.75kHz when simulating a tag // SSP_CLK runs at 13,56MHz / 32 = 423.75kHz when simulating a tag
#define DELAY_READER_TO_ARM_SIM 8 #define DELAY_ISO15693_VCD_TO_VICC_SIM 132 // 132/423.75kHz = 311.5us from end of command EOF to start of tag response
#define DELAY_ARM_TO_READER_SIM 0 //SSP_CLK runs at 13.56MHz / 4 = 3,39MHz when acting as reader. All values should be multiples of 16
#define DELAY_ISO15693_VCD_TO_VICC_SIM 132 // 132/423.75kHz = 311.5us from end of command EOF to start of tag response
//SSP_CLK runs at 13.56MHz / 4 = 3,39MHz when acting as reader
#define DELAY_ISO15693_VCD_TO_VICC_READER 1056 // 1056/3,39MHz = 311.5us from end of command EOF to start of tag response #define DELAY_ISO15693_VCD_TO_VICC_READER 1056 // 1056/3,39MHz = 311.5us from end of command EOF to start of tag response
#define DELAY_ISO15693_VICC_TO_VCD_READER 1017 // 1017/3.39MHz = 300us between end of tag response and next reader command #define DELAY_ISO15693_VICC_TO_VCD_READER 1024 // 1024/3.39MHz = 302.1us between end of tag response and next reader command
// times in samples @ 212kHz when acting as reader
#define ISO15693_READER_TIMEOUT 330 // 330/212kHz = 1558us, should be even enough for iClass tags responding to ACTALL
void Iso15693InitReader();
void CodeIso15693AsReader(uint8_t *cmd, int n);
void CodeIso15693AsTag(uint8_t *cmd, size_t len); void CodeIso15693AsTag(uint8_t *cmd, size_t len);
int GetIso15693CommandFromReader(uint8_t *received, size_t max_len, uint32_t *eof_time);
void TransmitTo15693Reader(const uint8_t *cmd, size_t len, uint32_t *start_time, uint32_t slot_time, bool slow); void TransmitTo15693Reader(const uint8_t *cmd, size_t len, uint32_t *start_time, uint32_t slot_time, bool slow);
int GetIso15693CommandFromReader(uint8_t *received, size_t max_len, uint32_t *eof_time);
void TransmitTo15693Tag(const uint8_t *cmd, int len, uint32_t *start_time);
int GetIso15693AnswerFromTag(uint8_t* response, uint16_t max_len, uint16_t timeout, uint32_t *eof_time);
void SnoopIso15693(void); void SnoopIso15693(void);
void AcquireRawAdcSamplesIso15693(void); void AcquireRawAdcSamplesIso15693(void);
void ReaderIso15693(uint32_t parameter); void ReaderIso15693(uint32_t parameter);
@ -35,5 +39,6 @@ void BruteforceIso15693Afi(uint32_t speed);
void DirectTag15693Command(uint32_t datalen, uint32_t speed, uint32_t recv, uint8_t data[]); void DirectTag15693Command(uint32_t datalen, uint32_t speed, uint32_t recv, uint8_t data[]);
void SetTag15693Uid(uint8_t *uid); void SetTag15693Uid(uint8_t *uid);
void SetDebugIso15693(uint32_t flag); void SetDebugIso15693(uint32_t flag);
bool LogTrace_ISO15693(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_start, uint32_t timestamp_end, uint8_t *parity, bool readerToTag);
#endif #endif

153
armsrc/util.c
View file

@ -21,7 +21,7 @@ void print_result(char *name, uint8_t *buf, size_t len) {
if ( len % 16 == 0 ) { if ( len % 16 == 0 ) {
for(; p-buf < len; p += 16) for(; p-buf < len; p += 16)
Dbprintf("[%s:%d/%d] %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", Dbprintf("[%s:%d/%d] %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
name, name,
p-buf, p-buf,
len, len,
@ -30,7 +30,7 @@ void print_result(char *name, uint8_t *buf, size_t len) {
} }
else { else {
for(; p-buf < len; p += 8) for(; p-buf < len; p += 8)
Dbprintf("[%s:%d/%d] %02x %02x %02x %02x %02x %02x %02x %02x", name, p-buf, len, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); Dbprintf("[%s:%d/%d] %02x %02x %02x %02x %02x %02x %02x %02x", name, p-buf, len, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
} }
} }
@ -68,17 +68,17 @@ uint64_t bytes_to_num(uint8_t* src, size_t len)
// RotateLeft - Ultralight, Desfire // RotateLeft - Ultralight, Desfire
void rol(uint8_t *data, const size_t len){ void rol(uint8_t *data, const size_t len){
uint8_t first = data[0]; uint8_t first = data[0];
for (size_t i = 0; i < len-1; i++) { for (size_t i = 0; i < len-1; i++) {
data[i] = data[i+1]; data[i] = data[i+1];
} }
data[len-1] = first; data[len-1] = first;
} }
void lsl (uint8_t *data, size_t len) { void lsl (uint8_t *data, size_t len) {
for (size_t n = 0; n < len - 1; n++) { for (size_t n = 0; n < len - 1; n++) {
data[n] = (data[n] << 1) | (data[n+1] >> 7); data[n] = (data[n] << 1) | (data[n+1] >> 7);
} }
data[len - 1] <<= 1; data[len - 1] <<= 1;
} }
void LEDsoff() void LEDsoff()
@ -309,16 +309,16 @@ void FormatVersionInformation(char *dst, int len, const char *prefix, void *vers
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// test procedure: // test procedure:
// //
// ti = GetTickCount(); // ti = GetTickCount();
// SpinDelay(1000); // SpinDelay(1000);
// ti = GetTickCount() - ti; // ti = GetTickCount() - ti;
// Dbprintf("timer(1s): %d t=%d", ti, GetTickCount()); // Dbprintf("timer(1s): %d t=%d", ti, GetTickCount());
void StartTickCount() void StartTickCount()
{ {
// This timer is based on the slow clock. The slow clock frequency is between 22kHz and 40kHz. // This timer is based on the slow clock. The slow clock frequency is between 22kHz and 40kHz.
// We can determine the actual slow clock frequency by looking at the Main Clock Frequency Register. // We can determine the actual slow clock frequency by looking at the Main Clock Frequency Register.
uint16_t mainf = AT91C_BASE_PMC->PMC_MCFR & 0xffff; // = 16 * main clock frequency (16MHz) / slow clock frequency uint16_t mainf = AT91C_BASE_PMC->PMC_MCFR & 0xffff; // = 16 * main clock frequency (16MHz) / slow clock frequency
// set RealTimeCounter divider to count at 1kHz: // set RealTimeCounter divider to count at 1kHz:
AT91C_BASE_RTTC->RTTC_RTMR = AT91C_RTTC_RTTRST | ((256000 + (mainf/2)) / mainf); AT91C_BASE_RTTC->RTTC_RTMR = AT91C_RTTC_RTTRST | ((256000 + (mainf/2)) / mainf);
// note: worst case precision is approx 2.5% // note: worst case precision is approx 2.5%
@ -334,12 +334,12 @@ uint32_t RAMFUNC GetTickCount(){
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// microseconds timer // microseconds timer
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
void StartCountUS() void StartCountUS()
{ {
AT91C_BASE_PMC->PMC_PCER |= (0x1 << 12) | (0x1 << 13) | (0x1 << 14); AT91C_BASE_PMC->PMC_PCER |= (0x1 << 12) | (0x1 << 13) | (0x1 << 14);
// AT91C_BASE_TCB->TCB_BMR = AT91C_TCB_TC1XC1S_TIOA0; // AT91C_BASE_TCB->TCB_BMR = AT91C_TCB_TC1XC1S_TIOA0;
AT91C_BASE_TCB->TCB_BMR = AT91C_TCB_TC0XC0S_NONE | AT91C_TCB_TC1XC1S_TIOA0 | AT91C_TCB_TC2XC2S_NONE; AT91C_BASE_TCB->TCB_BMR = AT91C_TCB_TC0XC0S_NONE | AT91C_TCB_TC1XC1S_TIOA0 | AT91C_TCB_TC2XC2S_NONE;
// fast clock // fast clock
@ -349,10 +349,10 @@ void StartCountUS()
AT91C_TC_ACPC_SET | AT91C_TC_ASWTRG_SET; AT91C_TC_ACPC_SET | AT91C_TC_ASWTRG_SET;
AT91C_BASE_TC0->TC_RA = 1; AT91C_BASE_TC0->TC_RA = 1;
AT91C_BASE_TC0->TC_RC = 0xBFFF + 1; // 0xC000 AT91C_BASE_TC0->TC_RC = 0xBFFF + 1; // 0xC000
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; // timer disable AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; // timer disable
AT91C_BASE_TC1->TC_CMR = AT91C_TC_CLKS_XC1; // from timer 0 AT91C_BASE_TC1->TC_CMR = AT91C_TC_CLKS_XC1; // from timer 0
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN; AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN;
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN; AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN;
AT91C_BASE_TCB->TCB_BCR = 1; AT91C_BASE_TCB->TCB_BCR = 1;
@ -375,61 +375,72 @@ uint32_t RAMFUNC GetDeltaCountUS(){
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// Timer for iso14443 commands. Uses ssp_clk from FPGA // Timer for iso14443 commands. Uses ssp_clk from FPGA
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
void StartCountSspClk() void StartCountSspClk()
{ {
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC0) | (1 << AT91C_ID_TC1) | (1 << AT91C_ID_TC2); // Enable Clock to all timers AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC0) | (1 << AT91C_ID_TC1) | (1 << AT91C_ID_TC2); // Enable Clock to all timers
AT91C_BASE_TCB->TCB_BMR = AT91C_TCB_TC0XC0S_TIOA1 // XC0 Clock = TIOA1 AT91C_BASE_TCB->TCB_BMR = AT91C_TCB_TC0XC0S_TIOA1 // XC0 Clock = TIOA1
| AT91C_TCB_TC1XC1S_NONE // XC1 Clock = none | AT91C_TCB_TC1XC1S_NONE // XC1 Clock = none
| AT91C_TCB_TC2XC2S_TIOA0; // XC2 Clock = TIOA0 | AT91C_TCB_TC2XC2S_TIOA0; // XC2 Clock = TIOA0
// configure TC1 to create a short pulse on TIOA1 when a rising edge on TIOB1 (= ssp_clk from FPGA) occurs: // configure TC1 to create a short pulse on TIOA1 when a rising edge on TIOB1 (= ssp_clk from FPGA) occurs:
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; // disable TC1 AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; // disable TC1
AT91C_BASE_TC1->TC_CMR = AT91C_TC_CLKS_TIMER_DIV1_CLOCK // TC1 Clock = MCK(48MHz)/2 = 24MHz AT91C_BASE_TC1->TC_CMR = AT91C_TC_CLKS_TIMER_DIV1_CLOCK // TC1 Clock = MCK(48MHz)/2 = 24MHz
| AT91C_TC_CPCSTOP // Stop clock on RC compare | AT91C_TC_CPCSTOP // Stop clock on RC compare
| AT91C_TC_EEVTEDG_RISING // Trigger on rising edge of Event | AT91C_TC_EEVTEDG_RISING // Trigger on rising edge of Event
| AT91C_TC_EEVT_TIOB // Event-Source: TIOB1 (= ssp_clk from FPGA = 13,56MHz/16 ... 13,56MHz/4) | AT91C_TC_EEVT_TIOB // Event-Source: TIOB1 (= ssp_clk from FPGA = 13,56MHz/16 ... 13,56MHz/4)
| AT91C_TC_ENETRG // Enable external trigger event | AT91C_TC_ENETRG // Enable external trigger event
| AT91C_TC_WAVESEL_UP // Upmode without automatic trigger on RC compare | AT91C_TC_WAVESEL_UP // Upmode without automatic trigger on RC compare
| AT91C_TC_WAVE // Waveform Mode | AT91C_TC_WAVE // Waveform Mode
| AT91C_TC_AEEVT_SET // Set TIOA1 on external event | AT91C_TC_AEEVT_SET // Set TIOA1 on external event
| AT91C_TC_ACPC_CLEAR; // Clear TIOA1 on RC Compare | AT91C_TC_ACPC_CLEAR; // Clear TIOA1 on RC Compare
AT91C_BASE_TC1->TC_RC = 0x02; // RC Compare value = 0x02 AT91C_BASE_TC1->TC_RC = 0x02; // RC Compare value = 0x02
// use TC0 to count TIOA1 pulses // use TC0 to count TIOA1 pulses
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS; // disable TC0 AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS; // disable TC0
AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_XC0 // TC0 clock = XC0 clock = TIOA1 AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_XC0 // TC0 clock = XC0 clock = TIOA1
| AT91C_TC_WAVE // Waveform Mode | AT91C_TC_WAVE // Waveform Mode
| AT91C_TC_WAVESEL_UP // just count | AT91C_TC_WAVESEL_UP // just count
| AT91C_TC_ACPA_CLEAR // Clear TIOA0 on RA Compare | AT91C_TC_ACPA_CLEAR // Clear TIOA0 on RA Compare
| AT91C_TC_ACPC_SET; // Set TIOA0 on RC Compare | AT91C_TC_ACPC_SET; // Set TIOA0 on RC Compare
AT91C_BASE_TC0->TC_RA = 1; // RA Compare value = 1; pulse width to TC2 AT91C_BASE_TC0->TC_RA = 1; // RA Compare value = 1; pulse width to TC2
AT91C_BASE_TC0->TC_RC = 0; // RC Compare value = 0; increment TC2 on overflow AT91C_BASE_TC0->TC_RC = 0; // RC Compare value = 0; increment TC2 on overflow
// use TC2 to count TIOA0 pulses (giving us a 32bit counter (TC0/TC2) clocked by ssp_clk) // use TC2 to count TIOA0 pulses (giving us a 32bit counter (TC0/TC2) clocked by ssp_clk)
AT91C_BASE_TC2->TC_CCR = AT91C_TC_CLKDIS; // disable TC2 AT91C_BASE_TC2->TC_CCR = AT91C_TC_CLKDIS; // disable TC2
AT91C_BASE_TC2->TC_CMR = AT91C_TC_CLKS_XC2 // TC2 clock = XC2 clock = TIOA0 AT91C_BASE_TC2->TC_CMR = AT91C_TC_CLKS_XC2 // TC2 clock = XC2 clock = TIOA0
| AT91C_TC_WAVE // Waveform Mode | AT91C_TC_WAVE // Waveform Mode
| AT91C_TC_WAVESEL_UP; // just count | AT91C_TC_WAVESEL_UP; // just count
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN; // enable TC0 AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN; // enable TC0
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN; // enable TC1 AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN; // enable TC1
AT91C_BASE_TC2->TC_CCR = AT91C_TC_CLKEN; // enable TC2 AT91C_BASE_TC2->TC_CCR = AT91C_TC_CLKEN; // enable TC2
// //
// synchronize the counter with the ssp_frame signal. Note: FPGA must be in a FPGA mode with SSC transfer, otherwise SSC_FRAME and SSC_CLK signals would not be present // synchronize the counter with the ssp_frame signal. Note: FPGA must be in a FPGA mode with SSC transfer, otherwise SSC_FRAME and SSC_CLK signals would not be present
// //
while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_FRAME)); // wait for ssp_frame to go high (start of frame) while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_FRAME); // wait for ssp_frame to be low
while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_FRAME); // wait for ssp_frame to be low while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_FRAME)); // wait for ssp_frame to go high (start of frame)
while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK)); // wait for ssp_clk to go high while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK)); // wait for ssp_clk to go high; 1st ssp_clk after start of frame
// note: up to now two ssp_clk rising edges have passed since the rising edge of ssp_frame while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK); // wait for ssp_clk to go low;
while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK)); // wait for ssp_clk to go high; 2nd ssp_clk after start of frame
if ((AT91C_BASE_SSC->SSC_RFMR & SSC_FRAME_MODE_BITS_IN_WORD(32)) == SSC_FRAME_MODE_BITS_IN_WORD(16)) {
while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK); // wait for ssp_clk to go low;
while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK)); // wait for ssp_clk to go high; 3rd ssp_clk after start of frame
while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK); // wait for ssp_clk to go low;
while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK)); // wait for ssp_clk to go high; 4th ssp_clk after start of frame
while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK); // wait for ssp_clk to go low;
while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK)); // wait for ssp_clk to go high; 5th ssp_clk after start of frame
while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK); // wait for ssp_clk to go low;
while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK)); // wait for ssp_clk to go high; 6th ssp_clk after start of frame
}
// it is now safe to assert a sync signal. This sets all timers to 0 on next active clock edge // it is now safe to assert a sync signal. This sets all timers to 0 on next active clock edge
AT91C_BASE_TCB->TCB_BCR = 1; // assert Sync (set all timers to 0 on next active clock edge) AT91C_BASE_TCB->TCB_BCR = 1; // assert Sync (set all timers to 0 on next active clock edge)
// at the next (3rd) ssp_clk rising edge, TC1 will be reset (and not generate a clock signal to TC0) // at the next (3rd/7th) ssp_clk rising edge, TC1 will be reset (and not generate a clock signal to TC0)
// at the next (4th) ssp_clk rising edge, TC0 (the low word of our counter) will be reset. From now on, // at the next (4th/8th) ssp_clk rising edge, TC0 (the low word of our counter) will be reset. From now on,
// whenever the last three bits of our counter go 0, we can be sure to be in the middle of a frame transfer. // whenever the last three bits of our counter go 0, we can be sure to be in the middle of a frame transfer.
// (just started with the transfer of the 4th Bit). // (just started with the transfer of the 3rd Bit).
// The high word of the counter (TC2) will not reset until the low word (TC0) overflows. Therefore need to wait quite some time before // The high word of the counter (TC2) will not reset until the low word (TC0) overflows. Therefore need to wait quite some time before
// we can use the counter. // we can use the counter.
while (AT91C_BASE_TC0->TC_CV < 0xFFFF); while (AT91C_BASE_TC0->TC_CV < 0xFFFF);
@ -445,19 +456,17 @@ void ResetSspClk(void) {
while (AT91C_BASE_TC2->TC_CV > 0); while (AT91C_BASE_TC2->TC_CV > 0);
} }
uint32_t GetCountSspClk(){ uint32_t GetCountSspClk(){
uint32_t hi, lo; uint32_t hi, lo;
do { do {
hi = AT91C_BASE_TC2->TC_CV; hi = AT91C_BASE_TC2->TC_CV;
lo = AT91C_BASE_TC0->TC_CV; lo = AT91C_BASE_TC0->TC_CV;
} while(hi != AT91C_BASE_TC2->TC_CV); } while (hi != AT91C_BASE_TC2->TC_CV);
return (hi << 16) | lo; return (hi << 16) | lo;
} }
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// Timer for bitbanging, or LF stuff when you need a very precis timer // Timer for bitbanging, or LF stuff when you need a very precis timer
// 1us = 1.5ticks // 1us = 1.5ticks
@ -476,11 +485,11 @@ void StartTicks(void){
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG; // re-enable timer and wait for TC0 AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG; // re-enable timer and wait for TC0
// second configure TC0 (lower, 0x0000FFFF) 16 bit counter // second configure TC0 (lower, 0x0000FFFF) 16 bit counter
AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_TIMER_DIV3_CLOCK | // MCK(48MHz) / 32 AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_TIMER_DIV3_CLOCK | // MCK(48MHz) / 32
AT91C_TC_WAVE | AT91C_TC_WAVESEL_UP_AUTO | AT91C_TC_WAVE | AT91C_TC_WAVESEL_UP_AUTO |
AT91C_TC_ACPA_CLEAR | // RA comperator clears TIOA (carry bit) AT91C_TC_ACPA_CLEAR | // RA comperator clears TIOA (carry bit)
AT91C_TC_ACPC_SET | // RC comperator sets TIOA (carry bit) AT91C_TC_ACPC_SET | // RC comperator sets TIOA (carry bit)
AT91C_TC_ASWTRG_SET; // SWTriger sets TIOA (carry bit) AT91C_TC_ASWTRG_SET; // SWTriger sets TIOA (carry bit)
AT91C_BASE_TC0->TC_RC = 0; // set TIOA (carry bit) on overflow, return to zero AT91C_BASE_TC0->TC_RC = 0; // set TIOA (carry bit) on overflow, return to zero
AT91C_BASE_TC0->TC_RA = 1; // clear carry bit on next clock cycle AT91C_BASE_TC0->TC_RA = 1; // clear carry bit on next clock cycle
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG; // reset and re-enable timer AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG; // reset and re-enable timer
@ -517,7 +526,7 @@ void WaitTicks(uint32_t ticks){
} }
// Wait / Spindelay in us (microseconds) // Wait / Spindelay in us (microseconds)
// 1us = 1.5ticks. // 1us = 1.5ticks.
void WaitUS(uint16_t us){ void WaitUS(uint16_t us){
WaitTicks( (uint32_t)us * 3 / 2 ) ; WaitTicks( (uint32_t)us * 3 / 2 ) ;
@ -546,7 +555,7 @@ void ResetTimer(AT91PS_TC timer){
// stop clock // stop clock
void StopTicks(void){ void StopTicks(void){
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS; AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS;
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS;
} }

2
armsrc/util.h
View file

@ -66,7 +66,7 @@ uint32_t RAMFUNC GetDeltaCountUS();
void StartCountSspClk(); void StartCountSspClk();
void ResetSspClk(void); void ResetSspClk(void);
uint32_t RAMFUNC GetCountSspClk(); uint32_t GetCountSspClk();
extern void StartTicks(void); extern void StartTicks(void);
extern uint32_t GetTicks(void); extern uint32_t GetTicks(void);

2
client/cmdhf.c
View file

@ -61,7 +61,7 @@ int CmdHFSearch(const char *Cmd){
return ans; return ans;
} }
//14b is longest test currently (and rarest chip type) ... put last //14b is longest test currently (and rarest chip type) ... put last
ans = HF14BInfo(false); ans = infoHF14B(false);
if (ans) { if (ans) {
PrintAndLog("\nValid ISO14443B Tag Found - Quiting Search\n"); PrintAndLog("\nValid ISO14443B Tag Found - Quiting Search\n");
return ans; return ans;

417
client/cmdhf14b.c
View file

@ -15,6 +15,7 @@
#include <stdbool.h> #include <stdbool.h>
#include <string.h> #include <string.h>
#include <stdint.h> #include <stdint.h>
#include <ctype.h>
#include "iso14443crc.h" #include "iso14443crc.h"
#include "comms.h" #include "comms.h"
#include "graph.h" #include "graph.h"
@ -25,101 +26,110 @@
#include "taginfo.h" #include "taginfo.h"
static int CmdHelp(const char *Cmd); int CmdHF14BList(const char *Cmd) {
int CmdHF14BList(const char *Cmd)
{
PrintAndLog("Deprecated command, use 'hf list 14b' instead"); PrintAndLog("Deprecated command, use 'hf list 14b' instead");
return 0; return 0;
} }
int CmdHF14BSim(const char *Cmd)
{ int CmdHF14BSim(const char *Cmd) {
UsbCommand c={CMD_SIMULATE_TAG_ISO_14443B}; UsbCommand c={CMD_SIMULATE_TAG_ISO_14443B};
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
int CmdHF14BSnoop(const char *Cmd)
{ int CmdHF14BSnoop(const char *Cmd) {
UsbCommand c = {CMD_SNOOP_ISO_14443B}; UsbCommand c = {CMD_SNOOP_ISO_14443B};
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
/* New command to read the contents of a SRI512 tag /* New command to read the contents of a SRI512 tag
* SRI512 tags are ISO14443-B modulated memory tags, * SRI512 tags are ISO14443-B modulated memory tags,
* this command just dumps the contents of the memory * this command just dumps the contents of the memory
*/ */
int CmdSri512Read(const char *Cmd) int CmdSri512Read(const char *Cmd) {
{
UsbCommand c = {CMD_READ_SRI512_TAG, {strtol(Cmd, NULL, 0), 0, 0}}; UsbCommand c = {CMD_READ_SRI512_TAG, {strtol(Cmd, NULL, 0), 0, 0}};
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
/* New command to read the contents of a SRIX4K tag /* New command to read the contents of a SRIX4K tag
* SRIX4K tags are ISO14443-B modulated memory tags, * SRIX4K tags are ISO14443-B modulated memory tags,
* this command just dumps the contents of the memory/ * this command just dumps the contents of the memory/
*/ */
int CmdSrix4kRead(const char *Cmd) int CmdSrix4kRead(const char *Cmd) {
{
UsbCommand c = {CMD_READ_SRIX4K_TAG, {strtol(Cmd, NULL, 0), 0, 0}}; UsbCommand c = {CMD_READ_SRIX4K_TAG, {strtol(Cmd, NULL, 0), 0, 0}};
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
int rawClose(void){
static bool switch_off_field_14b(void) {
UsbCommand resp; UsbCommand resp;
UsbCommand c = {CMD_ISO_14443B_COMMAND, {0, 0, 0}}; UsbCommand c = {CMD_ISO_14443B_COMMAND, {0, 0, 0}};
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
if (!WaitForResponseTimeout(CMD_ACK,&resp,1000)) { if (!WaitForResponseTimeout(CMD_ACK, &resp, 1000)) {
return 0; return false;
} }
return 0; return false;
} }
int HF14BCmdRaw(bool reply, bool *crc, bool power, uint8_t *data, uint8_t *datalen, bool verbose){
int HF14BCmdRaw(bool reply, bool *crc, bool power, uint8_t *data, uint8_t *datalen, bool verbose) {
UsbCommand resp; UsbCommand resp;
UsbCommand c = {CMD_ISO_14443B_COMMAND, {0, 0, 0}}; // len,recv,power UsbCommand c = {CMD_ISO_14443B_COMMAND, {0, 0, 0}}; // len,recv,power
if(*crc) if (*crc) {
{
uint8_t first, second; uint8_t first, second;
ComputeCrc14443(CRC_14443_B, data, *datalen, &first, &second); ComputeCrc14443(CRC_14443_B, data, *datalen, &first, &second);
data[*datalen] = first; data[*datalen] = first;
data[*datalen + 1] = second; data[*datalen + 1] = second;
*datalen += 2; *datalen += 2;
} }
c.arg[0] = *datalen; c.arg[0] = *datalen;
c.arg[1] = reply; c.arg[1] = reply;
c.arg[2] = power; c.arg[2] = power;
memcpy(c.d.asBytes,data,*datalen); memcpy(c.d.asBytes,data, *datalen);
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
if (!reply) return 1;
if (!WaitForResponseTimeout(CMD_ACK,&resp,1000)) { if (!reply) return 1;
if (!WaitForResponseTimeout(CMD_ACK, &resp, 1000)) {
if (verbose) PrintAndLog("timeout while waiting for reply."); if (verbose) PrintAndLog("timeout while waiting for reply.");
return 0; return 0;
} }
*datalen = resp.arg[0];
if (verbose) PrintAndLog("received %u octets", *datalen); int ret = resp.arg[0];
if(*datalen<2) return 0; if (verbose) {
if (ret < 0) {
PrintAndLog("tag didn't respond");
} else if (ret == 0) {
PrintAndLog("received SOF only (maybe iCLASS/Picopass)");
} else {
PrintAndLog("received %u octets", ret);
}
}
*datalen = ret;
if (ret < 2) return 0;
memcpy(data, resp.d.asBytes, *datalen); memcpy(data, resp.d.asBytes, *datalen);
if (verbose) PrintAndLog("%s", sprint_hex(data, *datalen)); if (verbose) PrintAndLog("%s", sprint_hex(data, *datalen));
uint8_t first, second; uint8_t first, second;
ComputeCrc14443(CRC_14443_B, data, *datalen-2, &first, &second); ComputeCrc14443(CRC_14443_B, data, *datalen-2, &first, &second);
if(data[*datalen-2] == first && data[*datalen-1] == second) { if (data[*datalen-2] == first && data[*datalen-1] == second) {
if (verbose) PrintAndLog("CRC OK"); if (verbose) PrintAndLog("CRC OK");
*crc = true; *crc = true;
} else { } else {
@ -129,7 +139,8 @@ int HF14BCmdRaw(bool reply, bool *crc, bool power, uint8_t *data, uint8_t *datal
return 1; return 1;
} }
int CmdHF14BCmdRaw (const char *Cmd) {
static int CmdHF14BCmdRaw (const char *Cmd) {
bool reply = true; bool reply = true;
bool crc = false; bool crc = false;
bool power = false; bool power = false;
@ -140,7 +151,7 @@ int CmdHF14BCmdRaw (const char *Cmd) {
uint8_t datalen = 0; uint8_t datalen = 0;
unsigned int temp; unsigned int temp;
int i = 0; int i = 0;
if (strlen(Cmd)<3) { if (strlen(Cmd) < 2) {
PrintAndLog("Usage: hf 14b raw [-r] [-c] [-p] [-s || -ss] <0A 0B 0C ... hex>"); PrintAndLog("Usage: hf 14b raw [-r] [-c] [-p] [-s || -ss] <0A 0B 0C ... hex>");
PrintAndLog(" -r do not read response"); PrintAndLog(" -r do not read response");
PrintAndLog(" -c calculate and append CRC"); PrintAndLog(" -c calculate and append CRC");
@ -151,28 +162,28 @@ int CmdHF14BCmdRaw (const char *Cmd) {
} }
// strip // strip
while (*Cmd==' ' || *Cmd=='\t') Cmd++; while (*Cmd == ' ' || *Cmd == '\t') Cmd++;
while (Cmd[i]!='\0') { while (Cmd[i] != '\0') {
if (Cmd[i]==' ' || Cmd[i]=='\t') { i++; continue; } if (Cmd[i] == ' ' || Cmd[i] == '\t') { i++; continue; }
if (Cmd[i]=='-') { if (Cmd[i] == '-') {
switch (Cmd[i+1]) { switch (Cmd[i+1]) {
case 'r': case 'r':
case 'R': case 'R':
reply = false; reply = false;
break; break;
case 'c': case 'c':
case 'C': case 'C':
crc = true; crc = true;
break; break;
case 'p': case 'p':
case 'P': case 'P':
power = true; power = true;
break; break;
case 's': case 's':
case 'S': case 'S':
select = true; select = true;
if (Cmd[i+2]=='s' || Cmd[i+2]=='S') { if (Cmd[i+2] == 's' || Cmd[i+2] == 'S') {
SRx = true; SRx = true;
i++; i++;
} }
@ -181,34 +192,33 @@ int CmdHF14BCmdRaw (const char *Cmd) {
PrintAndLog("Invalid option"); PrintAndLog("Invalid option");
return 0; return 0;
} }
i+=2; i += 2;
continue; continue;
} }
if ((Cmd[i]>='0' && Cmd[i]<='9') || if ((Cmd[i] >= '0' && Cmd[i] <= '9') ||
(Cmd[i]>='a' && Cmd[i]<='f') || (Cmd[i] >= 'a' && Cmd[i] <= 'f') ||
(Cmd[i]>='A' && Cmd[i]<='F') ) { (Cmd[i] >= 'A' && Cmd[i] <= 'F') ) {
buf[strlen(buf)+1]=0; buf[strlen(buf)+1] = 0;
buf[strlen(buf)]=Cmd[i]; buf[strlen(buf)] = Cmd[i];
i++; i++;
if (strlen(buf)>=2) { if (strlen(buf) >= 2) {
sscanf(buf,"%x",&temp); sscanf(buf, "%x", &temp);
data[datalen++]=(uint8_t)(temp & 0xff); data[datalen++] = (uint8_t)(temp & 0xff);
*buf=0; *buf = 0;
} }
continue; continue;
} }
PrintAndLog("Invalid char on input"); PrintAndLog("Invalid char on input");
return 0; return 0;
} }
if (datalen == 0) if (datalen == 0) {
{
PrintAndLog("Missing data input"); PrintAndLog("Missing data input");
return 0; return 0;
} }
if (select){ //auto select 14b tag if (select) { //auto select 14b tag
uint8_t cmd2[16]; uint8_t cmd2[16];
bool crc2 = true; bool crc2 = true;
uint8_t cmdLen; uint8_t cmdLen;
@ -225,11 +235,11 @@ int CmdHF14BCmdRaw (const char *Cmd) {
cmd2[2] = 0x08; cmd2[2] = 0x08;
} }
if (HF14BCmdRaw(true, &crc2, true, cmd2, &cmdLen, false)==0) return rawClose(); if (HF14BCmdRaw(true, &crc2, true, cmd2, &cmdLen, false) == 0) return switch_off_field_14b();
if (SRx && (cmdLen != 3 || !crc2) ) return switch_off_field_14b();
else if (cmd2[0] != 0x50 || cmdLen != 14 || !crc2) return switch_off_field_14b();
if ( SRx && (cmdLen != 3 || !crc2) ) return rawClose();
else if (cmd2[0] != 0x50 || cmdLen != 14 || !crc2) return rawClose();
uint8_t chipID = 0; uint8_t chipID = 0;
if (SRx) { if (SRx) {
// select // select
@ -239,7 +249,7 @@ int CmdHF14BCmdRaw (const char *Cmd) {
cmdLen = 2; cmdLen = 2;
} else { } else {
// attrib // attrib
cmd2[0] = 0x1D; cmd2[0] = 0x1D;
// UID from cmd2[1 - 4] // UID from cmd2[1 - 4]
cmd2[5] = 0x00; cmd2[5] = 0x00;
cmd2[6] = 0x08; cmd2[6] = 0x08;
@ -248,39 +258,40 @@ int CmdHF14BCmdRaw (const char *Cmd) {
cmdLen = 9; cmdLen = 9;
} }
if (HF14BCmdRaw(true, &crc2, true, cmd2, &cmdLen, false)==0) return rawClose(); if (HF14BCmdRaw(true, &crc2, true, cmd2, &cmdLen, false) == 0) return switch_off_field_14b();
if (cmdLen != 3 || !crc2) return rawClose(); if (cmdLen != 3 || !crc2) return switch_off_field_14b();
if (SRx && cmd2[0] != chipID) return rawClose(); if (SRx && cmd2[0] != chipID) return switch_off_field_14b();
} }
return HF14BCmdRaw(reply, &crc, power, data, &datalen, true); return HF14BCmdRaw(reply, &crc, power, data, &datalen, true);
} }
// print full atqb info // print full atqb info
static void print_atqb_resp(uint8_t *data){ static void print_atqb_resp(uint8_t *data) {
//PrintAndLog (" UID: %s", sprint_hex(data+1,4)); //PrintAndLog (" UID: %s", sprint_hex(data+1,4));
PrintAndLog (" App Data: %s", sprint_hex(data+5,4)); PrintAndLog(" App Data: %s", sprint_hex(data+5,4));
PrintAndLog (" Protocol: %s", sprint_hex(data+9,3)); PrintAndLog(" Protocol: %s", sprint_hex(data+9,3));
uint8_t BitRate = data[9]; uint8_t BitRate = data[9];
if (!BitRate) if (!BitRate)
PrintAndLog (" Bit Rate: 106 kbit/s only PICC <-> PCD"); PrintAndLog (" Bit Rate: 106 kbit/s only PICC <-> PCD");
if (BitRate & 0x10) if (BitRate & 0x10)
PrintAndLog (" Bit Rate: 212 kbit/s PICC -> PCD supported"); PrintAndLog (" Bit Rate: 212 kbit/s PICC -> PCD supported");
if (BitRate & 0x20) if (BitRate & 0x20)
PrintAndLog (" Bit Rate: 424 kbit/s PICC -> PCD supported"); PrintAndLog (" Bit Rate: 424 kbit/s PICC -> PCD supported");
if (BitRate & 0x40) if (BitRate & 0x40)
PrintAndLog (" Bit Rate: 847 kbit/s PICC -> PCD supported"); PrintAndLog (" Bit Rate: 847 kbit/s PICC -> PCD supported");
if (BitRate & 0x01) if (BitRate & 0x01)
PrintAndLog (" Bit Rate: 212 kbit/s PICC <- PCD supported"); PrintAndLog (" Bit Rate: 212 kbit/s PICC <- PCD supported");
if (BitRate & 0x02) if (BitRate & 0x02)
PrintAndLog (" Bit Rate: 424 kbit/s PICC <- PCD supported"); PrintAndLog (" Bit Rate: 424 kbit/s PICC <- PCD supported");
if (BitRate & 0x04) if (BitRate & 0x04)
PrintAndLog (" Bit Rate: 847 kbit/s PICC <- PCD supported"); PrintAndLog (" Bit Rate: 847 kbit/s PICC <- PCD supported");
if (BitRate & 0x80) if (BitRate & 0x80)
PrintAndLog (" Same bit rate <-> required"); PrintAndLog (" Same bit rate <-> required");
uint16_t maxFrame = data[10]>>4; uint16_t maxFrame = data[10] >> 4;
if (maxFrame < 5) if (maxFrame < 5)
maxFrame = 8*maxFrame + 16; maxFrame = 8*maxFrame + 16;
else if (maxFrame == 5) else if (maxFrame == 5)
maxFrame = 64; maxFrame = 64;
@ -293,7 +304,7 @@ static void print_atqb_resp(uint8_t *data){
else else
maxFrame = 257; maxFrame = 257;
PrintAndLog ("Max Frame Size: %u%s",maxFrame, (maxFrame == 257) ? "+ RFU" : ""); PrintAndLog ("Max Frame Size: %u%s", maxFrame, (maxFrame == 257) ? "+ RFU" : "");
uint8_t protocolT = data[10] & 0xF; uint8_t protocolT = data[10] & 0xF;
PrintAndLog (" Protocol Type: Protocol is %scompliant with ISO/IEC 14443-4",(protocolT) ? "" : "not " ); PrintAndLog (" Protocol Type: Protocol is %scompliant with ISO/IEC 14443-4",(protocolT) ? "" : "not " );
@ -302,32 +313,32 @@ static void print_atqb_resp(uint8_t *data){
PrintAndLog (" Frame Options: NAD is %ssupported",(data[11]&2) ? "" : "not "); PrintAndLog (" Frame Options: NAD is %ssupported",(data[11]&2) ? "" : "not ");
PrintAndLog (" Frame Options: CID is %ssupported",(data[11]&1) ? "" : "not "); PrintAndLog (" Frame Options: CID is %ssupported",(data[11]&1) ? "" : "not ");
PrintAndLog ("Max Buf Length: %u (MBLI) %s",data[14]>>4, (data[14] & 0xF0) ? "" : "not supported"); PrintAndLog ("Max Buf Length: %u (MBLI) %s",data[14]>>4, (data[14] & 0xF0) ? "" : "not supported");
return; return;
} }
int print_ST_Lock_info(uint8_t model){ int print_ST_Lock_info(uint8_t model) {
//assume connection open and tag selected... //assume connection open and tag selected...
uint8_t data[16] = {0x00}; uint8_t data[16] = {0x00};
uint8_t datalen = 2; uint8_t datalen = 2;
bool crc = true; bool crc = true;
uint8_t resplen; uint8_t resplen;
uint8_t blk1; uint8_t blk1;
data[0] = 0x08; data[0] = 0x08;
if (model == 0x2) { //SR176 has special command: if (model == 0x02) { //SR176 has special command:
data[1] = 0xf; data[1] = 0x0f;
resplen = 4; resplen = 4;
} else { } else {
data[1] = 0xff; data[1] = 0xff;
resplen = 6; resplen = 6;
} }
//std read cmd //std read cmd
if (HF14BCmdRaw(true, &crc, true, data, &datalen, false)==0) return rawClose(); if (HF14BCmdRaw(true, &crc, true, data, &datalen, false) == 0) return switch_off_field_14b();
if (datalen != resplen || !crc) return rawClose(); if (datalen != resplen || !crc) return switch_off_field_14b();
PrintAndLog("Chip Write Protection Bits:"); PrintAndLog("Chip Write Protection Bits:");
// now interpret the data // now interpret the data
@ -339,7 +350,7 @@ int print_ST_Lock_info(uint8_t model){
blk1 = 9; blk1 = 9;
PrintAndLog(" raw: %s",printBits(1,data+3)); PrintAndLog(" raw: %s",printBits(1,data+3));
PrintAndLog(" 07/08:%slocked", (data[3] & 1) ? " not " : " " ); PrintAndLog(" 07/08:%slocked", (data[3] & 1) ? " not " : " " );
for (uint8_t i = 1; i<8; i++){ for (uint8_t i = 1; i < 8; i++){
PrintAndLog(" %02u:%slocked", blk1, (data[3] & (1 << i)) ? " not " : " " ); PrintAndLog(" %02u:%slocked", blk1, (data[3] & (1 << i)) ? " not " : " " );
blk1++; blk1++;
} }
@ -349,9 +360,9 @@ int print_ST_Lock_info(uint8_t model){
case 0xC: // (SRT512) case 0xC: // (SRT512)
//need data[2] and data[3] //need data[2] and data[3]
blk1 = 0; blk1 = 0;
PrintAndLog(" raw: %s",printBits(2,data+2)); PrintAndLog(" raw: %s", printBits(2,data+2));
for (uint8_t b=2; b<4; b++){ for (uint8_t b = 2; b < 4; b++) {
for (uint8_t i=0; i<8; i++){ for (uint8_t i = 0; i < 8; i++) {
PrintAndLog(" %02u:%slocked", blk1, (data[b] & (1 << i)) ? " not " : " " ); PrintAndLog(" %02u:%slocked", blk1, (data[b] & (1 << i)) ? " not " : " " );
blk1++; blk1++;
} }
@ -360,29 +371,31 @@ int print_ST_Lock_info(uint8_t model){
case 0x2: // (SR176) case 0x2: // (SR176)
//need data[2] //need data[2]
blk1 = 0; blk1 = 0;
PrintAndLog(" raw: %s",printBits(1,data+2)); PrintAndLog(" raw: %s",printBits(1, data+2));
for (uint8_t i = 0; i<8; i++){ for (uint8_t i = 0; i < 8; i++){
PrintAndLog(" %02u/%02u:%slocked", blk1, blk1+1, (data[2] & (1 << i)) ? " " : " not " ); PrintAndLog(" %02u/%02u:%slocked", blk1, blk1+1, (data[2] & (1 << i)) ? " " : " not " );
blk1+=2; blk1 += 2;
} }
break; break;
default: default:
return rawClose(); return switch_off_field_14b();
} }
return 1; return 1;
} }
// print UID info from SRx chips (ST Microelectronics) // print UID info from SRx chips (ST Microelectronics)
static void print_st_general_info(uint8_t *data){ static void print_st_general_info(uint8_t *data) {
//uid = first 8 bytes in data //uid = first 8 bytes in data
PrintAndLog(" UID: %s", sprint_hex(SwapEndian64(data,8,8),8)); PrintAndLog(" UID: %s", sprint_hex(SwapEndian64(data, 8, 8), 8));
PrintAndLog(" MFG: %02X, %s", data[6], getManufacturerName(data[6])); PrintAndLog(" MFG: %02X, %s", data[6], getManufacturerName(data[6]));
PrintAndLog(" Chip: %02X, %s", data[5], getChipInfo(data[6], data[5])); PrintAndLog(" Chip: %02X, %s", data[5], getChipInfo(data[6], data[5]));
return; return;
} }
// 14b get and print UID only (general info) // 14b get and print UID only (general info)
int HF14BStdReader(uint8_t *data, uint8_t *datalen){ int HF14BStdReader(uint8_t *data, uint8_t *datalen) {
//05 00 00 = find one tag in field //05 00 00 = find one tag in field
//1d xx xx xx xx 00 08 01 00 = attrib xx=UID (resp 10 [f9 e0]) //1d xx xx xx xx 00 08 01 00 = attrib xx=UID (resp 10 [f9 e0])
//a3 = ? (resp 03 [e2 c2]) //a3 = ? (resp 03 [e2 c2])
@ -407,18 +420,18 @@ int HF14BStdReader(uint8_t *data, uint8_t *datalen){
data[1] = 0x00; data[1] = 0x00;
data[2] = 0x08; data[2] = 0x08;
if (HF14BCmdRaw(true, &crc, true, data, datalen, false)==0) return rawClose(); if (HF14BCmdRaw(true, &crc, true, data, datalen, false) == 0) return switch_off_field_14b();
if (data[0] != 0x50 || *datalen != 14 || !crc) return rawClose(); if (data[0] != 0x50 || *datalen != 14 || !crc) return switch_off_field_14b();
PrintAndLog ("\n14443-3b tag found:"); PrintAndLog ("\n14443-3b tag found:");
PrintAndLog (" UID: %s", sprint_hex(data+1,4)); PrintAndLog (" UID: %s", sprint_hex(data+1, 4));
uint8_t cmd2[16]; uint8_t cmd2[16];
uint8_t cmdLen = 3; uint8_t cmdLen = 3;
bool crc2 = true; bool crc2 = true;
cmd2[0] = 0x1D; cmd2[0] = 0x1D;
// UID from data[1 - 4] // UID from data[1 - 4]
cmd2[1] = data[1]; cmd2[1] = data[1];
cmd2[2] = data[2]; cmd2[2] = data[2];
@ -431,28 +444,29 @@ int HF14BStdReader(uint8_t *data, uint8_t *datalen){
cmdLen = 9; cmdLen = 9;
// attrib // attrib
if (HF14BCmdRaw(true, &crc2, true, cmd2, &cmdLen, false)==0) return rawClose(); if (HF14BCmdRaw(true, &crc2, true, cmd2, &cmdLen, false) == 0) return switch_off_field_14b();
if (cmdLen != 3 || !crc2) return rawClose(); if (cmdLen != 3 || !crc2) return switch_off_field_14b();
// add attrib responce to data // add attrib responce to data
data[14] = cmd2[0]; data[14] = cmd2[0];
rawClose(); switch_off_field_14b();
return 1; return 1;
} }
// 14b get and print Full Info (as much as we know) // 14b get and print Full Info (as much as we know)
int HF14BStdInfo(uint8_t *data, uint8_t *datalen){ static bool HF14B_Std_Info(uint8_t *data, uint8_t *datalen) {
if (!HF14BStdReader(data,datalen)) return 0; if (!HF14BStdReader(data, datalen)) return false;
//add more info here //add more info here
print_atqb_resp(data); print_atqb_resp(data);
return true;
return 1;
} }
// SRx get and print general info about SRx chip from UID // SRx get and print general info about SRx chip from UID
int HF14B_ST_Reader(uint8_t *data, uint8_t *datalen, bool closeCon){ static bool HF14B_ST_Reader(uint8_t *data, uint8_t *datalen, bool closeCon){
bool crc = true; bool crc = true;
*datalen = 2; *datalen = 2;
//wake cmd //wake cmd
@ -461,9 +475,9 @@ int HF14B_ST_Reader(uint8_t *data, uint8_t *datalen, bool closeCon){
//leave power on //leave power on
// verbose on for now for testing - turn off when functional // verbose on for now for testing - turn off when functional
if (HF14BCmdRaw(true, &crc, true, data, datalen, false)==0) return rawClose(); if (HF14BCmdRaw(true, &crc, true, data, datalen, false) == 0) return switch_off_field_14b();
if (*datalen != 3 || !crc) return rawClose(); if (*datalen != 3 || !crc) return switch_off_field_14b();
uint8_t chipID = data[0]; uint8_t chipID = data[0];
// select // select
@ -472,118 +486,143 @@ int HF14B_ST_Reader(uint8_t *data, uint8_t *datalen, bool closeCon){
*datalen = 2; *datalen = 2;
//leave power on //leave power on
if (HF14BCmdRaw(true, &crc, true, data, datalen, false)==0) return rawClose(); if (HF14BCmdRaw(true, &crc, true, data, datalen, false) == 0) return switch_off_field_14b();
if (*datalen != 3 || !crc || data[0] != chipID) return rawClose(); if (*datalen != 3 || !crc || data[0] != chipID) return switch_off_field_14b();
// get uid // get uid
data[0] = 0x0B; data[0] = 0x0B;
*datalen = 1; *datalen = 1;
//leave power on //leave power on
if (HF14BCmdRaw(true, &crc, true, data, datalen, false)==0) return rawClose(); if (HF14BCmdRaw(true, &crc, true, data, datalen, false) == 0) return switch_off_field_14b();
if (*datalen != 10 || !crc) return rawClose(); if (*datalen != 10 || !crc) return switch_off_field_14b();
//power off ? //power off ?
if (closeCon) rawClose(); if (closeCon) switch_off_field_14b();
PrintAndLog("\n14443-3b ST tag found:"); PrintAndLog("\n14443-3b ST tag found:");
print_st_general_info(data); print_st_general_info(data);
return 1; return 1;
} }
// SRx get and print full info (needs more info...)
int HF14B_ST_Info(uint8_t *data, uint8_t *datalen){
if (!HF14B_ST_Reader(data, datalen, false)) return 0;
//add locking bit information here.
if (print_ST_Lock_info(data[5]>>2))
rawClose();
return 1; // SRx get and print full info (needs more info...)
static bool HF14B_ST_Info(bool verbose) {
uint8_t data[100];
uint8_t datalen;
if (!HF14B_ST_Reader(data, &datalen, false)) return false;
//add locking bit information here.
if (print_ST_Lock_info(data[5] >> 2))
switch_off_field_14b();
return true;
} }
// test for other 14b type tags (mimic another reader - don't have tags to identify) // test for other 14b type tags (mimic another reader - don't have tags to identify)
int HF14B_Other_Reader(uint8_t *data, uint8_t *datalen){ static bool HF14B_Other_Reader(bool verbose) {
uint8_t data[4];
uint8_t datalen;
bool crc = true; bool crc = true;
*datalen = 4; datalen = 4;
//std read cmd //std read cmd
data[0] = 0x00; data[0] = 0x00;
data[1] = 0x0b; data[1] = 0x0b;
data[2] = 0x3f; data[2] = 0x3f;
data[3] = 0x80; data[3] = 0x80;
if (HF14BCmdRaw(true, &crc, true, data, datalen, false)!=0) { if (HF14BCmdRaw(true, &crc, true, data, &datalen, false) != 0) {
if (*datalen > 2 || !crc) { if (datalen > 2 || !crc) {
PrintAndLog ("\n14443-3b tag found:"); PrintAndLog ("\n14443-3b tag found:");
PrintAndLog ("Unknown tag type answered to a 0x000b3f80 command ans:"); PrintAndLog ("Unknown tag type answered to a 0x000b3f80 command ans:");
PrintAndLog ("%s",sprint_hex(data,*datalen)); PrintAndLog ("%s", sprint_hex(data, datalen));
rawClose(); switch_off_field_14b();
return 1; return true;
} }
} }
crc = false; crc = false;
*datalen = 1; datalen = 1;
data[0] = 0x0a; data[0] = 0x0a;
if (HF14BCmdRaw(true, &crc, true, data, datalen, false)!=0) { if (HF14BCmdRaw(true, &crc, true, data, &datalen, false) != 0) {
if (*datalen > 0) { if (datalen > 0) {
PrintAndLog ("\n14443-3b tag found:"); PrintAndLog ("\n14443-3b tag found:");
PrintAndLog ("Unknown tag type answered to a 0x0A command ans:"); PrintAndLog ("Unknown tag type answered to a 0x0A command ans:");
PrintAndLog ("%s",sprint_hex(data,*datalen)); PrintAndLog ("%s", sprint_hex(data, datalen));
rawClose(); switch_off_field_14b();
return 1; return true;
} }
} }
crc = false; crc = false;
*datalen = 1; datalen = 1;
data[0] = 0x0c; data[0] = 0x0c;
if (HF14BCmdRaw(true, &crc, true, data, datalen, false)!=0) { if (HF14BCmdRaw(true, &crc, true, data, &datalen, false) != 0) {
if (*datalen > 0) { if (datalen > 0) {
PrintAndLog ("\n14443-3b tag found:"); PrintAndLog ("\n14443-3b tag found:");
PrintAndLog ("Unknown tag type answered to a 0x0C command ans:"); PrintAndLog ("Unknown tag type answered to a 0x0C command ans:");
PrintAndLog ("%s",sprint_hex(data,*datalen)); PrintAndLog ("%s", sprint_hex(data, datalen));
rawClose(); switch_off_field_14b();
return 1; return true;
} }
} }
rawClose(); switch_off_field_14b();
return false;
}
// get and print all info known about any known 14b tag
static int usage_hf_14b_info(void) {
PrintAndLogEx(NORMAL, "Usage: hf 14b info [h] [s]");
PrintAndLogEx(NORMAL, "Options:");
PrintAndLogEx(NORMAL, " h this help");
PrintAndLogEx(NORMAL, " s silently");
PrintAndLogEx(NORMAL, "Example:");
PrintAndLogEx(NORMAL, " hf 14b info");
return 0; return 0;
} }
// get and print all info known about any known 14b tag int infoHF14B(bool verbose) {
int HF14BInfo(bool verbose){
uint8_t data[100]; uint8_t data[100];
uint8_t datalen = 5; uint8_t datalen;
// try std 14b (atqb) // try std 14b (atqb)
if (HF14BStdInfo(data, &datalen)) return 1; if (HF14B_Std_Info(data, &datalen)) return 1;
// try st 14b // try st 14b
if (HF14B_ST_Info(data, &datalen)) return 1; if (HF14B_ST_Info(verbose)) return 1;
// try unknown 14b read commands (to be identified later) // try unknown 14b read commands (to be identified later)
// could be read of calypso, CEPAS, moneo, or pico pass. // could be read of calypso, CEPAS, moneo, or pico pass.
if (HF14B_Other_Reader(data, &datalen)) return 1; if (HF14B_Other_Reader(verbose)) return 1;
if (verbose) PrintAndLog("no 14443B tag found"); if (verbose) PrintAndLog("no 14443B tag found");
return 0; return 0;
} }
// menu command to get and print all info known about any known 14b tag // menu command to get and print all info known about any known 14b tag
int CmdHF14Binfo(const char *Cmd){ static int CmdHF14Binfo(const char *Cmd){
return HF14BInfo(true); char cmdp = tolower(param_getchar(Cmd, 0));
if (cmdp == 'h') return usage_hf_14b_info();
bool verbose = !(cmdp == 's');
return infoHF14B(verbose);
} }
// get and print general info about all known 14b chips // get and print general info about all known 14b chips
int HF14BReader(bool verbose){ int readHF14B(bool verbose){
uint8_t data[100]; uint8_t data[100];
uint8_t datalen = 5; uint8_t datalen = 5;
// try std 14b (atqb) // try std 14b (atqb)
if (HF14BStdReader(data, &datalen)) return 1; if (HF14BStdReader(data, &datalen)) return 1;
@ -592,33 +631,50 @@ int HF14BReader(bool verbose){
// try unknown 14b read commands (to be identified later) // try unknown 14b read commands (to be identified later)
// could be read of calypso, CEPAS, moneo, or pico pass. // could be read of calypso, CEPAS, moneo, or pico pass.
if (HF14B_Other_Reader(data, &datalen)) return 1; if (HF14B_Other_Reader(verbose)) return 1;
if (verbose) PrintAndLog("no 14443B tag found"); if (verbose) PrintAndLog("no 14443B tag found");
return 0; return 0;
} }
// menu command to get and print general info about all known 14b chips // menu command to get and print general info about all known 14b chips
int CmdHF14BReader(const char *Cmd){ static int usage_hf_14b_reader(void) {
return HF14BReader(true); PrintAndLogEx(NORMAL, "Usage: hf 14b reader [h] [s]");
PrintAndLogEx(NORMAL, "Options:");
PrintAndLogEx(NORMAL, " h this help");
PrintAndLogEx(NORMAL, " s silently");
PrintAndLogEx(NORMAL, "Example:");
PrintAndLogEx(NORMAL, " hf 14b reader");
return 0;
} }
int CmdSriWrite( const char *Cmd){
static int CmdHF14BReader(const char *Cmd) {
char cmdp = tolower(param_getchar(Cmd, 0));
if (cmdp == 'h') return usage_hf_14b_reader();
bool verbose = !(cmdp == 's');
return readHF14B(verbose);
}
int CmdSriWrite(const char *Cmd) {
/* /*
* For SRIX4K blocks 00 - 7F * For SRIX4K blocks 00 - 7F
* hf 14b raw -c -p 09 $srix4kwblock $srix4kwdata * hf 14b raw -c -p 09 $srix4kwblock $srix4kwdata
* *
* For SR512 blocks 00 - 0F * For SR512 blocks 00 - 0F
* hf 14b raw -c -p 09 $sr512wblock $sr512wdata * hf 14b raw -c -p 09 $sr512wblock $sr512wdata
* *
* Special block FF = otp_lock_reg block. * Special block FF = otp_lock_reg block.
* Data len 4 bytes- * Data len 4 bytes-
*/ */
char cmdp = param_getchar(Cmd, 0); char cmdp = param_getchar(Cmd, 0);
uint8_t blockno = -1; uint8_t blockno = -1;
uint8_t data[4] = {0x00}; uint8_t data[4] = {0x00};
bool isSrix4k = true; bool isSrix4k = true;
char str[20]; char str[20];
if (strlen(Cmd) < 1 || cmdp == 'h' || cmdp == 'H') { if (strlen(Cmd) < 1 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: hf 14b write <1|2> <BLOCK> <DATA>"); PrintAndLog("Usage: hf 14b write <1|2> <BLOCK> <DATA>");
@ -634,43 +690,46 @@ int CmdSriWrite( const char *Cmd){
if ( cmdp == '2' ) if ( cmdp == '2' )
isSrix4k = false; isSrix4k = false;
//blockno = param_get8(Cmd, 1); //blockno = param_get8(Cmd, 1);
if ( param_gethex(Cmd,1, &blockno, 2) ) { if (param_gethex(Cmd,1, &blockno, 2) ) {
PrintAndLog("Block number must include 2 HEX symbols"); PrintAndLog("Block number must include 2 HEX symbols");
return 0; return 0;
} }
if ( isSrix4k ){ if (isSrix4k) {
if ( blockno > 0x7f && blockno != 0xff ){ if (blockno > 0x7f && blockno != 0xff){
PrintAndLog("Block number out of range"); PrintAndLog("Block number out of range");
return 0; return 0;
} }
} else { } else {
if ( blockno > 0x0f && blockno != 0xff ){ if (blockno > 0x0f && blockno != 0xff){
PrintAndLog("Block number out of range"); PrintAndLog("Block number out of range");
return 0; return 0;
} }
} }
if (param_gethex(Cmd, 2, data, 8)) { if (param_gethex(Cmd, 2, data, 8)) {
PrintAndLog("Data must include 8 HEX symbols"); PrintAndLog("Data must include 8 HEX symbols");
return 0; return 0;
} }
if ( blockno == 0xff) if (blockno == 0xff)
PrintAndLog("[%s] Write special block %02X [ %s ]", (isSrix4k)?"SRIX4K":"SRI512" , blockno, sprint_hex(data,4) ); PrintAndLog("[%s] Write special block %02X [ %s ]", (isSrix4k)?"SRIX4K":"SRI512", blockno, sprint_hex(data, 4));
else else
PrintAndLog("[%s] Write block %02X [ %s ]", (isSrix4k)?"SRIX4K":"SRI512", blockno, sprint_hex(data,4) ); PrintAndLog("[%s] Write block %02X [ %s ]", (isSrix4k)?"SRIX4K":"SRI512", blockno, sprint_hex(data, 4));
sprintf(str, "-c 09 %02x %02x%02x%02x%02x", blockno, data[0], data[1], data[2], data[3]); sprintf(str, "-c 09 %02x %02x%02x%02x%02x", blockno, data[0], data[1], data[2], data[3]);
CmdHF14BCmdRaw(str); CmdHF14BCmdRaw(str);
return 0; return 0;
} }
static command_t CommandTable[] =
static int CmdHelp(const char *Cmd);
static command_t CommandTable[] =
{ {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, 1, "This help"},
{"info", CmdHF14Binfo, 0, "Find and print details about a 14443B tag"}, {"info", CmdHF14Binfo, 0, "Find and print details about a 14443B tag"},

2
client/cmdhf14b.h
View file

@ -21,6 +21,6 @@ int CmdHF14BSnoop(const char *Cmd);
int CmdSri512Read(const char *Cmd); int CmdSri512Read(const char *Cmd);
int CmdSrix4kRead(const char *Cmd); int CmdSrix4kRead(const char *Cmd);
int CmdHF14BWrite( const char *cmd); int CmdHF14BWrite( const char *cmd);
int HF14BInfo(bool verbose); int infoHF14B(bool verbose);
#endif #endif

31
client/cmdhf15.c
View file

@ -464,7 +464,7 @@ int CmdHF15CmdRaw (const char *cmd) {
char *hexout; char *hexout;
if (strlen(cmd)<3) { if (strlen(cmd)<2) {
PrintAndLog("Usage: hf 15 cmd raw [-r] [-2] [-c] <0A 0B 0C ... hex>"); PrintAndLog("Usage: hf 15 cmd raw [-r] [-2] [-c] <0A 0B 0C ... hex>");
PrintAndLog(" -r do not read response"); PrintAndLog(" -r do not read response");
PrintAndLog(" -2 use slower '1 out of 256' mode"); PrintAndLog(" -2 use slower '1 out of 256' mode");
@ -526,22 +526,31 @@ int CmdHF15CmdRaw (const char *cmd) {
SendCommand(&c); SendCommand(&c);
if (reply) { if (reply) {
if (WaitForResponseTimeout(CMD_ACK,&resp,1000)) { if (WaitForResponseTimeout(CMD_ACK, &resp, 1000)) {
recv = resp.d.asBytes; recv = resp.d.asBytes;
PrintAndLog("received %i octets",resp.arg[0]); int recv_len = resp.arg[0];
hexout = (char *)malloc(resp.arg[0] * 3 + 1); if (recv_len == 0) {
if (hexout != NULL) { PrintAndLog("received SOF only. Maybe Picopass/iCLASS?");
for (int i = 0; i < resp.arg[0]; i++) { // data in hex } else if (recv_len > 0) {
sprintf(&hexout[i * 3], "%02X ", recv[i]); PrintAndLog("received %i octets", recv_len);
hexout = (char *)malloc(resp.arg[0] * 3 + 1);
if (hexout != NULL) {
for (int i = 0; i < resp.arg[0]; i++) { // data in hex
sprintf(&hexout[i * 3], "%02X ", recv[i]);
}
PrintAndLog("%s", hexout);
free(hexout);
} }
PrintAndLog("%s", hexout); } else if (recv_len == -1) {
free(hexout); PrintAndLog("card didn't respond");
} else if (recv_len == -2) {
PrintAndLog("receive buffer overflow");
} }
} else { } else {
PrintAndLog("timeout while waiting for reply."); PrintAndLog("timeout while waiting for reply.");
} }
}
} // if reply
return 0; return 0;
} }

821
client/cmdhficlass.c
View file

File diff suppressed because it is too large Load diff

24
client/cmdhficlass.h
View file

@ -13,28 +13,6 @@
#define CMDHFICLASS_H__ #define CMDHFICLASS_H__
int CmdHFiClass(const char *Cmd); int CmdHFiClass(const char *Cmd);
int CmdHFiClassCalcNewKey(const char *Cmd);
int CmdHFiClassCloneTag(const char *Cmd);
int CmdHFiClassDecrypt(const char *Cmd);
int CmdHFiClassEncryptBlk(const char *Cmd);
int CmdHFiClassELoad(const char *Cmd);
int CmdHFiClassList(const char *Cmd);
int HFiClassReader(const char *Cmd, bool loop, bool verbose); int HFiClassReader(const char *Cmd, bool loop, bool verbose);
int CmdHFiClassReader(const char *Cmd);
int CmdHFiClassReader_Dump(const char *Cmd);
int CmdHFiClassReader_Replay(const char *Cmd);
int CmdHFiClassReadKeyFile(const char *filename);
int CmdHFiClassReadTagFile(const char *Cmd);
int CmdHFiClass_ReadBlock(const char *Cmd);
int CmdHFiClass_TestMac(const char *Cmd);
int CmdHFiClassManageKeys(const char *Cmd);
int CmdHFiClass_loclass(const char *Cmd);
int CmdHFiClassSnoop(const char *Cmd);
int CmdHFiClassSim(const char *Cmd);
int CmdHFiClassWriteKeyFile(const char *Cmd);
int CmdHFiClass_WriteBlock(const char *Cmd);
int CmdHFiClassCheckKeys(const char *Cmd);
void printIclassDumpContents(uint8_t *iclass_dump, uint8_t startblock, uint8_t endblock, size_t filesize);
void HFiClassCalcDivKey(uint8_t *CSN, uint8_t *KEY, uint8_t *div_key, bool elite);
#endif #endif

6
client/cmdhflist.c
View file

@ -903,8 +903,6 @@ uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *trace, ui
// adjust for different time scales // adjust for different time scales
if (protocol == ICLASS || protocol == ISO_15693) { if (protocol == ICLASS || protocol == ISO_15693) {
first_timestamp *= 32;
timestamp *= 32;
duration *= 32; duration *= 32;
} }
@ -1037,10 +1035,6 @@ uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *trace, ui
if (showWaitCycles && !isResponse && next_record_is_response(tracepos, trace)) { if (showWaitCycles && !isResponse && next_record_is_response(tracepos, trace)) {
uint32_t next_timestamp = *((uint32_t *)(trace + tracepos)); uint32_t next_timestamp = *((uint32_t *)(trace + tracepos));
// adjust for different time scales
if (protocol == ICLASS || protocol == ISO_15693) {
next_timestamp *= 32;
}
PrintAndLog(" %10d | %10d | %s | fdt (Frame Delay Time): %d", PrintAndLog(" %10d | %10d | %s | fdt (Frame Delay Time): %d",
(EndOfTransmissionTimestamp - first_timestamp), (EndOfTransmissionTimestamp - first_timestamp),

2
client/loclass/elite_crack.h
View file

@ -85,7 +85,7 @@ typedef struct {
uint8_t cc_nr[12]; uint8_t cc_nr[12];
uint8_t mac[4]; uint8_t mac[4];
}dumpdata; } dumpdata;
/** /**
* @brief Performs brute force attack against a dump-data item, containing csn, cc_nr and mac. * @brief Performs brute force attack against a dump-data item, containing csn, cc_nr and mac.

BIN
fpga/fpga_hf.bit
View file

Binary file not shown.

4
fpga/hi_reader.v
View file

@ -247,9 +247,9 @@ begin
// set ssp_frame signal for corr_i_cnt = 1..3 // set ssp_frame signal for corr_i_cnt = 1..3
// (send one frame with 16 Bits) // (send one frame with 16 Bits)
if (corr_i_cnt == 6'd2) if (corr_i_cnt == 6'd1)
ssp_frame <= 1'b1; ssp_frame <= 1'b1;
if (corr_i_cnt == 6'd14) if (corr_i_cnt == 6'd5)
ssp_frame <= 1'b0; ssp_frame <= 1'b0;
end end

7
include/usb_cmd.h
View file

@ -165,7 +165,8 @@ typedef struct{
#define CMD_ICLASS_READBLOCK 0x0396 #define CMD_ICLASS_READBLOCK 0x0396
#define CMD_ICLASS_WRITEBLOCK 0x0397 #define CMD_ICLASS_WRITEBLOCK 0x0397
#define CMD_ICLASS_EML_MEMSET 0x0398 #define CMD_ICLASS_EML_MEMSET 0x0398
#define CMD_ICLASS_AUTHENTICATION 0x0399 #define CMD_ICLASS_CHECK 0x0399
#define CMD_ICLASS_READCHECK 0x039A
// For measurements of the antenna tuning // For measurements of the antenna tuning
#define CMD_MEASURE_ANTENNA_TUNING 0x0400 #define CMD_MEASURE_ANTENNA_TUNING 0x0400
@ -236,13 +237,11 @@ typedef struct{
// iCLASS reader flags // iCLASS reader flags
#define FLAG_ICLASS_READER_ONLY_ONCE 0x01
#define FLAG_ICLASS_READER_CC 0x02 #define FLAG_ICLASS_READER_CC 0x02
#define FLAG_ICLASS_READER_CSN 0x04 #define FLAG_ICLASS_READER_CSN 0x04
#define FLAG_ICLASS_READER_CONF 0x08 #define FLAG_ICLASS_READER_CONF 0x08
#define FLAG_ICLASS_READER_AA 0x10 #define FLAG_ICLASS_READER_AA 0x10
#define FLAG_ICLASS_READER_ONE_TRY 0x20 #define FLAG_ICLASS_READER_CREDITKEY 0x40
#define FLAG_ICLASS_READER_CEDITKEY 0x40
// iCLASS simulation modes // iCLASS simulation modes
#define ICLASS_SIM_MODE_CSN 0 #define ICLASS_SIM_MODE_CSN 0