mirror of
https://github.com/Proxmark/proxmark3.git
synced 2024-09-21 15:26:35 +08:00
commit
4c6f2d48fb
|
@ -419,7 +419,7 @@ int EPA_Setup()
|
|||
// return code
|
||||
int return_code = 0;
|
||||
// card UID
|
||||
uint8_t uid[8];
|
||||
uint8_t uid[10];
|
||||
// card select information
|
||||
iso14a_card_select_t card_select_info;
|
||||
// power up the field
|
||||
|
|
|
@ -1140,7 +1140,7 @@ void ReaderHitag(hitag_function htf, hitag_data* htd) {
|
|||
case RHT2F_PASSWORD: {
|
||||
Dbprintf("List identifier in password mode");
|
||||
memcpy(password,htd->pwd.password,4);
|
||||
blocknr = 0;
|
||||
blocknr = 0;
|
||||
bQuitTraceFull = false;
|
||||
bQuiet = false;
|
||||
bPwd = false;
|
||||
|
@ -1158,7 +1158,7 @@ void ReaderHitag(hitag_function htf, hitag_data* htd) {
|
|||
|
||||
case RHT2F_CRYPTO: {
|
||||
DbpString("Authenticating using key:");
|
||||
memcpy(key,htd->crypto.key,6);
|
||||
memcpy(key,htd->crypto.key,4);
|
||||
Dbhexdump(6,key,false);
|
||||
blocknr = 0;
|
||||
bQuiet = false;
|
||||
|
|
|
@ -1295,20 +1295,23 @@ static void TransmitIClassCommand(const uint8_t *cmd, int len, int *samples, int
|
|||
FpgaSetupSsc();
|
||||
|
||||
if (wait)
|
||||
if(*wait < 10)
|
||||
*wait = 10;
|
||||
{
|
||||
if(*wait < 10) *wait = 10;
|
||||
|
||||
for(c = 0; c < *wait;) {
|
||||
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();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
for(c = 0; c < *wait;) {
|
||||
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;
|
||||
bool firstpart = TRUE;
|
||||
|
|
|
@ -1726,7 +1726,13 @@ int iso14443a_select_card(byte_t* uid_ptr, iso14a_card_select_t* p_hi14a_card, u
|
|||
if ((sak & 0x04) /* && uid_resp[0] == 0x88 */) {
|
||||
// Remove first byte, 0x88 is not an UID byte, it CT, see page 3 of:
|
||||
// http://www.nxp.com/documents/application_note/AN10927.pdf
|
||||
memcpy(uid_resp, uid_resp + 1, 3);
|
||||
// This was earlier:
|
||||
//memcpy(uid_resp, uid_resp + 1, 3);
|
||||
// But memcpy should not be used for overlapping arrays,
|
||||
// and memmove appears to not be available in the arm build.
|
||||
// So this has been replaced with a for-loop:
|
||||
for(int xx = 0; xx < 3; xx++) uid_resp[xx] = uid_resp[xx+1];
|
||||
|
||||
uid_resp_len = 3;
|
||||
}
|
||||
|
||||
|
@ -1936,7 +1942,8 @@ void ReaderMifare(bool first_try)
|
|||
uint8_t uid[10];
|
||||
uint32_t cuid;
|
||||
|
||||
uint32_t nt, previous_nt;
|
||||
uint32_t nt =0 ;
|
||||
uint32_t previous_nt = 0;
|
||||
static uint32_t nt_attacked = 0;
|
||||
byte_t par_list[8] = {0,0,0,0,0,0,0,0};
|
||||
byte_t ks_list[8] = {0,0,0,0,0,0,0,0};
|
||||
|
|
147
armsrc/lfops.c
147
armsrc/lfops.c
|
@ -1456,78 +1456,81 @@ int DemodPCF7931(uint8_t **outBlocks) {
|
|||
|
||||
for (bitidx = 0; i < GraphTraceLen; i++)
|
||||
{
|
||||
if ( (GraphBuffer[i-1] > GraphBuffer[i] && dir == 1 && GraphBuffer[i] > lmax) || (GraphBuffer[i-1] < GraphBuffer[i] && dir == 0 && GraphBuffer[i] < lmin))
|
||||
{
|
||||
lc = i - lastval;
|
||||
lastval = i;
|
||||
|
||||
// Switch depending on lc length:
|
||||
// Tolerance is 1/8 of clock rate (arbitrary)
|
||||
if (abs(lc-clock/4) < tolerance) {
|
||||
// 16T0
|
||||
if((i - pmc) == lc) { /* 16T0 was previous one */
|
||||
/* It's a PMC ! */
|
||||
i += (128+127+16+32+33+16)-1;
|
||||
lastval = i;
|
||||
pmc = 0;
|
||||
block_done = 1;
|
||||
}
|
||||
else {
|
||||
pmc = i;
|
||||
}
|
||||
} else if (abs(lc-clock/2) < tolerance) {
|
||||
// 32TO
|
||||
if((i - pmc) == lc) { /* 16T0 was previous one */
|
||||
/* It's a PMC ! */
|
||||
i += (128+127+16+32+33)-1;
|
||||
lastval = i;
|
||||
pmc = 0;
|
||||
block_done = 1;
|
||||
}
|
||||
else if(half_switch == 1) {
|
||||
BitStream[bitidx++] = 0;
|
||||
half_switch = 0;
|
||||
}
|
||||
else
|
||||
half_switch++;
|
||||
} else if (abs(lc-clock) < tolerance) {
|
||||
// 64TO
|
||||
BitStream[bitidx++] = 1;
|
||||
} else {
|
||||
// Error
|
||||
warnings++;
|
||||
if (warnings > 10)
|
||||
{
|
||||
Dbprintf("Error: too many detection errors, aborting.");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if(block_done == 1) {
|
||||
if(bitidx == 128) {
|
||||
for(j=0; j<16; j++) {
|
||||
Blocks[num_blocks][j] = 128*BitStream[j*8+7]+
|
||||
64*BitStream[j*8+6]+
|
||||
32*BitStream[j*8+5]+
|
||||
16*BitStream[j*8+4]+
|
||||
8*BitStream[j*8+3]+
|
||||
4*BitStream[j*8+2]+
|
||||
2*BitStream[j*8+1]+
|
||||
BitStream[j*8];
|
||||
}
|
||||
num_blocks++;
|
||||
}
|
||||
bitidx = 0;
|
||||
block_done = 0;
|
||||
half_switch = 0;
|
||||
}
|
||||
if (GraphBuffer[i-1] > GraphBuffer[i]) dir=0;
|
||||
else dir = 1;
|
||||
}
|
||||
if(bitidx==255)
|
||||
bitidx=0;
|
||||
warnings = 0;
|
||||
if(num_blocks == 4) break;
|
||||
if ( (GraphBuffer[i-1] > GraphBuffer[i] && dir == 1 && GraphBuffer[i] > lmax) || (GraphBuffer[i-1] < GraphBuffer[i] && dir == 0 && GraphBuffer[i] < lmin))
|
||||
{
|
||||
lc = i - lastval;
|
||||
lastval = i;
|
||||
|
||||
// Switch depending on lc length:
|
||||
// Tolerance is 1/8 of clock rate (arbitrary)
|
||||
if (abs(lc-clock/4) < tolerance) {
|
||||
// 16T0
|
||||
if((i - pmc) == lc) { /* 16T0 was previous one */
|
||||
/* It's a PMC ! */
|
||||
i += (128+127+16+32+33+16)-1;
|
||||
lastval = i;
|
||||
pmc = 0;
|
||||
block_done = 1;
|
||||
}
|
||||
else {
|
||||
pmc = i;
|
||||
}
|
||||
} else if (abs(lc-clock/2) < tolerance) {
|
||||
// 32TO
|
||||
if((i - pmc) == lc) { /* 16T0 was previous one */
|
||||
/* It's a PMC ! */
|
||||
i += (128+127+16+32+33)-1;
|
||||
lastval = i;
|
||||
pmc = 0;
|
||||
block_done = 1;
|
||||
}
|
||||
else if(half_switch == 1) {
|
||||
BitStream[bitidx++] = 0;
|
||||
half_switch = 0;
|
||||
}
|
||||
else
|
||||
half_switch++;
|
||||
} else if (abs(lc-clock) < tolerance) {
|
||||
// 64TO
|
||||
BitStream[bitidx++] = 1;
|
||||
} else {
|
||||
// Error
|
||||
warnings++;
|
||||
if (warnings > 10)
|
||||
{
|
||||
Dbprintf("Error: too many detection errors, aborting.");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if(block_done == 1) {
|
||||
if(bitidx == 128) {
|
||||
for(j=0; j<16; j++) {
|
||||
Blocks[num_blocks][j] = 128*BitStream[j*8+7]+
|
||||
64*BitStream[j*8+6]+
|
||||
32*BitStream[j*8+5]+
|
||||
16*BitStream[j*8+4]+
|
||||
8*BitStream[j*8+3]+
|
||||
4*BitStream[j*8+2]+
|
||||
2*BitStream[j*8+1]+
|
||||
BitStream[j*8];
|
||||
}
|
||||
num_blocks++;
|
||||
}
|
||||
bitidx = 0;
|
||||
block_done = 0;
|
||||
half_switch = 0;
|
||||
}
|
||||
if(i < GraphTraceLen)
|
||||
{
|
||||
if (GraphBuffer[i-1] > GraphBuffer[i]) dir=0;
|
||||
else dir = 1;
|
||||
}
|
||||
}
|
||||
if(bitidx==255)
|
||||
bitidx=0;
|
||||
warnings = 0;
|
||||
if(num_blocks == 4) break;
|
||||
}
|
||||
memcpy(outBlocks, Blocks, 16*num_blocks);
|
||||
return num_blocks;
|
||||
|
|
|
@ -225,7 +225,7 @@ void FormatVersionInformation(char *dst, int len, const char *prefix, void *vers
|
|||
{
|
||||
struct version_information *v = (struct version_information*)version_information;
|
||||
dst[0] = 0;
|
||||
strncat(dst, prefix, len);
|
||||
strncat(dst, prefix, len-1);
|
||||
if(v->magic != VERSION_INFORMATION_MAGIC) {
|
||||
strncat(dst, "Missing/Invalid version information", len - strlen(dst) - 1);
|
||||
return;
|
||||
|
|
|
@ -556,7 +556,7 @@ int CmdManchesterDemod(const char *Cmd)
|
|||
|
||||
/* But it does not work if compiling on WIndows: therefore we just allocate a */
|
||||
/* large array */
|
||||
uint8_t BitStream[MAX_GRAPH_TRACE_LEN];
|
||||
uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0};
|
||||
|
||||
/* Detect high and lows */
|
||||
for (i = 0; i < GraphTraceLen; i++)
|
||||
|
|
|
@ -535,7 +535,8 @@ int CmdHF15CmdRaw (const char *cmd) {
|
|||
*/
|
||||
int prepareHF15Cmd(char **cmd, UsbCommand *c, uint8_t iso15cmd[], int iso15cmdlen) {
|
||||
int temp;
|
||||
uint8_t *req=c->d.asBytes, uid[8];
|
||||
uint8_t *req=c->d.asBytes;
|
||||
uint8_t uid[8] = {0};
|
||||
uint32_t reqlen=0;
|
||||
|
||||
// strip
|
||||
|
|
|
@ -502,6 +502,8 @@ int CmdHFiClassReader_Dump(const char *Cmd)
|
|||
SendCommand(&c);
|
||||
|
||||
UsbCommand resp;
|
||||
uint8_t key_sel[8] = {0};
|
||||
uint8_t key_sel_p[8] = { 0 };
|
||||
|
||||
if (WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
|
||||
uint8_t isOK = resp.arg[0] & 0xff;
|
||||
|
@ -520,8 +522,6 @@ int CmdHFiClassReader_Dump(const char *Cmd)
|
|||
{
|
||||
if(elite)
|
||||
{
|
||||
uint8_t key_sel[8] = {0};
|
||||
uint8_t key_sel_p[8] = { 0 };
|
||||
//Get the key index (hash1)
|
||||
uint8_t key_index[8] = {0};
|
||||
|
||||
|
|
112
client/cmdhfmf.c
112
client/cmdhfmf.c
|
@ -343,10 +343,6 @@ int CmdHF14AMfURdCard(const char *Cmd)
|
|||
uint8_t isOK = 0;
|
||||
uint8_t * data = NULL;
|
||||
|
||||
if (sectorNo > 15) {
|
||||
PrintAndLog("Sector number must be less than 16");
|
||||
return 1;
|
||||
}
|
||||
PrintAndLog("Attempting to Read Ultralight... ");
|
||||
|
||||
UsbCommand c = {CMD_MIFAREU_READCARD, {sectorNo}};
|
||||
|
@ -359,64 +355,24 @@ int CmdHF14AMfURdCard(const char *Cmd)
|
|||
|
||||
PrintAndLog("isOk:%02x", isOK);
|
||||
if (isOK)
|
||||
for (i = 0; i < 16; i++) {
|
||||
switch(i){
|
||||
case 2:
|
||||
//process lock bytes
|
||||
lockbytes_t=data+(i*4);
|
||||
lockbytes[0]=lockbytes_t[2];
|
||||
lockbytes[1]=lockbytes_t[3];
|
||||
for(int j=0; j<16; j++){
|
||||
bit[j]=lockbytes[j/8] & ( 1 <<(7-j%8));
|
||||
}
|
||||
//PrintAndLog("LB %02x %02x", lockbytes[0],lockbytes[1]);
|
||||
//PrintAndLog("LB2b %02x %02x %02x %02x %02x %02x %02x %02x",bit[8],bit[9],bit[10],bit[11],bit[12],bit[13],bit[14],bit[15]);
|
||||
PrintAndLog("Block %3d:%s ", i,sprint_hex(data + i * 4, 4));
|
||||
break;
|
||||
case 3:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[4]);
|
||||
break;
|
||||
case 4:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[3]);
|
||||
break;
|
||||
case 5:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[2]);
|
||||
break;
|
||||
case 6:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[1]);
|
||||
break;
|
||||
case 7:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[0]);
|
||||
break;
|
||||
case 8:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[15]);
|
||||
break;
|
||||
case 9:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[14]);
|
||||
break;
|
||||
case 10:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[13]);
|
||||
break;
|
||||
case 11:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[12]);
|
||||
break;
|
||||
case 12:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[11]);
|
||||
break;
|
||||
case 13:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[10]);
|
||||
break;
|
||||
case 14:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[9]);
|
||||
break;
|
||||
case 15:
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[8]);
|
||||
break;
|
||||
default:
|
||||
PrintAndLog("Block %3d:%s ", i,sprint_hex(data + i * 4, 4));
|
||||
break;
|
||||
{ // bit 0 and 1
|
||||
PrintAndLog("Block %3d:%s ", 0,sprint_hex(data + 0 * 4, 4));
|
||||
PrintAndLog("Block %3d:%s ", 1,sprint_hex(data + 1 * 4, 4));
|
||||
// bit 2
|
||||
//process lock bytes
|
||||
lockbytes_t=data+(2*4);
|
||||
lockbytes[0]=lockbytes_t[2];
|
||||
lockbytes[1]=lockbytes_t[3];
|
||||
for(int j=0; j<16; j++){
|
||||
bit[j]=lockbytes[j/8] & ( 1 <<(7-j%8));
|
||||
}
|
||||
}
|
||||
//remaining
|
||||
for (i = 3; i < 16; i++) {
|
||||
int bitnum = (23-i) % 16;
|
||||
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[bitnum]);
|
||||
}
|
||||
|
||||
}
|
||||
} else {
|
||||
PrintAndLog("Command execute timeout");
|
||||
}
|
||||
|
@ -546,6 +502,7 @@ int CmdHF14AMfDump(const char *Cmd)
|
|||
for (sectorNo=0; sectorNo<numSectors; sectorNo++) {
|
||||
if (fread( keyA[sectorNo], 1, 6, fin ) == 0) {
|
||||
PrintAndLog("File reading error.");
|
||||
fclose(fin);
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
|
@ -553,10 +510,11 @@ int CmdHF14AMfDump(const char *Cmd)
|
|||
for (sectorNo=0; sectorNo<numSectors; sectorNo++) {
|
||||
if (fread( keyB[sectorNo], 1, 6, fin ) == 0) {
|
||||
PrintAndLog("File reading error.");
|
||||
fclose(fin);
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
|
||||
fclose(fin);
|
||||
// Read access rights to sectors
|
||||
|
||||
PrintAndLog("|-----------------------------------------|");
|
||||
|
@ -666,7 +624,6 @@ int CmdHF14AMfDump(const char *Cmd)
|
|||
PrintAndLog("Dumped %d blocks (%d bytes) to file dumpdata.bin", numblocks, 16*numblocks);
|
||||
}
|
||||
|
||||
fclose(fin);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -1004,6 +961,16 @@ int CmdHF14AMfNested(const char *Cmd)
|
|||
|
||||
int CmdHF14AMfChk(const char *Cmd)
|
||||
{
|
||||
if (strlen(Cmd)<3) {
|
||||
PrintAndLog("Usage: hf mf chk <block number>|<*card memory> <key type (A/B/?)> [t] [<key (12 hex symbols)>] [<dic (*.dic)>]");
|
||||
PrintAndLog(" * - all sectors");
|
||||
PrintAndLog("card memory - 0 - MINI(320 bytes), 1 - 1K, 2 - 2K, 4 - 4K, <other> - 1K");
|
||||
PrintAndLog("d - write keys to binary file\n");
|
||||
PrintAndLog(" sample: hf mf chk 0 A 1234567890ab keys.dic");
|
||||
PrintAndLog(" hf mf chk *1 ? t");
|
||||
return 0;
|
||||
}
|
||||
|
||||
FILE * f;
|
||||
char filename[256]={0};
|
||||
char buf[13];
|
||||
|
@ -1021,6 +988,7 @@ int CmdHF14AMfChk(const char *Cmd)
|
|||
int transferToEml = 0;
|
||||
int createDumpFile = 0;
|
||||
|
||||
|
||||
keyBlock = calloc(stKeyBlock, 6);
|
||||
if (keyBlock == NULL) return 1;
|
||||
|
||||
|
@ -1047,15 +1015,6 @@ int CmdHF14AMfChk(const char *Cmd)
|
|||
num_to_bytes(defaultKeys[defaultKeyCounter], 6, (uint8_t*)(keyBlock + defaultKeyCounter * 6));
|
||||
}
|
||||
|
||||
if (strlen(Cmd)<3) {
|
||||
PrintAndLog("Usage: hf mf chk <block number>|<*card memory> <key type (A/B/?)> [t] [<key (12 hex symbols)>] [<dic (*.dic)>]");
|
||||
PrintAndLog(" * - all sectors");
|
||||
PrintAndLog("card memory - 0 - MINI(320 bytes), 1 - 1K, 2 - 2K, 4 - 4K, <other> - 1K");
|
||||
PrintAndLog("d - write keys to binary file\n");
|
||||
PrintAndLog(" sample: hf mf chk 0 A 1234567890ab keys.dic");
|
||||
PrintAndLog(" hf mf chk *1 ? t");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (param_getchar(Cmd, 0)=='*') {
|
||||
blockNo = 3;
|
||||
|
@ -1144,11 +1103,11 @@ int CmdHF14AMfChk(const char *Cmd)
|
|||
keycnt++;
|
||||
memset(buf, 0, sizeof(buf));
|
||||
}
|
||||
fclose(f);
|
||||
} else {
|
||||
PrintAndLog("File: %s: not found or locked.", filename);
|
||||
free(keyBlock);
|
||||
return 1;
|
||||
fclose(f);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1430,12 +1389,14 @@ int CmdHF14AMfELoad(const char *Cmd)
|
|||
break;
|
||||
}
|
||||
PrintAndLog("File reading error.");
|
||||
fclose(f);
|
||||
return 2;
|
||||
}
|
||||
if (strlen(buf) < 32){
|
||||
if(strlen(buf) && feof(f))
|
||||
break;
|
||||
PrintAndLog("File content error. Block data must include 32 HEX symbols");
|
||||
fclose(f);
|
||||
return 2;
|
||||
}
|
||||
for (i = 0; i < 32; i += 2) {
|
||||
|
@ -1444,6 +1405,7 @@ int CmdHF14AMfELoad(const char *Cmd)
|
|||
}
|
||||
if (mfEmlSetMem(buf8, blockNum, 1)) {
|
||||
PrintAndLog("Cant set emul block: %3d", blockNum);
|
||||
fclose(f);
|
||||
return 3;
|
||||
}
|
||||
blockNum++;
|
||||
|
@ -1586,8 +1548,8 @@ int CmdHF14AMfEKeyPrn(const char *Cmd)
|
|||
int CmdHF14AMfCSetUID(const char *Cmd)
|
||||
{
|
||||
uint8_t wipeCard = 0;
|
||||
uint8_t uid[8];
|
||||
uint8_t oldUid[8];
|
||||
uint8_t uid[8] = {0};
|
||||
uint8_t oldUid[8]= {0};
|
||||
int res;
|
||||
|
||||
if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {
|
||||
|
|
|
@ -319,7 +319,7 @@ int CmdEM4x50Read(const char *Cmd)
|
|||
++i;
|
||||
while ((GraphBuffer[i] > low) && (i<GraphTraceLen))
|
||||
++i;
|
||||
if (j>(MAX_GRAPH_TRACE_LEN/64)) {
|
||||
if (j>=(MAX_GRAPH_TRACE_LEN/64)) {
|
||||
break;
|
||||
}
|
||||
tmpbuff[j++]= i - start;
|
||||
|
|
|
@ -41,9 +41,6 @@ int CmdLFHitagList(const char *Cmd)
|
|||
int i = 0;
|
||||
int prev = -1;
|
||||
|
||||
char filename[256];
|
||||
FILE* pf = NULL;
|
||||
|
||||
for (;;) {
|
||||
if(i >= 1900) {
|
||||
break;
|
||||
|
@ -107,23 +104,19 @@ int CmdLFHitagList(const char *Cmd)
|
|||
line);
|
||||
|
||||
|
||||
if (pf) {
|
||||
fprintf(pf," +%7d: %3d: %s %s\n",
|
||||
(prev < 0 ? 0 : (timestamp - prev)),
|
||||
bits,
|
||||
(isResponse ? "TAG" : " "),
|
||||
line);
|
||||
}
|
||||
// if (pf) {
|
||||
// fprintf(pf," +%7d: %3d: %s %s\n",
|
||||
// (prev < 0 ? 0 : (timestamp - prev)),
|
||||
// bits,
|
||||
// (isResponse ? "TAG" : " "),
|
||||
// line);
|
||||
// }
|
||||
|
||||
prev = timestamp;
|
||||
i += (len + 9);
|
||||
}
|
||||
|
||||
if (pf) {
|
||||
PrintAndLog("Recorded activity succesfully written to file: %s", filename);
|
||||
fclose(pf);
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -149,6 +142,7 @@ int CmdLFHitagSim(const char *Cmd) {
|
|||
tag_mem_supplied = true;
|
||||
if (fread(c.d.asBytes,48,1,pf) == 0) {
|
||||
PrintAndLog("Error: File reading error");
|
||||
fclose(pf);
|
||||
return 1;
|
||||
}
|
||||
fclose(pf);
|
||||
|
|
|
@ -134,8 +134,9 @@ int getCommand(UsbCommand* response)
|
|||
*/
|
||||
bool WaitForResponseTimeout(uint32_t cmd, UsbCommand* response, size_t ms_timeout) {
|
||||
|
||||
UsbCommand resp;
|
||||
|
||||
if (response == NULL) {
|
||||
UsbCommand resp;
|
||||
response = &resp;
|
||||
}
|
||||
|
||||
|
|
|
@ -727,13 +727,17 @@ int readKeyFile(uint8_t key[8])
|
|||
{
|
||||
|
||||
FILE *f;
|
||||
|
||||
int retval = 1;
|
||||
f = fopen("iclass_key.bin", "rb");
|
||||
if (f)
|
||||
{
|
||||
if(fread(key, sizeof(key), 1, f) == 1) return 0;
|
||||
if(fread(key, sizeof(uint8_t), 8, f) == 1)
|
||||
{
|
||||
retval = 0;
|
||||
}
|
||||
fclose(f);
|
||||
}
|
||||
return 1;
|
||||
return retval;
|
||||
|
||||
}
|
||||
|
||||
|
|
|
@ -296,7 +296,7 @@ static uint8_t trailerAccessBytes[4] = {0x08, 0x77, 0x8F, 0x00};
|
|||
// variables
|
||||
char logHexFileName[200] = {0x00};
|
||||
static uint8_t traceCard[4096] = {0x00};
|
||||
static char traceFileName[20];
|
||||
static char traceFileName[200] = {0};
|
||||
static int traceState = TRACE_IDLE;
|
||||
static uint8_t traceCurBlock = 0;
|
||||
static uint8_t traceCurKey = 0;
|
||||
|
@ -497,7 +497,7 @@ int mfTraceDecode(uint8_t *data_src, int len, uint32_t parity, bool wantSaveToEm
|
|||
break;
|
||||
|
||||
case TRACE_WRITE_OK:
|
||||
if ((len == 1) && (data[0] = 0x0a)) {
|
||||
if ((len == 1) && (data[0] == 0x0a)) {
|
||||
traceState = TRACE_WRITE_DATA;
|
||||
|
||||
return 0;
|
||||
|
@ -555,23 +555,13 @@ int mfTraceDecode(uint8_t *data_src, int len, uint32_t parity, bool wantSaveToEm
|
|||
at_par = parity;
|
||||
|
||||
// decode key here)
|
||||
if (!traceCrypto1) {
|
||||
ks2 = ar_enc ^ prng_successor(nt, 64);
|
||||
ks3 = at_enc ^ prng_successor(nt, 96);
|
||||
revstate = lfsr_recovery64(ks2, ks3);
|
||||
lfsr_rollback_word(revstate, 0, 0);
|
||||
lfsr_rollback_word(revstate, 0, 0);
|
||||
lfsr_rollback_word(revstate, nr_enc, 1);
|
||||
lfsr_rollback_word(revstate, uid ^ nt, 0);
|
||||
}else{
|
||||
ks2 = ar_enc ^ prng_successor(nt, 64);
|
||||
ks3 = at_enc ^ prng_successor(nt, 96);
|
||||
revstate = lfsr_recovery64(ks2, ks3);
|
||||
lfsr_rollback_word(revstate, 0, 0);
|
||||
lfsr_rollback_word(revstate, 0, 0);
|
||||
lfsr_rollback_word(revstate, nr_enc, 1);
|
||||
lfsr_rollback_word(revstate, uid ^ nt, 0);
|
||||
}
|
||||
ks2 = ar_enc ^ prng_successor(nt, 64);
|
||||
ks3 = at_enc ^ prng_successor(nt, 96);
|
||||
revstate = lfsr_recovery64(ks2, ks3);
|
||||
lfsr_rollback_word(revstate, 0, 0);
|
||||
lfsr_rollback_word(revstate, 0, 0);
|
||||
lfsr_rollback_word(revstate, nr_enc, 1);
|
||||
lfsr_rollback_word(revstate, uid ^ nt, 0);
|
||||
crypto1_get_lfsr(revstate, &lfsr);
|
||||
printf("key> %x%x\n", (unsigned int)((lfsr & 0xFFFFFFFF00000000) >> 32), (unsigned int)(lfsr & 0xFFFFFFFF));
|
||||
AddLogUint64(logHexFileName, "key> ", lfsr);
|
||||
|
|
|
@ -544,8 +544,14 @@ lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8],
|
|||
|
||||
statelist = malloc((sizeof *statelist) << 21); //how large should be?
|
||||
if(!statelist || !odd || !even)
|
||||
{
|
||||
free(statelist);
|
||||
free(odd);
|
||||
free(even);
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
s = statelist;
|
||||
for(o = odd; *o != -1; ++o)
|
||||
for(e = even; *e != -1; ++e)
|
||||
|
|
Loading…
Reference in a new issue