mirror of
https://github.com/nfc-tools/mfcuk.git
synced 2025-12-23 18:50:06 +00:00
Applies make style
This commit is contained in:
romuald@libnfc.org
parent
22fa583429
commit
776b0d3f79
@ -124,8 +124,7 @@ static inline void extend_table_simple(uint32_t *tbl, uint32_t **end, int bit)
|
||||
static struct Crypto1State *
|
||||
recover(uint32_t *o_head, uint32_t *o_tail, uint32_t oks,
|
||||
uint32_t *e_head, uint32_t *e_tail, uint32_t eks, int rem,
|
||||
struct Crypto1State *sl, uint32_t in)
|
||||
{
|
||||
struct Crypto1State *sl, uint32_t in) {
|
||||
uint32_t *o, *e, i;
|
||||
|
||||
if (rem == -1) {
|
||||
@ -164,8 +163,7 @@ recover(uint32_t *o_head, uint32_t *o_tail, uint32_t oks,
|
||||
e_tail = binsearch(e_head, e = e_tail);
|
||||
sl = recover(o_tail--, o, oks,
|
||||
e_tail--, e, eks, rem, sl, in);
|
||||
}
|
||||
else if(*o_tail > *e_tail)
|
||||
} else if (*o_tail > *e_tail)
|
||||
o_tail = binsearch(o_head, o_tail) - 1;
|
||||
else
|
||||
e_tail = binsearch(e_head, e_tail) - 1;
|
||||
@ -177,8 +175,7 @@ recover(uint32_t *o_head, uint32_t *o_tail, uint32_t oks,
|
||||
* additionally you can use the in parameter to specify the value
|
||||
* that was fed into the lfsr at the time the keystream was generated
|
||||
*/
|
||||
struct Crypto1State* lfsr_recovery32(uint32_t ks2, uint32_t in)
|
||||
{
|
||||
struct Crypto1State *lfsr_recovery32(uint32_t ks2, uint32_t in) {
|
||||
struct Crypto1State *statelist;
|
||||
uint32_t *odd_head = 0, *odd_tail = 0, oks = 0;
|
||||
uint32_t *even_head = 0, *even_tail = 0, eks = 0;
|
||||
@ -224,29 +221,32 @@ out:
|
||||
|
||||
static const uint32_t S1[] = { 0x62141, 0x310A0, 0x18850, 0x0C428, 0x06214,
|
||||
0x0310A, 0x85E30, 0xC69AD, 0x634D6, 0xB5CDE, 0xDE8DA, 0x6F46D, 0xB3C83,
|
||||
0x59E41, 0xA8995, 0xD027F, 0x6813F, 0x3409F, 0x9E6FA};
|
||||
0x59E41, 0xA8995, 0xD027F, 0x6813F, 0x3409F, 0x9E6FA
|
||||
};
|
||||
static const uint32_t S2[] = { 0x3A557B00, 0x5D2ABD80, 0x2E955EC0, 0x174AAF60,
|
||||
0x0BA557B0, 0x05D2ABD8, 0x0449DE68, 0x048464B0, 0x42423258, 0x278192A8,
|
||||
0x156042D0, 0x0AB02168, 0x43F89B30, 0x61FC4D98, 0x765EAD48, 0x7D8FDD20,
|
||||
0x7EC7EE90, 0x7F63F748, 0x79117020};
|
||||
0x7EC7EE90, 0x7F63F748, 0x79117020
|
||||
};
|
||||
static const uint32_t T1[] = {
|
||||
0x4F37D, 0x279BE, 0x97A6A, 0x4BD35, 0x25E9A, 0x12F4D, 0x097A6, 0x80D66,
|
||||
0xC4006, 0x62003, 0xB56B4, 0x5AB5A, 0xA9318, 0xD0F39, 0x6879C, 0xB057B,
|
||||
0x582BD, 0x2C15E, 0x160AF, 0x8F6E2, 0xC3DC4, 0xE5857, 0x72C2B, 0x39615,
|
||||
0x98DBF, 0xC806A, 0xE0680, 0x70340, 0x381A0, 0x98665, 0x4C332, 0xA272C};
|
||||
0x98DBF, 0xC806A, 0xE0680, 0x70340, 0x381A0, 0x98665, 0x4C332, 0xA272C
|
||||
};
|
||||
static const uint32_t T2[] = { 0x3C88B810, 0x5E445C08, 0x2982A580, 0x14C152C0,
|
||||
0x4A60A960, 0x253054B0, 0x52982A58, 0x2FEC9EA8, 0x1156C4D0, 0x08AB6268,
|
||||
0x42F53AB0, 0x217A9D58, 0x161DC528, 0x0DAE6910, 0x46D73488, 0x25CB11C0,
|
||||
0x52E588E0, 0x6972C470, 0x34B96238, 0x5CFC3A98, 0x28DE96C8, 0x12CFC0E0,
|
||||
0x4967E070, 0x64B3F038, 0x74F97398, 0x7CDC3248, 0x38CE92A0, 0x1C674950,
|
||||
0x0E33A4A8, 0x01B959D0, 0x40DCACE8, 0x26CEDDF0};
|
||||
0x0E33A4A8, 0x01B959D0, 0x40DCACE8, 0x26CEDDF0
|
||||
};
|
||||
static const uint32_t C1[] = { 0x846B5, 0x4235A, 0x211AD};
|
||||
static const uint32_t C2[] = { 0x1A822E0, 0x21A822E0, 0x21A822E0};
|
||||
/** Reverse 64 bits of keystream into possible cipher states
|
||||
* Variation mentioned in the paper. Somewhat optimized version
|
||||
*/
|
||||
struct Crypto1State* lfsr_recovery64(uint32_t ks2, uint32_t ks3)
|
||||
{
|
||||
struct Crypto1State *lfsr_recovery64(uint32_t ks2, uint32_t ks3) {
|
||||
struct Crypto1State *statelist, *sl;
|
||||
uint8_t oks[32], eks[32], hi[32];
|
||||
uint32_t low = 0, win = 0;
|
||||
@ -306,7 +306,8 @@ struct Crypto1State* lfsr_recovery64(uint32_t ks2, uint32_t ks3)
|
||||
sl->even = win;
|
||||
++sl;
|
||||
sl->odd = sl->even = 0;
|
||||
continue2:;
|
||||
continue2:
|
||||
;
|
||||
}
|
||||
}
|
||||
return statelist;
|
||||
@ -376,7 +377,8 @@ int nonce_distance(uint32_t from, uint32_t to)
|
||||
|
||||
static uint32_t fastfwd[2][8] = {
|
||||
{ 0, 0x4BC53, 0xECB1, 0x450E2, 0x25E29, 0x6E27A, 0x2B298, 0x60ECB},
|
||||
{ 0, 0x1D962, 0x4BC53, 0x56531, 0xECB1, 0x135D3, 0x450E2, 0x58980}};
|
||||
{ 0, 0x1D962, 0x4BC53, 0x56531, 0xECB1, 0x135D3, 0x450E2, 0x58980}
|
||||
};
|
||||
|
||||
|
||||
/** lfsr_prefix_ks
|
||||
@ -416,8 +418,7 @@ uint32_t *lfsr_prefix_ks(uint8_t ks[8], int isodd)
|
||||
*/
|
||||
static struct Crypto1State *
|
||||
check_pfx_parity(uint32_t prefix, uint32_t rresp, uint8_t parities[8][8],
|
||||
uint32_t odd, uint32_t even, struct Crypto1State* sl)
|
||||
{
|
||||
uint32_t odd, uint32_t even, struct Crypto1State *sl) {
|
||||
uint32_t ks1, nr, ks2, rr, ks3, c, good = 1;
|
||||
|
||||
for (c = 0; good && c < 8; ++c) {
|
||||
@ -449,8 +450,7 @@ check_pfx_parity(uint32_t prefix, uint32_t rresp, uint8_t parities[8][8],
|
||||
* Implentation of the common prefix attack.
|
||||
*/
|
||||
struct Crypto1State *
|
||||
lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8])
|
||||
{
|
||||
lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8]) {
|
||||
struct Crypto1State *statelist, *s;
|
||||
uint32_t *odd, *even, *o, *e, top;
|
||||
|
||||
|
||||
@ -23,8 +23,7 @@
|
||||
#define SWAPENDIAN(x)\
|
||||
(x = (x >> 8 & 0xff00ff) | (x & 0xff00ff) << 8, x = x >> 16 | x << 16)
|
||||
|
||||
struct Crypto1State * crypto1_create(uint64_t key)
|
||||
{
|
||||
struct Crypto1State *crypto1_create(uint64_t key) {
|
||||
struct Crypto1State *s = malloc(sizeof(*s));
|
||||
int i;
|
||||
|
||||
|
||||
529
src/mfcuk.c
529
src/mfcuk.c
File diff suppressed because it is too large
Load Diff
@ -92,8 +92,7 @@
|
||||
#define MFCUK_DARKSIDE_START_NR 0xDEADBEEF
|
||||
#define MFCUK_DARKSIDE_START_AR 0xFACECAFE
|
||||
|
||||
typedef struct tag_nonce_entry
|
||||
{
|
||||
typedef struct tag_nonce_entry {
|
||||
uint32_t tagNonce; // Tag nonce we target for fixation
|
||||
uint8_t spoofFlag; // No spoofing until we have a successful auth with this tagNonce. Once we have, we want to spoof to get the encrypted 0x5 value
|
||||
uint32_t num_of_appearances; // For statistics, how many times this tag nonce appeared for the given SLEEP_ values
|
||||
|
||||
@ -38,8 +38,7 @@
|
||||
|
||||
#include "mfcuk_finger.h"
|
||||
|
||||
mfcuk_finger_tmpl_entry mfcuk_finger_db[] =
|
||||
{
|
||||
mfcuk_finger_tmpl_entry mfcuk_finger_db[] = {
|
||||
{ "./data/tmpls_fingerprints/mfcuk_tmpl_skgt.mfd", "Sofia SKGT", mfcuk_finger_default_comparator, mfcuk_finger_skgt_decoder, NULL },
|
||||
{ "./data/tmpls_fingerprints/mfcuk_tmpl_ratb.mfd", "Bucharest RATB", mfcuk_finger_default_comparator, mfcuk_finger_default_decoder, NULL },
|
||||
{ "./data/tmpls_fingerprints/mfcuk_tmpl_oyster.mfd", "London OYSTER", mfcuk_finger_default_comparator, mfcuk_finger_default_decoder, NULL },
|
||||
@ -49,8 +48,7 @@ int mfcuk_finger_db_entries = sizeof(mfcuk_finger_db)/sizeof(mfcuk_finger_db[0])
|
||||
|
||||
int mfcuk_finger_default_decoder(mifare_classic_tag *dump)
|
||||
{
|
||||
if (!dump)
|
||||
{
|
||||
if (!dump) {
|
||||
fprintf(stderr, "ERROR: cannot decode a NULL pointer :)\n");
|
||||
return 0;
|
||||
}
|
||||
@ -64,8 +62,7 @@ int mfcuk_finger_default_decoder(mifare_classic_tag *dump)
|
||||
// Yes, I know C++ class inheritance would perfectly fit the decoders/comparators... Though C is more to my heart. Anyone to rewrite in C++?
|
||||
int mfcuk_finger_skgt_decoder(mifare_classic_tag *dump)
|
||||
{
|
||||
if (!dump)
|
||||
{
|
||||
if (!dump) {
|
||||
fprintf(stderr, "ERROR: cannot decode a NULL pointer :)\n");
|
||||
return 0;
|
||||
}
|
||||
@ -87,45 +84,33 @@ int mfcuk_finger_default_comparator(mifare_classic_tag *dump, mfcuk_finger_templ
|
||||
int num_bytes_tomatch = 0;
|
||||
int num_bytes_matched = 0;
|
||||
|
||||
if ( (!dump) || (!tmpl) || (!score) )
|
||||
{
|
||||
if ((!dump) || (!tmpl) || (!score)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (IS_MIFARE_CLASSIC_1K_TAG(dump))
|
||||
{
|
||||
if (IS_MIFARE_CLASSIC_1K_TAG(dump)) {
|
||||
max_bytes = MIFARE_CLASSIC_BYTES_PER_BLOCK * MIFARE_CLASSIC_1K_MAX_BLOCKS;
|
||||
}
|
||||
else if (IS_MIFARE_CLASSIC_4K_TAG(dump))
|
||||
{
|
||||
} else if (IS_MIFARE_CLASSIC_4K_TAG(dump)) {
|
||||
max_bytes = MIFARE_CLASSIC_BYTES_PER_BLOCK * MIFARE_CLASSIC_4K_MAX_BLOCKS;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
|
||||
for (i=0; i<max_bytes; i++)
|
||||
{
|
||||
if ( ((char *)(&tmpl->mask))[i] == 0x0 )
|
||||
{
|
||||
for (i = 0; i < max_bytes; i++) {
|
||||
if (((char *)(&tmpl->mask))[i] == 0x0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
num_bytes_tomatch++;
|
||||
|
||||
if ( ((char *)(&tmpl->values))[i] == ((char *)dump)[i] )
|
||||
{
|
||||
if (((char *)(&tmpl->values))[i] == ((char *)dump)[i]) {
|
||||
num_bytes_matched++;
|
||||
}
|
||||
}
|
||||
|
||||
if (num_bytes_tomatch == 0)
|
||||
{
|
||||
if (num_bytes_tomatch == 0) {
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
*score = (float)(num_bytes_matched) / num_bytes_tomatch;
|
||||
}
|
||||
|
||||
@ -142,36 +127,30 @@ int mfcuk_finger_load(void)
|
||||
mfcuk_finger_template *tmpl_new = NULL;
|
||||
|
||||
int template_loaded_count = 0;
|
||||
for (i = 0; i<mfcuk_finger_db_entries; i++)
|
||||
{
|
||||
for (i = 0; i < mfcuk_finger_db_entries; i++) {
|
||||
fp = fopen(mfcuk_finger_db[i].tmpl_filename, "rb");
|
||||
|
||||
if (!fp)
|
||||
{
|
||||
if (!fp) {
|
||||
fprintf(stderr, "WARN: cannot open template file '%s'\n", mfcuk_finger_db[i].tmpl_filename);
|
||||
continue;
|
||||
}
|
||||
|
||||
// If not read exactly 1 record, something is wrong
|
||||
if ( (result = fread((void *)(&mask), sizeof(mask), 1, fp)) != 1)
|
||||
{
|
||||
if ((result = fread((void *)(&mask), sizeof(mask), 1, fp)) != 1) {
|
||||
fprintf(stderr, "WARN: cannot read MASK from template file '%s'\n", mfcuk_finger_db[i].tmpl_filename);
|
||||
fclose(fp);
|
||||
continue;
|
||||
}
|
||||
|
||||
// If not read exactly 1 record, something is wrong
|
||||
if ( (result = fread((void *)(&values), sizeof(values), 1, fp)) != 1)
|
||||
{
|
||||
if ((result = fread((void *)(&values), sizeof(values), 1, fp)) != 1) {
|
||||
fprintf(stderr, "WARN: cannot read VALUES template file '%s'\n", mfcuk_finger_db[i].tmpl_filename);
|
||||
fclose(fp);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (mfcuk_finger_db[i].tmpl_data == NULL)
|
||||
{
|
||||
if ( (tmpl_new = (mfcuk_finger_template *) malloc(sizeof(mfcuk_finger_template))) == NULL)
|
||||
{
|
||||
if (mfcuk_finger_db[i].tmpl_data == NULL) {
|
||||
if ((tmpl_new = (mfcuk_finger_template *) malloc(sizeof(mfcuk_finger_template))) == NULL) {
|
||||
fprintf(stderr, "WARN: cannot allocate memory to template record %d\n", i);
|
||||
fclose(fp);
|
||||
continue;
|
||||
@ -184,8 +163,7 @@ int mfcuk_finger_load(void)
|
||||
template_loaded_count++;
|
||||
}
|
||||
|
||||
if (fp)
|
||||
{
|
||||
if (fp) {
|
||||
fclose(fp);
|
||||
fp = NULL;
|
||||
}
|
||||
@ -198,10 +176,8 @@ int mfcuk_finger_unload(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i<mfcuk_finger_db_entries; i++)
|
||||
{
|
||||
if (mfcuk_finger_db[i].tmpl_data != NULL)
|
||||
{
|
||||
for (i = 0; i < mfcuk_finger_db_entries; i++) {
|
||||
if (mfcuk_finger_db[i].tmpl_data != NULL) {
|
||||
free(mfcuk_finger_db[i].tmpl_data);
|
||||
mfcuk_finger_db[i].tmpl_data = NULL;
|
||||
}
|
||||
|
||||
@ -45,8 +45,7 @@
|
||||
#include "mfcuk_mifare.h"
|
||||
|
||||
// Wrapping an ugly template into an externally pleasant name. To implement proper template later.
|
||||
typedef struct _mfcuk_finger_template_
|
||||
{
|
||||
typedef struct _mfcuk_finger_template_ {
|
||||
mifare_classic_tag mask;
|
||||
mifare_classic_tag values;
|
||||
} mfcuk_finger_template;
|
||||
@ -56,8 +55,7 @@ typedef int (*mfcuk_finger_comparator) (mifare_classic_tag *dump, mfcuk_finger_t
|
||||
typedef int (*mfcuk_finger_decoder)(mifare_classic_tag *dump);
|
||||
|
||||
// Naive implementation of a self-contained fingerprint database entry
|
||||
typedef struct _mfcuk_finger_tmpl_entry_
|
||||
{
|
||||
typedef struct _mfcuk_finger_tmpl_entry_ {
|
||||
const char *tmpl_filename;
|
||||
const char *tmpl_name;
|
||||
mfcuk_finger_comparator tmpl_comparison_func;
|
||||
|
||||
@ -53,8 +53,7 @@
|
||||
#include "mfcuk_mifare.h"
|
||||
|
||||
// Default keys used as a *BIG* mistake in many applications - especially System Integrators should pay attention!
|
||||
uint8_t mfcuk_default_keys[][MIFARE_CLASSIC_KEY_BYTELENGTH] =
|
||||
{
|
||||
uint8_t mfcuk_default_keys[][MIFARE_CLASSIC_KEY_BYTELENGTH] = {
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // Place-holder for current key to verify
|
||||
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
|
||||
{0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5},
|
||||
@ -70,13 +69,11 @@ int mfcuk_default_keys_num = sizeof(mfcuk_default_keys)/sizeof(mfcuk_default_key
|
||||
|
||||
bool is_valid_block(uint8_t bTagType, uint32_t uiBlock)
|
||||
{
|
||||
if ( IS_MIFARE_CLASSIC_1K(bTagType) && (uiBlock < MIFARE_CLASSIC_1K_MAX_BLOCKS) )
|
||||
{
|
||||
if (IS_MIFARE_CLASSIC_1K(bTagType) && (uiBlock < MIFARE_CLASSIC_1K_MAX_BLOCKS)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if ( IS_MIFARE_CLASSIC_4K(bTagType) && (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS) )
|
||||
{
|
||||
if (IS_MIFARE_CLASSIC_4K(bTagType) && (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -85,13 +82,11 @@ bool is_valid_block(uint8_t bTagType, uint32_t uiBlock)
|
||||
|
||||
bool is_valid_sector(uint8_t bTagType, uint32_t uiSector)
|
||||
{
|
||||
if ( IS_MIFARE_CLASSIC_1K(bTagType) && (uiSector < MIFARE_CLASSIC_1K_MAX_SECTORS) )
|
||||
{
|
||||
if (IS_MIFARE_CLASSIC_1K(bTagType) && (uiSector < MIFARE_CLASSIC_1K_MAX_SECTORS)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if ( IS_MIFARE_CLASSIC_4K(bTagType) && (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS) )
|
||||
{
|
||||
if (IS_MIFARE_CLASSIC_4K(bTagType) && (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -100,19 +95,15 @@ bool is_valid_sector(uint8_t bTagType, uint32_t uiSector)
|
||||
|
||||
bool is_first_block(uint8_t bTagType, uint32_t uiBlock)
|
||||
{
|
||||
if ( !is_valid_block(bTagType, uiBlock) )
|
||||
{
|
||||
if (!is_valid_block(bTagType, uiBlock)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Test if we are in the small or big sectors
|
||||
if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1)
|
||||
{
|
||||
if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1) {
|
||||
// For Mifare Classic 1K, it will enter always here
|
||||
return ((uiBlock) % (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) == 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// This branch will enter only for Mifare Classic 4K big sectors
|
||||
return ((uiBlock) % (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) == 0);
|
||||
}
|
||||
@ -123,19 +114,15 @@ bool is_first_block(uint8_t bTagType, uint32_t uiBlock)
|
||||
|
||||
bool is_trailer_block(uint8_t bTagType, uint32_t uiBlock)
|
||||
{
|
||||
if ( !is_valid_block(bTagType, uiBlock) )
|
||||
{
|
||||
if (!is_valid_block(bTagType, uiBlock)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Test if we are in the small or big sectors
|
||||
if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1)
|
||||
{
|
||||
if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1) {
|
||||
// For Mifare Classic 1K, it will enter always here
|
||||
return ((uiBlock + 1) % (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) == 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// This branch will enter only for Mifare Classic 4K big sectors
|
||||
return ((uiBlock + 1) % (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) == 0);
|
||||
}
|
||||
@ -146,19 +133,15 @@ bool is_trailer_block(uint8_t bTagType, uint32_t uiBlock)
|
||||
|
||||
uint32_t get_first_block(uint8_t bTagType, uint32_t uiBlock)
|
||||
{
|
||||
if ( !is_valid_block(bTagType, uiBlock) )
|
||||
{
|
||||
if (!is_valid_block(bTagType, uiBlock)) {
|
||||
return MIFARE_CLASSIC_INVALID_BLOCK;
|
||||
}
|
||||
|
||||
// Test if we are in the small or big sectors
|
||||
if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1)
|
||||
{
|
||||
if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1) {
|
||||
// Integer divide, then integer multiply
|
||||
return (uiBlock / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
uint32_t tmp = uiBlock - MIFARE_CLASSIC_4K_MAX_BLOCKS1;
|
||||
return MIFARE_CLASSIC_4K_MAX_BLOCKS1 + (tmp / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2;
|
||||
}
|
||||
@ -169,19 +152,15 @@ uint32_t get_first_block(uint8_t bTagType, uint32_t uiBlock)
|
||||
|
||||
uint32_t get_trailer_block(uint8_t bTagType, uint32_t uiBlock)
|
||||
{
|
||||
if ( !is_valid_block(bTagType, uiBlock) )
|
||||
{
|
||||
if (!is_valid_block(bTagType, uiBlock)) {
|
||||
return MIFARE_CLASSIC_INVALID_BLOCK;
|
||||
}
|
||||
|
||||
// Test if we are in the small or big sectors
|
||||
if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1)
|
||||
{
|
||||
if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1) {
|
||||
// Integer divide, then integer multiply
|
||||
return (uiBlock / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1 + (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1 - 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
uint32_t tmp = uiBlock - MIFARE_CLASSIC_4K_MAX_BLOCKS1;
|
||||
return MIFARE_CLASSIC_4K_MAX_BLOCKS1 + (tmp / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2 + (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2 - 1);
|
||||
}
|
||||
@ -192,13 +171,11 @@ uint32_t get_trailer_block(uint8_t bTagType, uint32_t uiBlock)
|
||||
|
||||
bool is_big_sector(uint8_t bTagType, uint32_t uiSector)
|
||||
{
|
||||
if ( !is_valid_sector(bTagType, uiSector) )
|
||||
{
|
||||
if (!is_valid_sector(bTagType, uiSector)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (uiSector >= MIFARE_CLASSIC_4K_MAX_SECTORS1)
|
||||
{
|
||||
if (uiSector >= MIFARE_CLASSIC_4K_MAX_SECTORS1) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -207,18 +184,14 @@ bool is_big_sector(uint8_t bTagType, uint32_t uiSector)
|
||||
|
||||
uint32_t get_first_block_for_sector(uint8_t bTagType, uint32_t uiSector)
|
||||
{
|
||||
if ( !is_valid_sector(bTagType, uiSector) )
|
||||
{
|
||||
if (!is_valid_sector(bTagType, uiSector)) {
|
||||
return MIFARE_CLASSIC_INVALID_BLOCK;
|
||||
}
|
||||
|
||||
if (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS1)
|
||||
{
|
||||
if (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS1) {
|
||||
// For Mifare Classic 1K, it will enter always here
|
||||
return (uiSector * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// For Mifare Classic 4K big sectors it will enter always here
|
||||
uint32_t tmp = uiSector - MIFARE_CLASSIC_4K_MAX_SECTORS1;
|
||||
return MIFARE_CLASSIC_4K_MAX_BLOCKS1 + (tmp * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2);
|
||||
@ -230,18 +203,14 @@ uint32_t get_first_block_for_sector(uint8_t bTagType, uint32_t uiSector)
|
||||
|
||||
uint32_t get_trailer_block_for_sector(uint8_t bTagType, uint32_t uiSector)
|
||||
{
|
||||
if ( !is_valid_sector(bTagType, uiSector) )
|
||||
{
|
||||
if (!is_valid_sector(bTagType, uiSector)) {
|
||||
return MIFARE_CLASSIC_INVALID_BLOCK;
|
||||
}
|
||||
|
||||
if (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS1)
|
||||
{
|
||||
if (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS1) {
|
||||
// For Mifare Classic 1K, it will enter always here
|
||||
return (uiSector * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) + (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1 - 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// For Mifare Classic 4K big sectors it will enter always here
|
||||
uint32_t tmp = uiSector - MIFARE_CLASSIC_4K_MAX_SECTORS1;
|
||||
return MIFARE_CLASSIC_4K_MAX_BLOCKS1 + (tmp * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) + (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2 - 1);
|
||||
@ -253,19 +222,15 @@ uint32_t get_trailer_block_for_sector(uint8_t bTagType, uint32_t uiSector)
|
||||
|
||||
uint32_t get_sector_for_block(uint8_t bTagType, uint32_t uiBlock)
|
||||
{
|
||||
if ( !is_valid_block(bTagType, uiBlock) )
|
||||
{
|
||||
if (!is_valid_block(bTagType, uiBlock)) {
|
||||
return MIFARE_CLASSIC_INVALID_BLOCK;
|
||||
}
|
||||
|
||||
// Test if we are in the small or big sectors
|
||||
if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1)
|
||||
{
|
||||
if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1) {
|
||||
// For Mifare Classic 1K, it will enter always here
|
||||
return (uiBlock / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
uint32_t tmp = uiBlock - MIFARE_CLASSIC_4K_MAX_BLOCKS1;
|
||||
return MIFARE_CLASSIC_4K_MAX_SECTORS1 + (tmp / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2);
|
||||
}
|
||||
@ -280,26 +245,20 @@ void test_mifare_classic_blocks_sectors_functions(uint8_t bTagType)
|
||||
uint32_t i;
|
||||
uint32_t max_blocks, max_sectors;
|
||||
|
||||
if ( IS_MIFARE_CLASSIC_1K(bTagType) )
|
||||
{
|
||||
if (IS_MIFARE_CLASSIC_1K(bTagType)) {
|
||||
printf("\nMIFARE CLASSIC 1K\n");
|
||||
max_blocks = MIFARE_CLASSIC_1K_MAX_BLOCKS;
|
||||
max_sectors = MIFARE_CLASSIC_1K_MAX_SECTORS;
|
||||
}
|
||||
else if ( IS_MIFARE_CLASSIC_4K(bTagType) )
|
||||
{
|
||||
} else if (IS_MIFARE_CLASSIC_4K(bTagType)) {
|
||||
printf("\nMIFARE CLASSIC 4K\n");
|
||||
max_blocks = MIFARE_CLASSIC_4K_MAX_BLOCKS;
|
||||
max_sectors = MIFARE_CLASSIC_4K_MAX_SECTORS;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
|
||||
// Include one invalid block, that is why we add +1
|
||||
for (i = 0; i<max_blocks+1; i++)
|
||||
{
|
||||
for (i = 0; i < max_blocks + 1; i++) {
|
||||
printf("BLOCK %d\n", i);
|
||||
printf("\t is_valid_block: %c\n", (is_valid_block(bTagType, i) ? 'Y' : 'N'));
|
||||
printf("\t is_first_block: %c\n", (is_first_block(bTagType, i) ? 'Y' : 'N'));
|
||||
@ -310,8 +269,7 @@ void test_mifare_classic_blocks_sectors_functions(uint8_t bTagType)
|
||||
}
|
||||
|
||||
// Include one invalid sector, that is why we add +1
|
||||
for (i = 0; i<max_sectors+1; i++)
|
||||
{
|
||||
for (i = 0; i < max_sectors + 1; i++) {
|
||||
printf("SECTOR %d\n", i);
|
||||
printf("\t is_valid_sector: %c\n", (is_valid_sector(bTagType, i) ? 'Y' : 'N'));
|
||||
printf("\t is_big_sector: %c\n", (is_big_sector(bTagType, i) ? 'Y' : 'N'));
|
||||
@ -327,8 +285,7 @@ bool mfcuk_save_tag_dump(const char *filename, mifare_classic_tag *tag)
|
||||
size_t result;
|
||||
|
||||
fp = fopen(filename, "wb");
|
||||
if (!fp)
|
||||
{
|
||||
if (!fp) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -336,8 +293,7 @@ bool mfcuk_save_tag_dump(const char *filename, mifare_classic_tag *tag)
|
||||
result = fwrite((void *) tag, sizeof(*tag), 1, fp);
|
||||
|
||||
// If not written exactly 1 record, something is wrong
|
||||
if (result != 1)
|
||||
{
|
||||
if (result != 1) {
|
||||
fclose(fp);
|
||||
return false;
|
||||
}
|
||||
@ -352,8 +308,7 @@ bool mfcuk_save_tag_dump_ext(const char *filename, mifare_classic_tag_ext *tag_e
|
||||
size_t result;
|
||||
|
||||
fp = fopen(filename, "wb");
|
||||
if (!fp)
|
||||
{
|
||||
if (!fp) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -361,8 +316,7 @@ bool mfcuk_save_tag_dump_ext(const char *filename, mifare_classic_tag_ext *tag_e
|
||||
result = fwrite((void *) tag_ext, sizeof(*tag_ext), 1, fp);
|
||||
|
||||
// If not written exactly 1 record, something is wrong
|
||||
if (result != 1)
|
||||
{
|
||||
if (result != 1) {
|
||||
fclose(fp);
|
||||
return false;
|
||||
}
|
||||
@ -377,8 +331,7 @@ bool mfcuk_load_tag_dump(const char *filename, mifare_classic_tag *tag)
|
||||
size_t result;
|
||||
|
||||
fp = fopen(filename, "rb");
|
||||
if (!fp)
|
||||
{
|
||||
if (!fp) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -386,8 +339,7 @@ bool mfcuk_load_tag_dump(const char *filename, mifare_classic_tag *tag)
|
||||
result = fread((void *) tag, sizeof(*tag), 1, fp);
|
||||
|
||||
// If not read exactly 1 record, something is wrong
|
||||
if (result != 1)
|
||||
{
|
||||
if (result != 1) {
|
||||
fclose(fp);
|
||||
return false;
|
||||
}
|
||||
@ -402,8 +354,7 @@ bool mfcuk_load_tag_dump_ext(const char *filename, mifare_classic_tag_ext *tag_e
|
||||
size_t result;
|
||||
|
||||
fp = fopen(filename, "rb");
|
||||
if (!fp)
|
||||
{
|
||||
if (!fp) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -411,8 +362,7 @@ bool mfcuk_load_tag_dump_ext(const char *filename, mifare_classic_tag_ext *tag_e
|
||||
result = fread((void *) tag_ext, sizeof(*tag_ext), 1, fp);
|
||||
|
||||
// If not read exactly 1 record, something is wrong
|
||||
if (result != sizeof(*tag_ext))
|
||||
{
|
||||
if (result != sizeof(*tag_ext)) {
|
||||
fclose(fp);
|
||||
return false;
|
||||
}
|
||||
@ -427,15 +377,13 @@ void print_mifare_classic_tag_keys(const char *title, mifare_classic_tag *tag)
|
||||
uint8_t bTagType;
|
||||
mifare_classic_block_trailer *ptr_trailer = NULL;
|
||||
|
||||
if (!tag)
|
||||
{
|
||||
if (!tag) {
|
||||
return;
|
||||
}
|
||||
|
||||
bTagType = tag->amb->mbm.btUnknown;
|
||||
|
||||
if ( !IS_MIFARE_CLASSIC_1K(bTagType) && !IS_MIFARE_CLASSIC_4K(bTagType) )
|
||||
{
|
||||
if (!IS_MIFARE_CLASSIC_1K(bTagType) && !IS_MIFARE_CLASSIC_4K(bTagType)) {
|
||||
return;
|
||||
}
|
||||
|
||||
@ -447,21 +395,16 @@ void print_mifare_classic_tag_keys(const char *title, mifare_classic_tag *tag)
|
||||
printf("Sector\t| Key A\t| AC bits\t| Key B\n");
|
||||
printf("-------------------------------------------------------\n");
|
||||
|
||||
if ( IS_MIFARE_CLASSIC_1K(tag->amb->mbm.btUnknown) )
|
||||
{
|
||||
if (IS_MIFARE_CLASSIC_1K(tag->amb->mbm.btUnknown)) {
|
||||
max_blocks = MIFARE_CLASSIC_1K_MAX_BLOCKS;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
max_blocks = MIFARE_CLASSIC_4K_MAX_BLOCKS;
|
||||
}
|
||||
|
||||
for (i=0; i<max_blocks; i++)
|
||||
{
|
||||
for (i = 0; i < max_blocks; i++) {
|
||||
trailer_block = get_trailer_block(bTagType, i);
|
||||
|
||||
if ( !is_valid_block(bTagType, trailer_block) )
|
||||
{
|
||||
if (!is_valid_block(bTagType, trailer_block)) {
|
||||
break;
|
||||
}
|
||||
|
||||
@ -489,13 +432,11 @@ bool mfcuk_key_uint64_to_arr(const uint64_t *ui64Key, uint8_t *arr6Key)
|
||||
{
|
||||
int i;
|
||||
|
||||
if ( !ui64Key || !arr6Key )
|
||||
{
|
||||
if (!ui64Key || !arr6Key) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (i = 0; i<MIFARE_CLASSIC_KEY_BYTELENGTH; i++)
|
||||
{
|
||||
for (i = 0; i < MIFARE_CLASSIC_KEY_BYTELENGTH; i++) {
|
||||
arr6Key[i] = (uint8_t)(((*ui64Key) >> 8 * (MIFARE_CLASSIC_KEY_BYTELENGTH - i - 1)) & 0xFF);
|
||||
}
|
||||
|
||||
@ -507,13 +448,11 @@ bool mfcuk_key_arr_to_uint64(const uint8_t *arr6Key, uint64_t *ui64Key)
|
||||
uint64_t key = 0;
|
||||
int i;
|
||||
|
||||
if ( !ui64Key || !arr6Key )
|
||||
{
|
||||
if (!ui64Key || !arr6Key) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (i = 0; i<MIFARE_CLASSIC_KEY_BYTELENGTH; i++, key <<= 8)
|
||||
{
|
||||
for (i = 0; i < MIFARE_CLASSIC_KEY_BYTELENGTH; i++, key <<= 8) {
|
||||
key |= arr6Key[i];
|
||||
}
|
||||
key >>= 8;
|
||||
|
||||
@ -167,21 +167,18 @@ int getopt(int argc, char *argv[], char *optstring)
|
||||
|
||||
optarg = NULL;
|
||||
|
||||
if (next == NULL || *next == '\0')
|
||||
{
|
||||
if (next == NULL || *next == '\0') {
|
||||
if (optind == 0)
|
||||
optind++;
|
||||
|
||||
if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0')
|
||||
{
|
||||
if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0') {
|
||||
optarg = NULL;
|
||||
if (optind < argc)
|
||||
optarg = argv[optind];
|
||||
return EOF;
|
||||
}
|
||||
|
||||
if (strcmp(argv[optind], "--") == 0)
|
||||
{
|
||||
if (strcmp(argv[optind], "--") == 0) {
|
||||
optind++;
|
||||
optarg = NULL;
|
||||
if (optind < argc)
|
||||
@ -201,20 +198,14 @@ int getopt(int argc, char *argv[], char *optstring)
|
||||
return '?';
|
||||
|
||||
cp++;
|
||||
if (*cp == ':')
|
||||
{
|
||||
if (*next != '\0')
|
||||
{
|
||||
if (*cp == ':') {
|
||||
if (*next != '\0') {
|
||||
optarg = next;
|
||||
next = NULL;
|
||||
}
|
||||
else if (optind < argc)
|
||||
{
|
||||
} else if (optind < argc) {
|
||||
optarg = argv[optind];
|
||||
optind++;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
return '?';
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user