github/RRG-Proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-08-21 05:43:48 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

make style

Browse source
This commit is contained in:
Philippe Teuwen 2020-01-15 19:26:12 +01:00
commit b57f40e3d7
2 changed files with 321 additions and 311 deletions
Download patch file Download diff file Expand all files Collapse all files

134
armsrc/hitag2.c
View file

@ -341,18 +341,18 @@ static void hitag_reader_send_frame(const uint8_t *frame, size_t frame_len) {
size_t blocknr; size_t blocknr;
uint8_t hitag_crc(uint8_t *data, size_t length){ uint8_t hitag_crc(uint8_t *data, size_t length) {
uint8_t crc = 0xff; uint8_t crc = 0xff;
unsigned int byte, bit; unsigned int byte, bit;
for(byte=0; byte<((length+7)/8); byte++){ for (byte = 0; byte < ((length + 7) / 8); byte++) {
crc ^= *(data + byte); crc ^= *(data + byte);
bit = length < (8*(byte+1)) ? (length % 8) : 8; bit = length < (8 * (byte + 1)) ? (length % 8) : 8;
while(bit--){ while (bit--) {
if(crc & 0x80){ if (crc & 0x80) {
crc<<=1; crc <<= 1;
crc ^= 0x1d; crc ^= 0x1d;
} else { } else {
crc<<=1; crc <<= 1;
} }
} }
} }
@ -363,21 +363,21 @@ uint8_t hitag_crc(uint8_t *data, size_t length){
#define set_bit(data, i) *(data+(i/8)) |= (1 << (7-(i%8))) #define set_bit(data, i) *(data+(i/8)) |= (1 << (7-(i%8)))
#define clear_bit(data, i) *(data+(i/8)) &= ~(1 << (7-(i%8))) #define clear_bit(data, i) *(data+(i/8)) &= ~(1 << (7-(i%8)))
#define flip_bit(data, i) *(data+(i/8)) ^= (1 << (7-(i%8))) #define flip_bit(data, i) *(data+(i/8)) ^= (1 << (7-(i%8)))
void fix_ac_decoding(uint8_t *input, size_t len){ void fix_ac_decoding(uint8_t *input, size_t len) {
// Reader routine tries to decode AC data after Manchester decoding // Reader routine tries to decode AC data after Manchester decoding
// AC has double the bitrate, extract data from bit-pairs // AC has double the bitrate, extract data from bit-pairs
uint8_t temp[len / 16]; uint8_t temp[len / 16];
memset(temp, 0, sizeof(temp)); memset(temp, 0, sizeof(temp));
for (size_t i = 1; i < len; i += 2) { for (size_t i = 1; i < len; i += 2) {
if (test_bit(input, i) && test_bit(input, (i + 1))){ if (test_bit(input, i) && test_bit(input, (i + 1))) {
set_bit(temp, (i / 2)); set_bit(temp, (i / 2));
} }
} }
memcpy(input, temp, sizeof(temp)); memcpy(input, temp, sizeof(temp));
} }
bool hitag_plain(uint8_t* rx, const size_t rxlen, uint8_t* tx, size_t* txlen, bool hitag_s) { bool hitag_plain(uint8_t *rx, const size_t rxlen, uint8_t *tx, size_t *txlen, bool hitag_s) {
uint8_t crc; uint8_t crc;
*txlen = 0; *txlen = 0;
switch (rxlen) { switch (rxlen) {
@ -386,27 +386,27 @@ bool hitag_plain(uint8_t* rx, const size_t rxlen, uint8_t* tx, size_t* txlen, bo
/*tx[0] = 0xb0; // Rev 3.0*/ /*tx[0] = 0xb0; // Rev 3.0*/
tx[0] = 0x30; // Rev 2.0 tx[0] = 0x30; // Rev 2.0
*txlen = 5; *txlen = 5;
if(!bCollision) blocknr--; if (!bCollision) blocknr--;
if(blocknr < 0) { if (blocknr < 0) {
blocknr = 0; blocknr = 0;
} }
if(!hitag_s){ if (!hitag_s) {
if (blocknr > 1 && blocknr < 31) { if (blocknr > 1 && blocknr < 31) {
blocknr=31; blocknr = 31;
} }
} }
bCollision = true; bCollision = true;
return true; return true;
} }
case 32: { case 32: {
if(bCollision){ if (bCollision) {
// Select card by serial from response // Select card by serial from response
tx[0] = 0x00 | rx[0] >> 5; tx[0] = 0x00 | rx[0] >> 5;
tx[1] = rx[0] << 3 | rx[1] >> 5; tx[1] = rx[0] << 3 | rx[1] >> 5;
tx[2] = rx[1] << 3 | rx[2] >> 5; tx[2] = rx[1] << 3 | rx[2] >> 5;
tx[3] = rx[2] << 3 | rx[3] >> 5; tx[3] = rx[2] << 3 | rx[3] >> 5;
tx[4] = rx[3] << 3; tx[4] = rx[3] << 3;
crc = hitag_crc(tx,37); crc = hitag_crc(tx, 37);
tx[4] |= crc >> 5; tx[4] |= crc >> 5;
tx[5] = crc << 3; tx[5] = crc << 3;
*txlen = 45; *txlen = 45;
@ -414,9 +414,9 @@ bool hitag_plain(uint8_t* rx, const size_t rxlen, uint8_t* tx, size_t* txlen, bo
} else { } else {
memcpy(tag.sectors[blocknr], rx, 4); memcpy(tag.sectors[blocknr], rx, 4);
blocknr++; blocknr++;
if(!hitag_s){ if (!hitag_s) {
if (blocknr > 1 && blocknr < 31) { if (blocknr > 1 && blocknr < 31) {
blocknr=31; blocknr = 31;
} }
} }
if (blocknr > 63) { if (blocknr > 63) {
@ -429,16 +429,18 @@ bool hitag_plain(uint8_t* rx, const size_t rxlen, uint8_t* tx, size_t* txlen, bo
Dbprintf("Reading page %02u", blocknr); Dbprintf("Reading page %02u", blocknr);
tx[0] = 0xc0 | blocknr >> 4; // RDPPAGE tx[0] = 0xc0 | blocknr >> 4; // RDPPAGE
tx[1] = blocknr << 4; tx[1] = blocknr << 4;
crc = hitag_crc(tx,12); crc = hitag_crc(tx, 12);
tx[1] |= crc >> 4; tx[1] |= crc >> 4;
tx[2] = crc << 4; tx[2] = crc << 4;
*txlen = 20; *txlen = 20;
} }
} break; }
break;
default: { default: {
Dbprintf("Uknown frame length: %d",rxlen); Dbprintf("Uknown frame length: %d", rxlen);
return false; return false;
} break; }
break;
} }
return true; return true;
} }
@ -446,7 +448,7 @@ bool hitag_plain(uint8_t* rx, const size_t rxlen, uint8_t* tx, size_t* txlen, bo
size_t flipped_bit = 0; size_t flipped_bit = 0;
uint32_t byte_value = 0; uint32_t byte_value = 0;
bool hitag1_authenticate(uint8_t* rx, const size_t rxlen, uint8_t* tx, size_t* txlen) { bool hitag1_authenticate(uint8_t *rx, const size_t rxlen, uint8_t *tx, size_t *txlen) {
uint8_t crc; uint8_t crc;
*txlen = 0; *txlen = 0;
switch (rxlen) { switch (rxlen) {
@ -455,17 +457,18 @@ bool hitag1_authenticate(uint8_t* rx, const size_t rxlen, uint8_t* tx, size_t* t
/*tx[0] = 0xb0; // Rev 3.0*/ /*tx[0] = 0xb0; // Rev 3.0*/
tx[0] = 0x30; // Rev 2.0 tx[0] = 0x30; // Rev 2.0
*txlen = 5; *txlen = 5;
if (bCrypto && byte_value <= 0xff){ if (bCrypto && byte_value <= 0xff) {
// to retry // to retry
bCrypto = false; bCrypto = false;
} }
if(!bCollision) blocknr--; if (!bCollision) blocknr--;
if(blocknr < 0) { if (blocknr < 0) {
blocknr = 0; blocknr = 0;
} }
bCollision = true; bCollision = true;
// will receive 32-bit UID // will receive 32-bit UID
} break; }
break;
case 2: { case 2: {
if (bAuthenticating) { if (bAuthenticating) {
// received Auth init ACK, send nonce // received Auth init ACK, send nonce
@ -474,43 +477,44 @@ bool hitag1_authenticate(uint8_t* rx, const size_t rxlen, uint8_t* tx, size_t* t
/*nonce[1] = 0x74;*/ /*nonce[1] = 0x74;*/
/*nonce[2] = 0x80;*/ /*nonce[2] = 0x80;*/
/*nonce[3] = 0xa5;*/ /*nonce[3] = 0xa5;*/
nonce[0]=byte_value; nonce[0] = byte_value;
byte_value++; byte_value++;
/*set_bit(nonce,flipped_bit);*/ /*set_bit(nonce,flipped_bit);*/
memcpy(tx,nonce,4); memcpy(tx, nonce, 4);
*txlen = 32; *txlen = 32;
// will receive 32 bit encrypted Logdata // will receive 32 bit encrypted Logdata
} else if (bCrypto) { } else if (bCrypto) {
// authed, start reading // authed, start reading
tx[0] = 0xe0 | blocknr >> 4; // RDCPAGE tx[0] = 0xe0 | blocknr >> 4; // RDCPAGE
tx[1] = blocknr << 4; tx[1] = blocknr << 4;
crc = hitag_crc(tx,12); crc = hitag_crc(tx, 12);
tx[1] |= crc >> 4; tx[1] |= crc >> 4;
tx[2] = crc << 4; tx[2] = crc << 4;
*txlen = 20; *txlen = 20;
// will receive 32-bit encrypted page // will receive 32-bit encrypted page
} }
} break; }
break;
case 32: { case 32: {
if (bCollision){ if (bCollision) {
// Select card by serial from response // Select card by serial from response
tx[0] = 0x00 | rx[0] >> 5; tx[0] = 0x00 | rx[0] >> 5;
tx[1] = rx[0] << 3 | rx[1] >> 5; tx[1] = rx[0] << 3 | rx[1] >> 5;
tx[2] = rx[1] << 3 | rx[2] >> 5; tx[2] = rx[1] << 3 | rx[2] >> 5;
tx[3] = rx[2] << 3 | rx[3] >> 5; tx[3] = rx[2] << 3 | rx[3] >> 5;
tx[4] = rx[3] << 3; tx[4] = rx[3] << 3;
crc = hitag_crc(tx,37); crc = hitag_crc(tx, 37);
tx[4] |= crc >> 5; tx[4] |= crc >> 5;
tx[5] = crc << 3; tx[5] = crc << 3;
*txlen = 45; *txlen = 45;
bCollision = false; bCollision = false;
bSelecting = true; bSelecting = true;
// will receive 32-bit configuration page // will receive 32-bit configuration page
} else if (bSelecting){ } else if (bSelecting) {
// Initiate auth // Initiate auth
tx[0] = 0xa0 | key_no >> 4; // WRCPAGE tx[0] = 0xa0 | key_no >> 4; // WRCPAGE
tx[1] = blocknr << 4; tx[1] = blocknr << 4;
crc = hitag_crc(tx,12); crc = hitag_crc(tx, 12);
tx[1] |= crc >> 4; tx[1] |= crc >> 4;
tx[2] = crc << 4; tx[2] = crc << 4;
*txlen = 20; *txlen = 20;
@ -525,7 +529,7 @@ bool hitag1_authenticate(uint8_t* rx, const size_t rxlen, uint8_t* tx, size_t* t
Dbprintf("%02x%02x%02x%02x %02x%02x%02x%02x", rx[0], rx[1], rx[2], rx[3], tx[0], tx[1], tx[2], tx[3]); Dbprintf("%02x%02x%02x%02x %02x%02x%02x%02x", rx[0], rx[1], rx[2], rx[3], tx[0], tx[1], tx[2], tx[3]);
// TODO replace with secret data stream // TODO replace with secret data stream
// TODO encrypt logdata_1 // TODO encrypt logdata_1
memcpy(tx,logdata_1,4); memcpy(tx, logdata_1, 4);
*txlen = 32; *txlen = 32;
bAuthenticating = false; bAuthenticating = false;
bCrypto = true; bCrypto = true;
@ -533,7 +537,7 @@ bool hitag1_authenticate(uint8_t* rx, const size_t rxlen, uint8_t* tx, size_t* t
} else if (bCrypto) { } else if (bCrypto) {
// received 32-bit encrypted page // received 32-bit encrypted page
// TODO decrypt rx // TODO decrypt rx
memcpy(tag.sectors[blocknr],rx,4); memcpy(tag.sectors[blocknr], rx, 4);
blocknr++; blocknr++;
if (blocknr > 63) { if (blocknr > 63) {
DbpString("Read succesful!"); DbpString("Read succesful!");
@ -543,23 +547,25 @@ bool hitag1_authenticate(uint8_t* rx, const size_t rxlen, uint8_t* tx, size_t* t
// TEST // TEST
Dbprintf("Succesfully authenticated with logdata:"); Dbprintf("Succesfully authenticated with logdata:");
Dbhexdump(4,logdata_1,false); Dbhexdump(4, logdata_1, false);
bSuccessful = true; bSuccessful = true;
return false; return false;
// read next page of card until done // read next page of card until done
tx[0] = 0xe0 | blocknr >> 4; // RDCPAGE tx[0] = 0xe0 | blocknr >> 4; // RDCPAGE
tx[1] = blocknr << 4; tx[1] = blocknr << 4;
crc = hitag_crc(tx,12); crc = hitag_crc(tx, 12);
tx[1] |= crc >> 4; tx[1] |= crc >> 4;
tx[2] = crc << 4; tx[2] = crc << 4;
*txlen = 20; *txlen = 20;
} }
} break; }
break;
default: { default: {
Dbprintf("Uknown frame length: %d",rxlen); Dbprintf("Uknown frame length: %d", rxlen);
return false; return false;
} break; }
break;
} }
return true; return true;
@ -988,13 +994,13 @@ void SniffHitag(void) {
} }
/*lf_count_edge_periods(10000);*/ /*lf_count_edge_periods(10000);*/
while ((periods = lf_detect_gap(64)) != 0){ while ((periods = lf_detect_gap(64)) != 0) {
num_to_bytes(periods, 4, periods_bytes); num_to_bytes(periods, 4, periods_bytes);
LogTrace(periods_bytes, 4, 0, 0, NULL, true); LogTrace(periods_bytes, 4, 0, 0, NULL, true);
} }
/* /*
// Check if frame was captured // Check if frame was captured
if (rxlen > 0) { if (rxlen > 0) {
// frame_count++; // frame_count++;
@ -1008,7 +1014,7 @@ void SniffHitag(void) {
auth_table_len += 8; auth_table_len += 8;
} }
} }
*/ */
} }
lf_finalize(); lf_finalize();
@ -1227,9 +1233,10 @@ void ReaderHitag(hitag_function htf, hitag_data *htd) {
case RHT1F_PLAIN: { case RHT1F_PLAIN: {
Dbprintf("Read public blocks in plain mode"); Dbprintf("Read public blocks in plain mode");
// this part will be unreadable // this part will be unreadable
memset(tag.sectors+2, 0x0, 30); memset(tag.sectors + 2, 0x0, 30);
blocknr = 0; blocknr = 0;
} break; }
break;
case RHT1F_AUTHENTICATE: { case RHT1F_AUTHENTICATE: {
Dbprintf("Read all blocks in authed mode"); Dbprintf("Read all blocks in authed mode");
@ -1251,7 +1258,8 @@ void ReaderHitag(hitag_function htf, hitag_data *htd) {
DbpString("Logdata_1:"); DbpString("Logdata_1:");
Dbhexdump(4, logdata_1, false); Dbhexdump(4, logdata_1, false);
blocknr = 0; blocknr = 0;
} break; }
break;
case RHT2F_PASSWORD: { case RHT2F_PASSWORD: {
Dbprintf("List identifier in password mode"); Dbprintf("List identifier in password mode");
memcpy(password, htd->pwd.password, 4); memcpy(password, htd->pwd.password, 4);
@ -1273,8 +1281,8 @@ void ReaderHitag(hitag_function htf, hitag_data *htd) {
memcpy(key, htd->crypto.key, 6); //HACK; 4 or 6?? I read both in the code. memcpy(key, htd->crypto.key, 6); //HACK; 4 or 6?? I read both in the code.
Dbhexdump(6, key, false); Dbhexdump(6, key, false);
DbpString("Nonce:"); DbpString("Nonce:");
Dbhexdump(4,nonce,false); Dbhexdump(4, nonce, false);
memcpy(nonce,htd->crypto.data,4); memcpy(nonce, htd->crypto.data, 4);
blocknr = 0; blocknr = 0;
bCrypto = false; bCrypto = false;
bAuthenticating = false; bAuthenticating = false;
@ -1310,7 +1318,7 @@ void ReaderHitag(hitag_function htf, hitag_data *htd) {
uint8_t attempt_count = 0; uint8_t attempt_count = 0;
// Tag specific configuration settings (sof, timings, etc.) // Tag specific configuration settings (sof, timings, etc.)
if (htf < 10){ if (htf < 10) {
// hitagS settings // hitagS settings
t_wait_1 = 204; t_wait_1 = 204;
t_wait_2 = 128; t_wait_2 = 128;
@ -1358,11 +1366,13 @@ void ReaderHitag(hitag_function htf, hitag_data *htd) {
switch (htf) { switch (htf) {
case RHT1F_PLAIN: { case RHT1F_PLAIN: {
bStop = !hitag_plain(rx, rxlen, tx, &txlen, false); bStop = !hitag_plain(rx, rxlen, tx, &txlen, false);
} break; }
break;
case RHT1F_AUTHENTICATE: { case RHT1F_AUTHENTICATE: {
bStop = !hitag1_authenticate(rx, rxlen, tx, &txlen); bStop = !hitag1_authenticate(rx, rxlen, tx, &txlen);
} break; }
break;
case RHT2F_PASSWORD: { case RHT2F_PASSWORD: {
bStop = !hitag2_password(rx, rxlen, tx, &txlen, false); bStop = !hitag2_password(rx, rxlen, tx, &txlen, false);
@ -1427,7 +1437,7 @@ void ReaderHitag(hitag_function htf, hitag_data *htd) {
// Just break out of loop after an initial time-out (tag is probably not available) // Just break out of loop after an initial time-out (tag is probably not available)
if (periods == 0) break; if (periods == 0) break;
// Register the number of periods that have passed // Register the number of periods that have passed
response = t_wait_1-64 + periods; response = t_wait_1 - 64 + periods;
// Indicate that we have dealt with the first edge // Indicate that we have dealt with the first edge
waiting_for_first_edge = false; waiting_for_first_edge = false;
// The first edge is always a single NRZ bit, force periods on 16 // The first edge is always a single NRZ bit, force periods on 16
@ -1437,20 +1447,20 @@ void ReaderHitag(hitag_function htf, hitag_data *htd) {
} else { } else {
// The function lf_count_edge_periods() returns 0 when a time-out occurs // The function lf_count_edge_periods() returns 0 when a time-out occurs
if (periods == 0) { if (periods == 0) {
Dbprintf("Detected timeout after [%d] nrz samples",nrzs); Dbprintf("Detected timeout after [%d] nrz samples", nrzs);
break; break;
} }
} }
// Evaluate the number of periods before the next edge // Evaluate the number of periods before the next edge
if (periods > 24 && periods <= 64){ if (periods > 24 && periods <= 64) {
// Detected two sequential equal bits and a modulation switch // Detected two sequential equal bits and a modulation switch
// NRZ modulation: (11 => --|) or (11 __|) // NRZ modulation: (11 => --|) or (11 __|)
nrz_samples[nrzs++] = tag_modulation; nrz_samples[nrzs++] = tag_modulation;
nrz_samples[nrzs++] = tag_modulation; nrz_samples[nrzs++] = tag_modulation;
// Invert tag modulation state // Invert tag modulation state
tag_modulation ^= 1; tag_modulation ^= 1;
} else if (periods > 0 && periods <= 24){ } else if (periods > 0 && periods <= 24) {
// Detected one bit and a modulation switch // Detected one bit and a modulation switch
// NRZ modulation: (1 => -|) or (0 _|) // NRZ modulation: (1 => -|) or (0 _|)
nrz_samples[nrzs++] = tag_modulation; nrz_samples[nrzs++] = tag_modulation;
@ -1492,24 +1502,24 @@ void ReaderHitag(hitag_function htf, hitag_data *htd) {
LED_B_ON(); LED_B_ON();
// decode bitstream // decode bitstream
manrawdecode((uint8_t*)nrz_samples, &nrzs, true, 0); manrawdecode((uint8_t *)nrz_samples, &nrzs, true, 0);
// decode frame // decode frame
// Verify if the header consists of five consecutive ones // Verify if the header consists of five consecutive ones
if (nrzs < 5) { if (nrzs < 5) {
Dbprintf("Detected unexpected number of manchester decoded samples [%d]",nrzs); Dbprintf("Detected unexpected number of manchester decoded samples [%d]", nrzs);
break; break;
} else { } else {
for (size_t i = 0; i < 5; i++){ for (size_t i = 0; i < 5; i++) {
if (nrz_samples[i] != 1) { if (nrz_samples[i] != 1) {
Dbprintf("Detected incorrect header, the bit [%d] is zero instead of one",i); Dbprintf("Detected incorrect header, the bit [%d] is zero instead of one", i);
} }
} }
} }
// Pack the response into a byte array // Pack the response into a byte array
for (size_t i = 5; i < nrzs; i++){ for (size_t i = 5; i < nrzs; i++) {
uint8_t bit = nrz_samples[i]; uint8_t bit = nrz_samples[i];
rx[rxlen / 8] |= bit << (7 - (rxlen % 8)); rx[rxlen / 8] |= bit << (7 - (rxlen % 8));
rxlen++; rxlen++;