github/proxmark3
1
0
Fork 0
mirror of https://github.com/Proxmark/proxmark3.git synced 2025-07-15 09:43:00 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #158 from marshmellow42/master

Browse source 
q5 fixes plus a couple coverity scan fixes from @iceman1001
This commit is contained in:
Martin Holst Swende 2016-02-09 12:55:36 +01:00
commit 2a99a73055
10 changed files with 300 additions and 214 deletions
Download patch file Download diff file Expand all files Collapse all files

2
armsrc/BigBuf.c
View file

@ -184,7 +184,7 @@ bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_
traceLen += iLen; traceLen += iLen;
// parity bytes // parity bytes
if (iLen != 0) { if (num_paritybytes != 0) {
if (parity != NULL) { if (parity != NULL) {
memcpy(trace + traceLen, parity, num_paritybytes); memcpy(trace + traceLen, parity, num_paritybytes);
} else { } else {

2
armsrc/des.c
View file

@ -274,7 +274,7 @@ uint32_t des_f(uint32_t r, uint8_t* kr){
uint64_t data; uint64_t data;
uint8_t *sbp; /* sboxpointer */ uint8_t *sbp; /* sboxpointer */
permute((uint8_t*)e_permtab, (uint8_t*)&r, (uint8_t*)&data); permute((uint8_t*)e_permtab, (uint8_t*)&r, (uint8_t*)&data);
for(i=0; i<7; ++i) for(i=0; i<6; ++i)
((uint8_t*)&data)[i] ^= kr[i]; ((uint8_t*)&data)[i] ^= kr[i];
/* Sbox substitution */ /* Sbox substitution */

29
client/cmddata.c
View file

@ -944,35 +944,32 @@ int FSKrawDemod(const char *Cmd, bool verbose)
{ {
//raw fsk demod no manchester decoding no start bit finding just get binary from wave //raw fsk demod no manchester decoding no start bit finding just get binary from wave
uint8_t rfLen, invert, fchigh, fclow; uint8_t rfLen, invert, fchigh, fclow;
//set defaults //set defaults
//set options from parameters entered with the command //set options from parameters entered with the command
rfLen = param_get8ex(Cmd, 0, 0, 10); rfLen = param_get8(Cmd, 0);
invert = param_get8ex(Cmd, 1, 0, 10); invert = param_get8(Cmd, 1);
fchigh = param_get8ex(Cmd, 2, 0, 10); fchigh = param_get8(Cmd, 2);
fclow = param_get8ex(Cmd, 3, 0, 10); fclow = param_get8(Cmd, 3);
if (strlen(Cmd)>0 && strlen(Cmd)<=2) { if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
if (rfLen==1){ if (rfLen==1){
invert = 1; //if invert option only is used invert = 1; //if invert option only is used
rfLen = 0; rfLen = 0;
} }
} }
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
size_t BitLen = getFromGraphBuf(BitStream); size_t BitLen = getFromGraphBuf(BitStream);
if (BitLen==0) return 0; if (BitLen==0) return 0;
//get field clock lengths //get field clock lengths
uint16_t fcs=0; uint8_t fc1=0, fc2=0, rf1=0;
if (!fchigh || !fclow) { if (!fchigh || !fclow) {
fcs = countFC(BitStream, BitLen, 1); uint8_t ans = fskClocks(&fc1, &fc2, &rf1, false);
if (!fcs) { if (ans == 0) {
fchigh = 10; if (g_debugMode) PrintAndLog("\nError: cannot detect valid fsk field clocks");
fclow = 8; return 0; // can't detect field clock
} else {
fchigh = (fcs >> 8) & 0x00FF;
fclow = fcs & 0x00FF;
} }
fchigh = fc1;
fclow = fc2;
if (rfLen == 0) rfLen = rf1;
} }
//get bit clock length //get bit clock length
if (!rfLen){ if (!rfLen){
@ -985,7 +982,7 @@ int FSKrawDemod(const char *Cmd, bool verbose)
// Now output the bitstream to the scrollback by line of 16 bits // Now output the bitstream to the scrollback by line of 16 bits
if (verbose || g_debugMode) { if (verbose || g_debugMode) {
PrintAndLog("\nUsing Clock:%u, invert:%u, fchigh:%u, fclow:%u", rfLen, invert, fchigh, fclow); PrintAndLog("\nUsing Clock:%hu, invert:%hu, fchigh:%hu, fclow:%hu", rfLen, invert, fchigh, fclow);
PrintAndLog("%s decoded bitstream:",GetFSKType(fchigh,fclow,invert)); PrintAndLog("%s decoded bitstream:",GetFSKType(fchigh,fclow,invert));
printDemodBuff(); printDemodBuff();
} }

1
client/cmdhfepa.c
View file

@ -58,6 +58,7 @@ int CmdHFEPACollectPACENonces(const char *Cmd)
} }
// print nonce // print nonce
PrintAndLog("Length: %d, Nonce: %s", nonce_length, nonce); PrintAndLog("Length: %d, Nonce: %s", nonce_length, nonce);
free(nonce);
} }
if (i < n - 1) { if (i < n - 1) {
sleep(d); sleep(d);

2
client/cmdhficlass.c
View file

@ -406,7 +406,7 @@ int CmdHFiClassDecrypt(const char *Cmd) {
fclose(f); fclose(f);
saveFile(outfilename,"bin", decrypted, blocknum*8); saveFile(outfilename,"bin", decrypted, blocknum*8);
free(decrypted);
return 0; return 0;
} }

430
client/cmdlft55xx.c
View file

@ -10,7 +10,7 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <inttypes.h> #include <inttypes.h>
#include <time.h> //#include <time.h> //not used - marshmellow
#include "proxmark3.h" #include "proxmark3.h"
#include "ui.h" #include "ui.h"
#include "graph.h" #include "graph.h"
@ -22,14 +22,14 @@
#include "util.h" #include "util.h"
#include "data.h" #include "data.h"
#include "lfdemod.h" #include "lfdemod.h"
#include "../common/crc.h" //#include "../common/crc.h" //not used - marshmellow
#include "../common/iso14443crc.h" //#include "../common/iso14443crc.h" //not used - marshmellow
#include "cmdhf14a.h" #include "cmdhf14a.h" //for getTagInfo
#define T55x7_CONFIGURATION_BLOCK 0x00 #define T55x7_CONFIGURATION_BLOCK 0x00
#define T55x7_PAGE0 0x00 #define T55x7_PAGE0 0x00
#define T55x7_PAGE1 0x01 #define T55x7_PAGE1 0x01
#define T55x7_PWD 0x00000010 //#define T55x7_PWD 0x00000010
#define REGULAR_READ_MODE_BLOCK 0xFF #define REGULAR_READ_MODE_BLOCK 0xFF
// Default configuration // Default configuration
@ -166,6 +166,19 @@ int usage_t55xx_bruteforce(){
PrintAndLog(""); PrintAndLog("");
return 0; return 0;
} }
int usage_t55xx_wipe(){
PrintAndLog("Usage: lf t55xx wipe [h] [Q5]");
PrintAndLog("This commands wipes a tag, fills blocks 1-7 with zeros and a default configuration block");
PrintAndLog("Options:");
PrintAndLog(" h - this help");
PrintAndLog(" Q5 - indicates to use the T5555 (Q5) default configuration block");
PrintAndLog("");
PrintAndLog("Examples:");
PrintAndLog(" lf t55xx wipe - wipes a t55x7 tag, config block 0x000880E0");
PrintAndLog(" lf t55xx wipe Q5 - wipes a t5555 Q5 tag, config block 0x6001F004");
return 0;
}
static int CmdHelp(const char *Cmd); static int CmdHelp(const char *Cmd);
@ -183,7 +196,6 @@ int CmdT55xxSetConfig(const char *Cmd) {
uint8_t bitRate = 0; uint8_t bitRate = 0;
uint8_t rates[9] = {8,16,32,40,50,64,100,128,0}; uint8_t rates[9] = {8,16,32,40,50,64,100,128,0};
uint8_t cmdp = 0; uint8_t cmdp = 0;
config.Q5 = FALSE;
bool errors = FALSE; bool errors = FALSE;
while(param_getchar(Cmd, cmdp) != 0x00 && !errors) while(param_getchar(Cmd, cmdp) != 0x00 && !errors)
{ {
@ -418,6 +430,13 @@ bool DecodeT55xxBlock(){
return (bool) ans; return (bool) ans;
} }
bool DecodeT5555TraceBlock() {
DemodBufferLen = 0x00;
// According to datasheet. Always: RF/64, not inverted, Manchester
return (bool) ASKDemod("64 0 1", FALSE, FALSE, 1);
}
int CmdT55xxDetect(const char *Cmd){ int CmdT55xxDetect(const char *Cmd){
bool errors = FALSE; bool errors = FALSE;
bool useGB = FALSE; bool useGB = FALSE;
@ -469,7 +488,7 @@ bool tryDetectModulation(){
if (GetFskClock("", FALSE, FALSE)){ if (GetFskClock("", FALSE, FALSE)){
fskClocks(&fc1, &fc2, &clk, FALSE); fskClocks(&fc1, &fc2, &clk, FALSE);
if ( FSKrawDemod("0 0", FALSE) && test(DEMOD_FSK, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)){ if ( FSKrawDemod("0 0", FALSE) && test(DEMOD_FSK, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) {
tests[hits].modulation = DEMOD_FSK; tests[hits].modulation = DEMOD_FSK;
if (fc1==8 && fc2 == 5) if (fc1==8 && fc2 == 5)
tests[hits].modulation = DEMOD_FSK1a; tests[hits].modulation = DEMOD_FSK1a;
@ -486,7 +505,6 @@ bool tryDetectModulation(){
tests[hits].modulation = DEMOD_FSK1; tests[hits].modulation = DEMOD_FSK1;
else if (fc1 == 10 && fc2 == 8) else if (fc1 == 10 && fc2 == 8)
tests[hits].modulation = DEMOD_FSK2a; tests[hits].modulation = DEMOD_FSK2a;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = TRUE; tests[hits].inverted = TRUE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
@ -597,6 +615,7 @@ bool tryDetectModulation(){
config.inverted = tests[0].inverted; config.inverted = tests[0].inverted;
config.offset = tests[0].offset; config.offset = tests[0].offset;
config.block0 = tests[0].block0; config.block0 = tests[0].block0;
config.Q5 = tests[0].Q5;
printConfiguration( config ); printConfiguration( config );
return TRUE; return TRUE;
} }
@ -672,6 +691,15 @@ bool testQ5Modulation(uint8_t mode, uint8_t modread){
return FALSE; return FALSE;
} }
int convertQ5bitRate(uint8_t bitRateRead) {
uint8_t expected[] = {8, 16, 32, 40, 50, 64, 100, 128};
for (int i=0; i<8; i++)
if (expected[i] == bitRateRead)
return i;
return -1;
}
bool testQ5(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk){ bool testQ5(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk){
if ( DemodBufferLen < 64 ) return FALSE; if ( DemodBufferLen < 64 ) return FALSE;
@ -683,12 +711,12 @@ bool testQ5(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk){
uint8_t safer = PackBits(si, 4, DemodBuffer); si += 4; //master key uint8_t safer = PackBits(si, 4, DemodBuffer); si += 4; //master key
uint8_t resv = PackBits(si, 8, DemodBuffer); si += 8; uint8_t resv = PackBits(si, 8, DemodBuffer); si += 8;
// 2nibble must be zeroed. // 2nibble must be zeroed.
if (safer != 0x6) continue; if (safer != 0x6 && safer != 0x9) continue;
if ( resv > 0x00) continue; if ( resv > 0x00) continue;
//uint8_t pageSel = PackBits(si, 1, DemodBuffer); si += 1; //uint8_t pageSel = PackBits(si, 1, DemodBuffer); si += 1;
//uint8_t fastWrite = PackBits(si, 1, DemodBuffer); si += 1; //uint8_t fastWrite = PackBits(si, 1, DemodBuffer); si += 1;
si += 1+1; si += 1+1;
int bitRate = PackBits(si, 5, DemodBuffer)*2 + 2; si += 5; //bit rate int bitRate = PackBits(si, 6, DemodBuffer)*2 + 2; si += 6; //bit rate
if (bitRate > 128 || bitRate < 8) continue; if (bitRate > 128 || bitRate < 8) continue;
//uint8_t AOR = PackBits(si, 1, DemodBuffer); si += 1; //uint8_t AOR = PackBits(si, 1, DemodBuffer); si += 1;
@ -703,7 +731,8 @@ bool testQ5(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk){
//test modulation //test modulation
if (!testQ5Modulation(mode, modread)) continue; if (!testQ5Modulation(mode, modread)) continue;
if (bitRate != clk) continue; if (bitRate != clk) continue;
*fndBitRate = bitRate; *fndBitRate = convertQ5bitRate(bitRate);
if (*fndBitRate < 0) continue;
*offset = idx; *offset = idx;
return TRUE; return TRUE;
@ -926,58 +955,107 @@ int CmdT55xxReadTrace(const char *Cmd) {
if (strlen(Cmd)==0) if (strlen(Cmd)==0)
if ( !AquireData( T55x7_PAGE1, REGULAR_READ_MODE_BLOCK, pwdmode, password ) ) if ( !AquireData( T55x7_PAGE1, REGULAR_READ_MODE_BLOCK, pwdmode, password ) )
return 0; return 0;
if (!DecodeT55xxBlock()) return 0;
if ( !DemodBufferLen) return 0; if ( config.Q5 ) {
if (!DecodeT5555TraceBlock()) return 0;
} else {
if (!DecodeT55xxBlock()) return 0;
}
if ( !DemodBufferLen ) return 0;
RepaintGraphWindow(); RepaintGraphWindow();
uint8_t repeat = 0; uint8_t repeat = (config.offset > 5) ? 32 : 0;
if (config.offset > 5)
repeat = 32;
uint8_t si = config.offset+repeat; uint8_t si = config.offset+repeat;
uint32_t bl1 = PackBits(si, 32, DemodBuffer); uint32_t bl1 = PackBits(si, 32, DemodBuffer);
uint32_t bl2 = PackBits(si+32, 32, DemodBuffer); uint32_t bl2 = PackBits(si+32, 32, DemodBuffer);
uint32_t acl = PackBits(si, 8, DemodBuffer); si += 8;
uint32_t mfc = PackBits(si, 8, DemodBuffer); si += 8;
uint32_t cid = PackBits(si, 5, DemodBuffer); si += 5;
uint32_t icr = PackBits(si, 3, DemodBuffer); si += 3;
uint32_t year = PackBits(si, 4, DemodBuffer); si += 4;
uint32_t quarter = PackBits(si, 2, DemodBuffer); si += 2;
uint32_t lotid = PackBits(si, 14, DemodBuffer); si += 14;
uint32_t wafer = PackBits(si, 5, DemodBuffer); si += 5;
uint32_t dw = PackBits(si, 15, DemodBuffer);
time_t t = time(NULL);
struct tm tm = *localtime(&t);
if ( year > tm.tm_year-110)
year += 2000;
else
year += 2010;
if (config.Q5) PrintAndLog("*** Warning *** Info read off a Q5 will not work as expected"); if (config.Q5) {
if ( acl != 0xE0 ) { uint32_t hdr = PackBits(si, 9, DemodBuffer); si += 9;
PrintAndLog("The modulation is most likely wrong since the ACL is not 0xE0. ");
return 0; if (hdr != 0x1FF) {
PrintAndLog("Invalid Q5 Trace data header (expected 0x1FF, found %X)", hdr);
return 0;
}
t5555_tracedata_t data = {.bl1 = bl1, .bl2 = bl2, .icr = 0, .lotidc = '?', .lotid = 0, .wafer = 0, .dw =0};
data.icr = PackBits(si, 2, DemodBuffer); si += 2;
data.lotidc = 'Z' - PackBits(si, 2, DemodBuffer); si += 3;
data.lotid = PackBits(si, 4, DemodBuffer); si += 5;
data.lotid <<= 4;
data.lotid |= PackBits(si, 4, DemodBuffer); si += 5;
data.lotid <<= 4;
data.lotid |= PackBits(si, 4, DemodBuffer); si += 5;
data.lotid <<= 4;
data.lotid |= PackBits(si, 4, DemodBuffer); si += 5;
data.lotid <<= 1;
data.lotid |= PackBits(si, 1, DemodBuffer); si += 1;
data.wafer = PackBits(si, 3, DemodBuffer); si += 4;
data.wafer <<= 2;
data.wafer |= PackBits(si, 2, DemodBuffer); si += 2;
data.dw = PackBits(si, 2, DemodBuffer); si += 3;
data.dw <<= 4;
data.dw |= PackBits(si, 4, DemodBuffer); si += 5;
data.dw <<= 4;
data.dw |= PackBits(si, 4, DemodBuffer); si += 5;
data.dw <<= 4;
data.dw |= PackBits(si, 4, DemodBuffer); si += 5;
printT5555Trace(data, repeat);
} else {
t55x7_tracedata_t data = {.bl1 = bl1, .bl2 = bl2, .acl = 0, .mfc = 0, .cid = 0, .year = 0, .quarter = 0, .icr = 0, .lotid = 0, .wafer = 0, .dw = 0};
data.acl = PackBits(si, 8, DemodBuffer); si += 8;
if ( data.acl != 0xE0 ) {
PrintAndLog("The modulation is most likely wrong since the ACL is not 0xE0. ");
return 0;
}
data.mfc = PackBits(si, 8, DemodBuffer); si += 8;
data.cid = PackBits(si, 5, DemodBuffer); si += 5;
data.icr = PackBits(si, 3, DemodBuffer); si += 3;
data.year = PackBits(si, 4, DemodBuffer); si += 4;
data.quarter = PackBits(si, 2, DemodBuffer); si += 2;
data.lotid = PackBits(si, 14, DemodBuffer); si += 14;
data.wafer = PackBits(si, 5, DemodBuffer); si += 5;
data.dw = PackBits(si, 15, DemodBuffer);
time_t t = time(NULL);
struct tm tm = *localtime(&t);
if ( data.year > tm.tm_year-110)
data.year += 2000;
else
data.year += 2010;
printT55x7Trace(data, repeat);
} }
PrintAndLog(""); return 0;
PrintAndLog("-- T55xx Trace Information ----------------------------------"); }
void printT55x7Trace( t55x7_tracedata_t data, uint8_t repeat ){
PrintAndLog("-- T55x7 Trace Information ----------------------------------");
PrintAndLog("-------------------------------------------------------------"); PrintAndLog("-------------------------------------------------------------");
PrintAndLog(" ACL Allocation class (ISO/IEC 15963-1) : 0x%02X (%d)", acl, acl); PrintAndLog(" ACL Allocation class (ISO/IEC 15963-1) : 0x%02X (%d)", data.acl, data.acl);
PrintAndLog(" MFC Manufacturer ID (ISO/IEC 7816-6) : 0x%02X (%d) - %s", mfc, mfc, getTagInfo(mfc)); PrintAndLog(" MFC Manufacturer ID (ISO/IEC 7816-6) : 0x%02X (%d) - %s", data.mfc, data.mfc, getTagInfo(data.mfc));
PrintAndLog(" CID : 0x%02X (%d) - %s", cid, cid, GetModelStrFromCID(cid)); PrintAndLog(" CID : 0x%02X (%d) - %s", data.cid, data.cid, GetModelStrFromCID(data.cid));
PrintAndLog(" ICR IC Revision : %d",icr ); PrintAndLog(" ICR IC Revision : %d", data.icr );
PrintAndLog(" Manufactured"); PrintAndLog(" Manufactured");
PrintAndLog(" Year/Quarter : %d/%d",year, quarter); PrintAndLog(" Year/Quarter : %d/%d", data.year, data.quarter);
PrintAndLog(" Lot ID : %d", lotid ); PrintAndLog(" Lot ID : %d", data.lotid );
PrintAndLog(" Wafer number : %d", wafer); PrintAndLog(" Wafer number : %d", data.wafer);
PrintAndLog(" Die Number : %d", dw); PrintAndLog(" Die Number : %d", data.dw);
PrintAndLog("-------------------------------------------------------------"); PrintAndLog("-------------------------------------------------------------");
PrintAndLog(" Raw Data - Page 1"); PrintAndLog(" Raw Data - Page 1");
PrintAndLog(" Block 1 : 0x%08X %s", bl1, sprint_bin(DemodBuffer+config.offset+repeat,32) ); PrintAndLog(" Block 1 : 0x%08X %s", data.bl1, sprint_bin(DemodBuffer+config.offset+repeat,32) );
PrintAndLog(" Block 2 : 0x%08X %s", bl2, sprint_bin(DemodBuffer+config.offset+repeat+32,32) ); PrintAndLog(" Block 2 : 0x%08X %s", data.bl2, sprint_bin(DemodBuffer+config.offset+repeat+32,32) );
PrintAndLog("-------------------------------------------------------------"); PrintAndLog("-------------------------------------------------------------");
/* /*
TRACE - BLOCK O TRACE - BLOCK O
@ -995,10 +1073,36 @@ int CmdT55xxReadTrace(const char *Cmd) {
13-17 Wafer number 13-17 Wafer number
18-32 DW, die number sequential 18-32 DW, die number sequential
*/ */
return 0;
} }
void printT5555Trace( t5555_tracedata_t data, uint8_t repeat ){
PrintAndLog("-- T5555 (Q5) Trace Information -----------------------------");
PrintAndLog("-------------------------------------------------------------");
PrintAndLog(" ICR IC Revision : %d", data.icr );
PrintAndLog(" Lot : %c%d", data.lotidc, data.lotid);
PrintAndLog(" Wafer number : %d", data.wafer);
PrintAndLog(" Die Number : %d", data.dw);
PrintAndLog("-------------------------------------------------------------");
PrintAndLog(" Raw Data - Page 1");
PrintAndLog(" Block 1 : 0x%08X %s", data.bl1, sprint_bin(DemodBuffer+config.offset+repeat,32) );
PrintAndLog(" Block 2 : 0x%08X %s", data.bl2, sprint_bin(DemodBuffer+config.offset+repeat+32,32) );
/*
** Q5 **
TRACE - BLOCK O and BLOCK1
Bits Definition HEX
1-9 Header 0x1FF
10-11 IC Revision
12-13 Lot ID char
15-35 Lot ID (NB parity)
36-41 Wafer number (NB parity)
42-58 DW, die number sequential (NB parity)
60-63 Parity bits
64 Always zero
*/
}
//need to add Q5 info...
int CmdT55xxInfo(const char *Cmd){ int CmdT55xxInfo(const char *Cmd){
/* /*
Page 0 Block 0 Configuration data. Page 0 Block 0 Configuration data.
@ -1018,6 +1122,7 @@ int CmdT55xxInfo(const char *Cmd){
if (!DecodeT55xxBlock()) return 1; if (!DecodeT55xxBlock()) return 1;
// too little space to start with
if ( DemodBufferLen < 32) return 1; if ( DemodBufferLen < 32) return 1;
uint8_t si = config.offset; uint8_t si = config.offset;
@ -1037,9 +1142,10 @@ int CmdT55xxInfo(const char *Cmd){
uint32_t fw = PackBits(si, 1, DemodBuffer); si += 1; uint32_t fw = PackBits(si, 1, DemodBuffer); si += 1;
uint32_t inv = PackBits(si, 1, DemodBuffer); si += 1; uint32_t inv = PackBits(si, 1, DemodBuffer); si += 1;
uint32_t por = PackBits(si, 1, DemodBuffer); si += 1; uint32_t por = PackBits(si, 1, DemodBuffer); si += 1;
if (config.Q5) PrintAndLog("*** Warning *** Config Info read off a Q5 will not display as expected"); if (config.Q5) PrintAndLog("*** Warning *** Config Info read off a Q5 will not display as expected");
PrintAndLog(""); PrintAndLog("");
PrintAndLog("-- T55xx Configuration & Tag Information --------------------"); PrintAndLog("-- T55x7 Configuration & Tag Information --------------------");
PrintAndLog("-------------------------------------------------------------"); PrintAndLog("-------------------------------------------------------------");
PrintAndLog(" Safer key : %s", GetSaferStr(safer)); PrintAndLog(" Safer key : %s", GetSaferStr(safer));
PrintAndLog(" reserved : %d", resv); PrintAndLog(" reserved : %d", resv);
@ -1109,44 +1215,25 @@ int AquireData( uint8_t page, uint8_t block, bool pwdmode, uint32_t password ){
return 1; return 1;
} }
char * GetBitRateStr(uint32_t id){ char * GetBitRateStr(uint32_t id) {
static char buf[25]; static char buf[25];
char *retStr = buf; char *retStr = buf;
switch (id){ switch (id) {
case 0: case 0: snprintf(retStr,sizeof(buf),"%d - RF/8",id); break;
snprintf(retStr,sizeof(buf),"%d - RF/8",id); case 1: snprintf(retStr,sizeof(buf),"%d - RF/16",id); break;
break; case 2: snprintf(retStr,sizeof(buf),"%d - RF/32",id); break;
case 1: case 3: snprintf(retStr,sizeof(buf),"%d - RF/40",id); break;
snprintf(retStr,sizeof(buf),"%d - RF/16",id); case 4: snprintf(retStr,sizeof(buf),"%d - RF/50",id); break;
break; case 5: snprintf(retStr,sizeof(buf),"%d - RF/64",id); break;
case 2: case 6: snprintf(retStr,sizeof(buf),"%d - RF/100",id); break;
snprintf(retStr,sizeof(buf),"%d - RF/32",id); case 7: snprintf(retStr,sizeof(buf),"%d - RF/128",id); break;
break; default: snprintf(retStr,sizeof(buf),"%d - (Unknown)",id); break;
case 3: }
snprintf(retStr,sizeof(buf),"%d - RF/40",id);
break;
case 4:
snprintf(retStr,sizeof(buf),"%d - RF/50",id);
break;
case 5:
snprintf(retStr,sizeof(buf),"%d - RF/64",id);
break;
case 6:
snprintf(retStr,sizeof(buf),"%d - RF/100",id);
break;
case 7:
snprintf(retStr,sizeof(buf),"%d - RF/128",id);
break;
default:
snprintf(retStr,sizeof(buf),"%d - (Unknown)",id);
break;
}
return buf; return buf;
} }
char * GetSaferStr(uint32_t id){ char * GetSaferStr(uint32_t id) {
static char buf[40]; static char buf[40];
char *retStr = buf; char *retStr = buf;
@ -1166,45 +1253,19 @@ char * GetModulationStr( uint32_t id){
char *retStr = buf; char *retStr = buf;
switch (id){ switch (id){
case 0: case 0: snprintf(retStr,sizeof(buf),"%d - DIRECT (ASK/NRZ)",id); break;
snprintf(retStr,sizeof(buf),"%d - DIRECT (ASK/NRZ)",id); case 1: snprintf(retStr,sizeof(buf),"%d - PSK 1 phase change when input changes",id); break;
break; case 2: snprintf(retStr,sizeof(buf),"%d - PSK 2 phase change on bitclk if input high",id); break;
case 1: case 3: snprintf(retStr,sizeof(buf),"%d - PSK 3 phase change on rising edge of input",id); break;
snprintf(retStr,sizeof(buf),"%d - PSK 1 phase change when input changes",id); case 4: snprintf(retStr,sizeof(buf),"%d - FSK 1 RF/8 RF/5",id); break;
break; case 5: snprintf(retStr,sizeof(buf),"%d - FSK 2 RF/8 RF/10",id); break;
case 2: case 6: snprintf(retStr,sizeof(buf),"%d - FSK 1a RF/5 RF/8",id); break;
snprintf(retStr,sizeof(buf),"%d - PSK 2 phase change on bitclk if input high",id); case 7: snprintf(retStr,sizeof(buf),"%d - FSK 2a RF/10 RF/8",id); break;
break; case 8: snprintf(retStr,sizeof(buf),"%d - Manchester",id); break;
case 3: case 16: snprintf(retStr,sizeof(buf),"%d - Biphase",id); break;
snprintf(retStr,sizeof(buf),"%d - PSK 3 phase change on rising edge of input",id); case 0x18: snprintf(retStr,sizeof(buf),"%d - Biphase a - AKA Conditional Dephase Encoding(CDP)",id); break;
break; case 17: snprintf(retStr,sizeof(buf),"%d - Reserved",id); break;
case 4: default: snprintf(retStr,sizeof(buf),"0x%02X (Unknown)",id); break;
snprintf(retStr,sizeof(buf),"%d - FSK 1 RF/8 RF/5",id);
break;
case 5:
snprintf(retStr,sizeof(buf),"%d - FSK 2 RF/8 RF/10",id);
break;
case 6:
snprintf(retStr,sizeof(buf),"%d - FSK 1a RF/5 RF/8",id);
break;
case 7:
snprintf(retStr,sizeof(buf),"%d - FSK 2a RF/10 RF/8",id);
break;
case 8:
snprintf(retStr,sizeof(buf),"%d - Manchester",id);
break;
case 16:
snprintf(retStr,sizeof(buf),"%d - Biphase",id);
break;
case 0x18:
snprintf(retStr,sizeof(buf),"%d - Biphase a - AKA Conditional Dephase Encoding(CDP)",id);
break;
case 17:
snprintf(retStr,sizeof(buf),"%d - Reserved",id);
break;
default:
snprintf(retStr,sizeof(buf),"0x%02X (Unknown)",id);
break;
} }
return buf; return buf;
} }
@ -1224,47 +1285,21 @@ char * GetSelectedModulationStr( uint8_t id){
static char buf[20]; static char buf[20];
char *retStr = buf; char *retStr = buf;
switch (id){ switch (id) {
case DEMOD_FSK: case DEMOD_FSK: snprintf(retStr,sizeof(buf),"FSK"); break;
snprintf(retStr,sizeof(buf),"FSK"); case DEMOD_FSK1: snprintf(retStr,sizeof(buf),"FSK1"); break;
break; case DEMOD_FSK1a: snprintf(retStr,sizeof(buf),"FSK1a"); break;
case DEMOD_FSK1: case DEMOD_FSK2: snprintf(retStr,sizeof(buf),"FSK2"); break;
snprintf(retStr,sizeof(buf),"FSK1"); case DEMOD_FSK2a: snprintf(retStr,sizeof(buf),"FSK2a"); break;
break; case DEMOD_ASK: snprintf(retStr,sizeof(buf),"ASK"); break;
case DEMOD_FSK1a: case DEMOD_NRZ: snprintf(retStr,sizeof(buf),"DIRECT/NRZ"); break;
snprintf(retStr,sizeof(buf),"FSK1a"); case DEMOD_PSK1: snprintf(retStr,sizeof(buf),"PSK1"); break;
break; case DEMOD_PSK2: snprintf(retStr,sizeof(buf),"PSK2"); break;
case DEMOD_FSK2: case DEMOD_PSK3: snprintf(retStr,sizeof(buf),"PSK3"); break;
snprintf(retStr,sizeof(buf),"FSK2"); case DEMOD_BI: snprintf(retStr,sizeof(buf),"BIPHASE"); break;
break; case DEMOD_BIa: snprintf(retStr,sizeof(buf),"BIPHASEa - (CDP)"); break;
case DEMOD_FSK2a: default: snprintf(retStr,sizeof(buf),"(Unknown)"); break;
snprintf(retStr,sizeof(buf),"FSK2a"); }
break;
case DEMOD_ASK:
snprintf(retStr,sizeof(buf),"ASK");
break;
case DEMOD_NRZ:
snprintf(retStr,sizeof(buf),"DIRECT/NRZ");
break;
case DEMOD_PSK1:
snprintf(retStr,sizeof(buf),"PSK1");
break;
case DEMOD_PSK2:
snprintf(retStr,sizeof(buf),"PSK2");
break;
case DEMOD_PSK3:
snprintf(retStr,sizeof(buf),"PSK3");
break;
case DEMOD_BI:
snprintf(retStr,sizeof(buf),"BIPHASE");
break;
case DEMOD_BIa:
snprintf(retStr,sizeof(buf),"BIPHASEa - (CDP)");
break;
default:
snprintf(retStr,sizeof(buf),"(Unknown)");
break;
}
return buf; return buf;
} }
@ -1303,13 +1338,22 @@ int CmdT55xxWipe(const char *Cmd) {
char writeData[20] = {0}; char writeData[20] = {0};
char *ptrData = writeData; char *ptrData = writeData;
char cmdp = param_getchar(Cmd, 0);
if ( cmdp == 'h' || cmdp == 'H') return usage_t55xx_wipe();
bool Q5 = (cmdp == 'q' || cmdp == 'Q');
// Try with the default password to reset block 0
// With a pwd should work even if pwd bit not set
PrintAndLog("\nBeginning Wipe of a T55xx tag (assuming the tag is not password protected)\n"); PrintAndLog("\nBeginning Wipe of a T55xx tag (assuming the tag is not password protected)\n");
//try with the default password to reset block 0 (with a pwd should work even if pwd bit not set) if ( Q5 ){
snprintf(ptrData,sizeof(writeData),"b 0 d 00088040 p 0"); snprintf(ptrData,sizeof(writeData),"b 0 d 6001F004 p 0");
} else {
snprintf(ptrData,sizeof(writeData),"b 0 d 00088040 p 0");
}
if (!CmdT55xxWriteBlock(ptrData)) if (!CmdT55xxWriteBlock(ptrData)) PrintAndLog("Error writing blk 0");
PrintAndLog("Error writing blk 0");
for (uint8_t blk = 1; blk<8; blk++) { for (uint8_t blk = 1; blk<8; blk++) {
snprintf(ptrData,sizeof(writeData),"b %d d 0", blk); snprintf(ptrData,sizeof(writeData),"b %d d 0", blk);
@ -1353,7 +1397,7 @@ int CmdT55xxBruteForce(const char *Cmd) {
return 1; return 1;
} }
while( fgets(buf, sizeof(buf), f) ){ while( fgets(buf, sizeof(buf), f) ) {
if (strlen(buf) < 8 || buf[7] == '\n') continue; if (strlen(buf) < 8 || buf[7] == '\n') continue;
while (fgetc(f) != '\n' && !feof(f)) ; //goto next line while (fgetc(f) != '\n' && !feof(f)) ; //goto next line
@ -1361,7 +1405,7 @@ int CmdT55xxBruteForce(const char *Cmd) {
//The line start with # is comment, skip //The line start with # is comment, skip
if( buf[0]=='#' ) continue; if( buf[0]=='#' ) continue;
if (!isxdigit(buf[0])){ if (!isxdigit(buf[0])) {
PrintAndLog("File content error. '%s' must include 8 HEX symbols", buf); PrintAndLog("File content error. '%s' must include 8 HEX symbols", buf);
continue; continue;
} }
@ -1426,39 +1470,39 @@ int CmdT55xxBruteForce(const char *Cmd) {
// incremental pwd range search // incremental pwd range search
start_password = param_get32ex(Cmd, 0, 0, 16); start_password = param_get32ex(Cmd, 0, 0, 16);
end_password = param_get32ex(Cmd, 1, 0, 16); end_password = param_get32ex(Cmd, 1, 0, 16);
if ( start_password >= end_password ) return usage_t55xx_bruteforce(); if ( start_password >= end_password ) return usage_t55xx_bruteforce();
PrintAndLog("Search password range [%08X -> %08X]", start_password, end_password); PrintAndLog("Search password range [%08X -> %08X]", start_password, end_password);
uint32_t i = start_password; uint32_t i = start_password;
while ((!found) && (i <= end_password)){ while ((!found) && (i <= end_password)) {
printf("."); printf(".");
fflush(stdout); fflush(stdout);
if (ukbhit()) { if (ukbhit()) {
getchar(); getchar();
printf("\naborted via keyboard!\n"); printf("\naborted via keyboard!\n");
return 0; return 0;
} }
if (!AquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, TRUE, i)) { if (!AquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, TRUE, i)) {
PrintAndLog("Aquireing data from device failed. Quitting"); PrintAndLog("Aquireing data from device failed. Quitting");
return 0; return 0;
} }
found = tryDetectModulation(); found = tryDetectModulation();
if (found) break; if (found) break;
i++; i++;
} }
PrintAndLog(""); PrintAndLog("");
if (found) if (found)
PrintAndLog("Found valid password: [%08x]", i); PrintAndLog("Found valid password: [%08x]", i);
else else
PrintAndLog("Password NOT found. Last tried: [%08x]", --i); PrintAndLog("Password NOT found. Last tried: [%08x]", --i);
return 0; return 0;
} }
@ -1475,7 +1519,7 @@ static command_t CommandTable[] = {
{"dump", CmdT55xxDump, 0, "[password] [o] Dump T55xx card block 0-7. Optional [password], [override]"}, {"dump", CmdT55xxDump, 0, "[password] [o] Dump T55xx card block 0-7. Optional [password], [override]"},
{"special", special, 0, "Show block changes with 64 different offsets"}, {"special", special, 0, "Show block changes with 64 different offsets"},
{"wakeup", CmdT55xxWakeUp, 0, "Send AOR wakeup command"}, {"wakeup", CmdT55xxWakeUp, 0, "Send AOR wakeup command"},
{"wipe", CmdT55xxWipe, 0, "Wipe a T55xx tag and set defaults (will destroy any data on tag)"}, {"wipe", CmdT55xxWipe, 0, "[q] Wipe a T55xx tag and set defaults (will destroy any data on tag)"},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };

28
client/cmdlft55xx.h
View file

@ -10,6 +10,30 @@
#ifndef CMDLFT55XX_H__ #ifndef CMDLFT55XX_H__
#define CMDLFT55XX_H__ #define CMDLFT55XX_H__
typedef struct {
uint32_t bl1;
uint32_t bl2;
uint32_t acl;
uint32_t mfc;
uint32_t cid;
uint32_t year;
uint32_t quarter;
uint32_t icr;
uint32_t lotid;
uint32_t wafer;
uint32_t dw;
} t55x7_tracedata_t;
typedef struct {
uint32_t bl1;
uint32_t bl2;
uint32_t icr;
char lotidc;
uint32_t lotid;
uint32_t wafer;
uint32_t dw;
} t5555_tracedata_t;
typedef struct { typedef struct {
enum { enum {
DEMOD_NRZ = 0x00, DEMOD_NRZ = 0x00,
@ -61,6 +85,7 @@ char * GetModulationStr( uint32_t id);
char * GetModelStrFromCID(uint32_t cid); char * GetModelStrFromCID(uint32_t cid);
char * GetSelectedModulationStr( uint8_t id); char * GetSelectedModulationStr( uint8_t id);
uint32_t PackBits(uint8_t start, uint8_t len, uint8_t *bitstream); uint32_t PackBits(uint8_t start, uint8_t len, uint8_t *bitstream);
void printT5xxHeader(uint8_t page);
void printT55xxBlock(const char *demodStr); void printT55xxBlock(const char *demodStr);
int printConfiguration( t55xx_conf_block_t b); int printConfiguration( t55xx_conf_block_t b);
@ -70,4 +95,7 @@ bool test(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk, bool *Q5)
int special(const char *Cmd); int special(const char *Cmd);
int AquireData( uint8_t page, uint8_t block, bool pwdmode, uint32_t password ); int AquireData( uint8_t page, uint8_t block, bool pwdmode, uint32_t password );
void printT55x7Trace( t55x7_tracedata_t data, uint8_t repeat );
void printT5555Trace( t5555_tracedata_t data, uint8_t repeat );
#endif #endif

2
client/loclass/cipherutils.c
View file

@ -171,6 +171,7 @@ void printarr(char * name, uint8_t* arr, int len)
} }
cx += snprintf(output+cx,outsize-cx,"};"); cx += snprintf(output+cx,outsize-cx,"};");
prnlog(output); prnlog(output);
free(output);
} }
void printvar(char * name, uint8_t* arr, int len) void printvar(char * name, uint8_t* arr, int len)
@ -188,6 +189,7 @@ void printvar(char * name, uint8_t* arr, int len)
} }
prnlog(output); prnlog(output);
free(output);
} }
void printarr_human_readable(char * title, uint8_t* arr, int len) void printarr_human_readable(char * title, uint8_t* arr, int len)

14
client/util.c
View file

@ -142,7 +142,7 @@ char *sprint_bin_break(const uint8_t *data, const size_t len, const uint8_t brea
for (size_t out_index=0; out_index < max_len; out_index++) { for (size_t out_index=0; out_index < max_len; out_index++) {
// set character // set character
sprintf(tmp++, "%u", data[in_index]); sprintf(tmp++, "%u", data[in_index]);
// check if a line break is needed // check if a line break is needed and we have room to print it in our array
if ( (breaks > 0) && !((in_index+1) % breaks) && (out_index+1 != max_len) ) { if ( (breaks > 0) && !((in_index+1) % breaks) && (out_index+1 != max_len) ) {
// increment and print line break // increment and print line break
out_index++; out_index++;
@ -271,7 +271,7 @@ char param_getchar(const char *line, int paramnum)
uint8_t param_get8(const char *line, int paramnum) uint8_t param_get8(const char *line, int paramnum)
{ {
return param_get8ex(line, paramnum, 10, 0); return param_get8ex(line, paramnum, 0, 10);
} }
/** /**
@ -497,3 +497,13 @@ void xor(unsigned char *dst, unsigned char *src, size_t len) {
int32_t le24toh (uint8_t data[3]) { int32_t le24toh (uint8_t data[3]) {
return (data[2] << 16) | (data[1] << 8) | data[0]; return (data[2] << 16) | (data[1] << 8) | data[0];
} }
// RotateLeft - Ultralight, Desfire, works on byte level
// 00-01-02 >> 01-02-00
void rol(uint8_t *data, const size_t len){
uint8_t first = data[0];
for (size_t i = 0; i < len-1; i++) {
data[i] = data[i+1];
}
data[len-1] = first;
}

4
client/util.h
View file

@ -17,6 +17,9 @@
#include <time.h> #include <time.h>
#include "data.h" #include "data.h"
#ifndef ROTR
# define ROTR(x,n) (((uintmax_t)(x) >> (n)) | ((uintmax_t)(x) << ((sizeof(x) * 8) - (n))))
#endif
#ifndef MIN #ifndef MIN
# define MIN(a, b) (((a) < (b)) ? (a) : (b)) # define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif #endif
@ -68,3 +71,4 @@ void wiegand_add_parity(uint8_t *target, uint8_t *source, uint8_t length);
void xor(unsigned char *dst, unsigned char *src, size_t len); void xor(unsigned char *dst, unsigned char *src, size_t len);
int32_t le24toh(uint8_t data[3]); int32_t le24toh(uint8_t data[3]);
void rol(uint8_t *data, const size_t len);