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

Merge pull request #2629 from pingu2211/hf-mifare-refacor

Browse source 
Style src/mifare/mifarehost
This commit is contained in:
Iceman 2024-11-14 07:52:32 +01:00 • committed by GitHub
commit 4a119a73f0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
8 changed files with 202 additions and 202 deletions
Download patch file Download diff file Expand all files Collapse all files

4
armsrc/Standalone/hf_young.c
View file

@ -177,14 +177,14 @@ void RunMod(void) {
MifareCGetBlock(c->arg[0], c->arg[1], c->d.asBytes); MifareCGetBlock(c->arg[0], c->arg[1], c->d.asBytes);
break; break;
mfCSetUID provides example logic for UID set workflow: mf_chinese_set_uid provides example logic for UID set workflow:
-Read block0 from card in field with MifareCGetBlock() -Read block0 from card in field with MifareCGetBlock()
-Configure new values without replacing reserved bytes -Configure new values without replacing reserved bytes
memcpy(block0, uid, 4); // Copy UID bytes from byte array memcpy(block0, uid, 4); // Copy UID bytes from byte array
// Mifare UID BCC // Mifare UID BCC
block0[4] = block0[0]^block0[1]^block0[2]^block0[3]; // BCC on byte 5 block0[4] = block0[0]^block0[1]^block0[2]^block0[3]; // BCC on byte 5
Bytes 5-7 are reserved SAK and ATQA for mifare classic Bytes 5-7 are reserved SAK and ATQA for mifare classic
-Use mfCSetBlock(0, block0, oldUID, wantWipe, MAGIC_SINGLE | MAGIC_WUPC) to write it -Use mf_chinese_set_block(0, block0, oldUID, wantWipe, MAGIC_SINGLE | MAGIC_WUPC) to write it
*/ */
uint8_t oldBlock0[16] = {0}, newBlock0[16] = {0}; uint8_t oldBlock0[16] = {0}, newBlock0[16] = {0};
// arg0 = Flags, arg1=blockNo // arg0 = Flags, arg1=blockNo

2
client/src/cmdhfict.c
View file

@ -525,7 +525,7 @@ static int CmdHfIctCredential(const char *Cmd) {
} }
// diversified key A? // diversified key A?
int res = mfReadSector(ICT_MIFARE_SECTOR, MF_KEY_A, ICT_MIFARE_A_KEY, data); int res = mf_read_sector(ICT_MIFARE_SECTOR, MF_KEY_A, ICT_MIFARE_A_KEY, data);
if (res != PM3_SUCCESS) { if (res != PM3_SUCCESS) {
free(data); free(data);
return res; return res;

4
client/src/cmdhfjooki.c
View file

@ -531,7 +531,7 @@ static int CmdHF14AJookiSim(const char *Cmd) {
g_conn.block_after_ACK = true; g_conn.block_after_ACK = true;
uint8_t blockwidth = 4, counter = 0, blockno = 0; uint8_t blockwidth = 4, counter = 0, blockno = 0;
// 12 is the size of the struct the fct mfEmlSetMem_xt uses to transfer to device // 12 is the size of the struct the fct mf_eml_set_mem_xt uses to transfer to device
uint16_t max_avail_blocks = ((PM3_CMD_DATA_SIZE - 12) / blockwidth) * blockwidth; uint16_t max_avail_blocks = ((PM3_CMD_DATA_SIZE - 12) / blockwidth) * blockwidth;
while (datalen) { while (datalen) {
@ -542,7 +542,7 @@ static int CmdHF14AJookiSim(const char *Cmd) {
uint16_t chunk_size = MIN(max_avail_blocks, datalen); uint16_t chunk_size = MIN(max_avail_blocks, datalen);
uint16_t blocks_to_send = chunk_size / blockwidth; uint16_t blocks_to_send = chunk_size / blockwidth;
if (mfEmlSetMem_xt(data + counter, blockno, blocks_to_send, blockwidth) != PM3_SUCCESS) { if (mf_eml_set_mem_xt(data + counter, blockno, blocks_to_send, blockwidth) != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Cant set emul block: %3d", blockno); PrintAndLogEx(FAILED, "Cant set emul block: %3d", blockno);
free(data); free(data);
return PM3_ESOFT; return PM3_ESOFT;

180
client/src/cmdhfmf.c
View file

@ -905,7 +905,7 @@ static int CmdHF14AMfDarkside(const char *Cmd) {
uint64_t key = 0; uint64_t key = 0;
uint64_t t1 = msclock(); uint64_t t1 = msclock();
int ret = mfDarkside(blockno, key_type, &key); int ret = mf_dark_side(blockno, key_type, &key);
t1 = msclock() - t1; t1 = msclock() - t1;
if (ret != PM3_SUCCESS) return ret; if (ret != PM3_SUCCESS) return ret;
@ -1086,7 +1086,7 @@ static int CmdHF14AMfRdBl(const char *Cmd) {
uint8_t blockno = (uint8_t)b; uint8_t blockno = (uint8_t)b;
uint8_t data[16] = {0}; uint8_t data[16] = {0};
int res = mfReadBlock(blockno, keytype, key, data); int res = mf_read_block(blockno, keytype, key, data);
if (res == PM3_SUCCESS) { if (res == PM3_SUCCESS) {
uint8_t sector = mfSectorNum(blockno); uint8_t sector = mfSectorNum(blockno);
@ -1162,7 +1162,7 @@ static int CmdHF14AMfRdSc(const char *Cmd) {
return PM3_EMALLOC; return PM3_EMALLOC;
} }
int res = mfReadSector(sector, keytype, key, data); int res = mf_read_sector(sector, keytype, key, data);
if (res == PM3_SUCCESS) { if (res == PM3_SUCCESS) {
uint8_t blocks = mfNumBlocksPerSector(sector); uint8_t blocks = mfNumBlocksPerSector(sector);
@ -1767,7 +1767,7 @@ static int CmdHF14AMfNested(const char *Cmd) { //TODO: single mode broken? can't
} }
// check if we can authenticate to sector // check if we can authenticate to sector
if (mfCheckKeys(blockNo, keyType, true, 1, key, &key64) != PM3_SUCCESS) { if (mf_check_keys(blockNo, keyType, true, 1, key, &key64) != PM3_SUCCESS) {
if (keyType < 2) { if (keyType < 2) {
PrintAndLogEx(WARNING, "Wrong key. Can't authenticate to block:%3d key type:%c", blockNo, keyType ? 'B' : 'A'); PrintAndLogEx(WARNING, "Wrong key. Can't authenticate to block:%3d key type:%c", blockNo, keyType ? 'B' : 'A');
} else { } else {
@ -1777,7 +1777,7 @@ static int CmdHF14AMfNested(const char *Cmd) { //TODO: single mode broken? can't
} }
if (singleSector) { if (singleSector) {
int16_t isOK = mfnested(blockNo, keyType, key, trgBlockNo, trgKeyType, keyBlock, !ignore_static_encrypted); int16_t isOK = mf_nested(blockNo, keyType, key, trgBlockNo, trgKeyType, keyBlock, !ignore_static_encrypted);
switch (isOK) { switch (isOK) {
case PM3_ETIMEOUT: case PM3_ETIMEOUT:
PrintAndLogEx(ERR, "command execution time out\n"); PrintAndLogEx(ERR, "command execution time out\n");
@ -1806,14 +1806,14 @@ static int CmdHF14AMfNested(const char *Cmd) { //TODO: single mode broken? can't
} else { // 16 block sector } else { // 16 block sector
sectortrailer = trgBlockNo | 0x0f; sectortrailer = trgBlockNo | 0x0f;
} }
mfEmlGetMem(keyBlock, sectortrailer, 1); mf_eml_get_mem(keyBlock, sectortrailer, 1);
if (trgKeyType == MF_KEY_A) if (trgKeyType == MF_KEY_A)
num_to_bytes(key64, 6, keyBlock); num_to_bytes(key64, 6, keyBlock);
else else
num_to_bytes(key64, 6, &keyBlock[10]); num_to_bytes(key64, 6, &keyBlock[10]);
mfEmlSetMem(keyBlock, sectortrailer, 1); mf_elm_set_mem(keyBlock, sectortrailer, 1);
PrintAndLogEx(SUCCESS, "Key transferred to emulator memory."); PrintAndLogEx(SUCCESS, "Key transferred to emulator memory.");
} }
return PM3_SUCCESS; return PM3_SUCCESS;
@ -1841,7 +1841,7 @@ static int CmdHF14AMfNested(const char *Cmd) { //TODO: single mode broken? can't
} }
PrintAndLogEx(SUCCESS, "Testing known keys. Sector count "_YELLOW_("%d"), SectorsCnt); PrintAndLogEx(SUCCESS, "Testing known keys. Sector count "_YELLOW_("%d"), SectorsCnt);
int res = mfCheckKeys_fast(SectorsCnt, true, true, 1, ARRAYLEN(g_mifare_default_keys) + 1, keyBlock, e_sector, use_flashmemory, false); int res = mf_check_keys_fast(SectorsCnt, true, true, 1, ARRAYLEN(g_mifare_default_keys) + 1, keyBlock, e_sector, use_flashmemory, false);
if (res == PM3_SUCCESS) { if (res == PM3_SUCCESS) {
PrintAndLogEx(SUCCESS, "Fast check found all keys"); PrintAndLogEx(SUCCESS, "Fast check found all keys");
goto jumptoend; goto jumptoend;
@ -1860,7 +1860,7 @@ static int CmdHF14AMfNested(const char *Cmd) { //TODO: single mode broken? can't
if (e_sector[sectorNo].foundKey[trgKeyType]) continue; if (e_sector[sectorNo].foundKey[trgKeyType]) continue;
int16_t isOK = mfnested(blockNo, keyType, key, mfFirstBlockOfSector(sectorNo), trgKeyType, keyBlock, calibrate); int16_t isOK = mf_nested(blockNo, keyType, key, mfFirstBlockOfSector(sectorNo), trgKeyType, keyBlock, calibrate);
switch (isOK) { switch (isOK) {
case PM3_ETIMEOUT: case PM3_ETIMEOUT:
PrintAndLogEx(ERR, "command execution time out\n"); PrintAndLogEx(ERR, "command execution time out\n");
@ -1883,7 +1883,7 @@ static int CmdHF14AMfNested(const char *Cmd) { //TODO: single mode broken? can't
e_sector[sectorNo].foundKey[trgKeyType] = 1; e_sector[sectorNo].foundKey[trgKeyType] = 1;
e_sector[sectorNo].Key[trgKeyType] = bytes_to_num(keyBlock, 6); e_sector[sectorNo].Key[trgKeyType] = bytes_to_num(keyBlock, 6);
mfCheckKeys_fast(SectorsCnt, true, true, 2, 1, keyBlock, e_sector, false, false); mf_check_keys_fast(SectorsCnt, true, true, 2, 1, keyBlock, e_sector, false, false);
continue; continue;
default : default :
PrintAndLogEx(ERR, "Unknown error\n"); PrintAndLogEx(ERR, "Unknown error\n");
@ -1945,7 +1945,7 @@ jumptoend:
// fast push mode // fast push mode
g_conn.block_after_ACK = true; g_conn.block_after_ACK = true;
for (int i = 0; i < SectorsCnt; i++) { for (int i = 0; i < SectorsCnt; i++) {
mfEmlGetMem(keyBlock, mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1, 1); mf_eml_get_mem(keyBlock, mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1, 1);
if (e_sector[i].foundKey[0]) if (e_sector[i].foundKey[0])
num_to_bytes(e_sector[i].Key[0], 6, keyBlock); num_to_bytes(e_sector[i].Key[0], 6, keyBlock);
@ -1957,7 +1957,7 @@ jumptoend:
// Disable fast mode on last packet // Disable fast mode on last packet
g_conn.block_after_ACK = false; g_conn.block_after_ACK = false;
} }
mfEmlSetMem(keyBlock, mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1, 1); mf_elm_set_mem(keyBlock, mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1, 1);
} }
PrintAndLogEx(SUCCESS, "keys transferred to emulator memory."); PrintAndLogEx(SUCCESS, "keys transferred to emulator memory.");
} }
@ -2069,7 +2069,7 @@ static int CmdHF14AMfNestedStatic(const char *Cmd) {
} }
// check if we can authenticate to sector // check if we can authenticate to sector
if (mfCheckKeys(blockNo, keyType, true, 1, key, &key64) != PM3_SUCCESS) { if (mf_check_keys(blockNo, keyType, true, 1, key, &key64) != PM3_SUCCESS) {
if (keyType < 2) { if (keyType < 2) {
PrintAndLogEx(WARNING, "Wrong key. Can't authenticate to block:%3d key type:%c", blockNo, keyType ? 'B' : 'A'); PrintAndLogEx(WARNING, "Wrong key. Can't authenticate to block:%3d key type:%c", blockNo, keyType ? 'B' : 'A');
} else { } else {
@ -2101,7 +2101,7 @@ static int CmdHF14AMfNestedStatic(const char *Cmd) {
} }
PrintAndLogEx(SUCCESS, "Testing known keys. Sector count "_YELLOW_("%d"), SectorsCnt); PrintAndLogEx(SUCCESS, "Testing known keys. Sector count "_YELLOW_("%d"), SectorsCnt);
int res = mfCheckKeys_fast(SectorsCnt, true, true, 1, ARRAYLEN(g_mifare_default_keys) + 1, keyBlock, e_sector, false, false); int res = mf_check_keys_fast(SectorsCnt, true, true, 1, ARRAYLEN(g_mifare_default_keys) + 1, keyBlock, e_sector, false, false);
if (res == PM3_SUCCESS) { if (res == PM3_SUCCESS) {
// all keys found // all keys found
PrintAndLogEx(SUCCESS, "Fast check found all keys"); PrintAndLogEx(SUCCESS, "Fast check found all keys");
@ -2120,7 +2120,7 @@ static int CmdHF14AMfNestedStatic(const char *Cmd) {
if (e_sector[sectorNo].foundKey[trgKeyType]) continue; if (e_sector[sectorNo].foundKey[trgKeyType]) continue;
int16_t isOK = mfStaticNested(blockNo, keyType, key, mfFirstBlockOfSector(sectorNo), trgKeyType, keyBlock); int16_t isOK = mf_static_nested(blockNo, keyType, key, mfFirstBlockOfSector(sectorNo), trgKeyType, keyBlock);
switch (isOK) { switch (isOK) {
case PM3_ETIMEOUT : case PM3_ETIMEOUT :
PrintAndLogEx(ERR, "command execution time out"); PrintAndLogEx(ERR, "command execution time out");
@ -2198,7 +2198,7 @@ jumptoend:
// fast push mode // fast push mode
g_conn.block_after_ACK = true; g_conn.block_after_ACK = true;
for (int i = 0; i < SectorsCnt; i++) { for (int i = 0; i < SectorsCnt; i++) {
mfEmlGetMem(keyBlock, mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1, 1); mf_eml_get_mem(keyBlock, mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1, 1);
if (e_sector[i].foundKey[0]) if (e_sector[i].foundKey[0])
num_to_bytes(e_sector[i].Key[0], 6, keyBlock); num_to_bytes(e_sector[i].Key[0], 6, keyBlock);
@ -2210,7 +2210,7 @@ jumptoend:
// Disable fast mode on last packet // Disable fast mode on last packet
g_conn.block_after_ACK = false; g_conn.block_after_ACK = false;
} }
mfEmlSetMem(keyBlock, mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1, 1); mf_elm_set_mem(keyBlock, mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1, 1);
} }
PrintAndLogEx(SUCCESS, "keys transferred to emulator memory."); PrintAndLogEx(SUCCESS, "keys transferred to emulator memory.");
} }
@ -2417,7 +2417,7 @@ static int CmdHF14AMfNestedHard(const char *Cmd) {
uint64_t key64 = 0; uint64_t key64 = 0;
// check if we can authenticate to sector // check if we can authenticate to sector
if (mfCheckKeys(blockno, keytype, true, 1, key, &key64) != PM3_SUCCESS) { if (mf_check_keys(blockno, keytype, true, 1, key, &key64) != PM3_SUCCESS) {
if (keytype < 2) { if (keytype < 2) {
PrintAndLogEx(WARNING, "Wrong key. Can't authenticate to block:%3d key type:%c", blockno, keytype ? 'B' : 'A'); PrintAndLogEx(WARNING, "Wrong key. Can't authenticate to block:%3d key type:%c", blockno, keytype ? 'B' : 'A');
} else { } else {
@ -2791,7 +2791,7 @@ static int CmdHF14AMfAutoPWN(const char *Cmd) {
PrintAndLogEx(NORMAL, "." NOLF); PrintAndLogEx(NORMAL, "." NOLF);
fflush(stdout); fflush(stdout);
if (mfCheckKeys(mfFirstBlockOfSector(i), j, true, 1, (keyBlock + (MIFARE_KEY_SIZE * k)), &key64) == PM3_SUCCESS) { if (mf_check_keys(mfFirstBlockOfSector(i), j, true, 1, (keyBlock + (MIFARE_KEY_SIZE * k)), &key64) == PM3_SUCCESS) {
e_sector[i].Key[j] = bytes_to_num((keyBlock + (MIFARE_KEY_SIZE * k)), MIFARE_KEY_SIZE); e_sector[i].Key[j] = bytes_to_num((keyBlock + (MIFARE_KEY_SIZE * k)), MIFARE_KEY_SIZE);
e_sector[i].foundKey[j] = 'D'; e_sector[i].foundKey[j] = 'D';
break; break;
@ -2823,7 +2823,7 @@ static int CmdHF14AMfAutoPWN(const char *Cmd) {
lastChunk = true; lastChunk = true;
} }
res = mfCheckKeys_fast(sector_cnt, firstChunk, lastChunk, strategy, size, keyBlock + (i * MIFARE_KEY_SIZE), e_sector, false, verbose); res = mf_check_keys_fast(sector_cnt, firstChunk, lastChunk, strategy, size, keyBlock + (i * MIFARE_KEY_SIZE), e_sector, false, verbose);
if (firstChunk) { if (firstChunk) {
firstChunk = false; firstChunk = false;
} }
@ -2888,7 +2888,7 @@ static int CmdHF14AMfAutoPWN(const char *Cmd) {
PrintAndLogEx(NORMAL, ""); PrintAndLogEx(NORMAL, "");
isOK = mfDarkside(mfFirstBlockOfSector(sectorno), MIFARE_AUTH_KEYA + keytype, &key64); isOK = mf_dark_side(mfFirstBlockOfSector(sectorno), MIFARE_AUTH_KEYA + keytype, &key64);
if (isOK != PM3_SUCCESS) if (isOK != PM3_SUCCESS)
goto noValidKeyFound; goto noValidKeyFound;
@ -2942,7 +2942,7 @@ noValidKeyFound:
continue; continue;
// Check if the key works // Check if the key works
if (mfCheckKeys(mfFirstBlockOfSector(i), j, true, 1, tmp_key, &key64) == PM3_SUCCESS) { if (mf_check_keys(mfFirstBlockOfSector(i), j, true, 1, tmp_key, &key64) == PM3_SUCCESS) {
e_sector[i].Key[j] = bytes_to_num(tmp_key, MIFARE_KEY_SIZE); e_sector[i].Key[j] = bytes_to_num(tmp_key, MIFARE_KEY_SIZE);
e_sector[i].foundKey[j] = 'R'; e_sector[i].foundKey[j] = 'R';
PrintAndLogEx(SUCCESS, "target sector %3u key type %c -- found valid key [ " _GREEN_("%s") " ]", PrintAndLogEx(SUCCESS, "target sector %3u key type %c -- found valid key [ " _GREEN_("%s") " ]",
@ -3021,7 +3021,7 @@ skipReadBKey:
(current_key_type_i == MF_KEY_B) ? 'B' : 'A'); (current_key_type_i == MF_KEY_B) ? 'B' : 'A');
} }
tryNested: tryNested:
isOK = mfnested(mfFirstBlockOfSector(sectorno), keytype, key, mfFirstBlockOfSector(current_sector_i), current_key_type_i, tmp_key, calibrate); isOK = mf_nested(mfFirstBlockOfSector(sectorno), keytype, key, mfFirstBlockOfSector(current_sector_i), current_key_type_i, tmp_key, calibrate);
switch (isOK) { switch (isOK) {
case PM3_ETIMEOUT: { case PM3_ETIMEOUT: {
@ -3147,7 +3147,7 @@ tryStaticnested:
(current_key_type_i == MF_KEY_B) ? 'B' : 'A'); (current_key_type_i == MF_KEY_B) ? 'B' : 'A');
} }
isOK = mfStaticNested(mfFirstBlockOfSector(sectorno), keytype, key, mfFirstBlockOfSector(current_sector_i), current_key_type_i, tmp_key); isOK = mf_static_nested(mfFirstBlockOfSector(sectorno), keytype, key, mfFirstBlockOfSector(current_sector_i), current_key_type_i, tmp_key);
DropField(); DropField();
switch (isOK) { switch (isOK) {
case PM3_ETIMEOUT: { case PM3_ETIMEOUT: {
@ -3211,13 +3211,13 @@ all_found:
bool transfer_status = true; bool transfer_status = true;
for (current_sector_i = 0; current_sector_i < sector_cnt; current_sector_i++) { for (current_sector_i = 0; current_sector_i < sector_cnt; current_sector_i++) {
mfEmlGetMem(block, current_sector_i, 1); mf_eml_get_mem(block, current_sector_i, 1);
if (e_sector[current_sector_i].foundKey[0]) if (e_sector[current_sector_i].foundKey[0])
num_to_bytes(e_sector[current_sector_i].Key[0], MIFARE_KEY_SIZE, block); num_to_bytes(e_sector[current_sector_i].Key[0], MIFARE_KEY_SIZE, block);
if (e_sector[current_sector_i].foundKey[1]) if (e_sector[current_sector_i].foundKey[1])
num_to_bytes(e_sector[current_sector_i].Key[1], MIFARE_KEY_SIZE, block + 10); num_to_bytes(e_sector[current_sector_i].Key[1], MIFARE_KEY_SIZE, block + 10);
transfer_status |= mfEmlSetMem(block, mfFirstBlockOfSector(current_sector_i) + mfNumBlocksPerSector(current_sector_i) - 1, 1); transfer_status |= mf_elm_set_mem(block, mfFirstBlockOfSector(current_sector_i) + mfNumBlocksPerSector(current_sector_i) - 1, 1);
} }
PrintAndLogEx(NORMAL, "( %s )", (transfer_status) ? _GREEN_("ok") : _RED_("fail")); PrintAndLogEx(NORMAL, "( %s )", (transfer_status) ? _GREEN_("ok") : _RED_("fail"));
@ -3387,7 +3387,7 @@ static int CmdHF14AMfChk_fast(const char *Cmd) {
} }
if (use_flashmemory) { if (use_flashmemory) {
PrintAndLogEx(SUCCESS, "Using dictionary in flash memory"); PrintAndLogEx(SUCCESS, "Using dictionary in flash memory");
mfCheckKeys_fast_ex(sectorsCnt, true, true, 1, 0, keyBlock, e_sector, use_flashmemory, false, false, singleSectorParams); mf_check_keys_fast_ex(sectorsCnt, true, true, 1, 0, keyBlock, e_sector, use_flashmemory, false, false, singleSectorParams);
} else { } else {
// strategies. 1= deep first on sector 0 AB, 2= width first on all sectors // strategies. 1= deep first on sector 0 AB, 2= width first on all sectors
@ -3416,7 +3416,7 @@ static int CmdHF14AMfChk_fast(const char *Cmd) {
if (size == keycnt - i) if (size == keycnt - i)
lastChunk = true; lastChunk = true;
int res = mfCheckKeys_fast_ex(sectorsCnt, firstChunk, lastChunk, strategy, size, keyBlock + (i * MIFARE_KEY_SIZE), e_sector, false, false, true, singleSectorParams); int res = mf_check_keys_fast_ex(sectorsCnt, firstChunk, lastChunk, strategy, size, keyBlock + (i * MIFARE_KEY_SIZE), e_sector, false, false, true, singleSectorParams);
if (firstChunk) if (firstChunk)
firstChunk = false; firstChunk = false;
@ -3474,7 +3474,7 @@ out:
uint8_t block[MFBLOCK_SIZE] = {0x00}; uint8_t block[MFBLOCK_SIZE] = {0x00};
for (i = 0; i < sectorsCnt; ++i) { for (i = 0; i < sectorsCnt; ++i) {
uint8_t b = mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1; uint8_t b = mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1;
mfEmlGetMem(block, b, 1); mf_eml_get_mem(block, b, 1);
if (e_sector[i].foundKey[0]) if (e_sector[i].foundKey[0])
num_to_bytes(e_sector[i].Key[0], MIFARE_KEY_SIZE, block); num_to_bytes(e_sector[i].Key[0], MIFARE_KEY_SIZE, block);
@ -3486,7 +3486,7 @@ out:
// Disable fast mode on last packet // Disable fast mode on last packet
g_conn.block_after_ACK = false; g_conn.block_after_ACK = false;
} }
mfEmlSetMem(block, b, 1); mf_elm_set_mem(block, b, 1);
} }
PrintAndLogEx(SUCCESS, "Found keys have been transferred to the emulator memory"); PrintAndLogEx(SUCCESS, "Found keys have been transferred to the emulator memory");
@ -3644,7 +3644,7 @@ static int CmdHF14AMfSmartBrute(const char *Cmd) {
} }
int strategy = 2; // width first on all sectors int strategy = 2; // width first on all sectors
ret = mfCheckKeys_fast(sectorsCnt, firstChunk, lastChunk, strategy, keycnt, keyBlock, e_sector, false, false); ret = mf_check_keys_fast(sectorsCnt, firstChunk, lastChunk, strategy, keycnt, keyBlock, e_sector, false, false);
keys_checked += keycnt; keys_checked += keycnt;
total_keys_checked += keycnt; total_keys_checked += keycnt;
@ -3688,7 +3688,7 @@ out:
uint8_t block[MFBLOCK_SIZE] = {0x00}; uint8_t block[MFBLOCK_SIZE] = {0x00};
for (i = 0; i < sectorsCnt; ++i) { for (i = 0; i < sectorsCnt; ++i) {
uint8_t b = mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1; uint8_t b = mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1;
mfEmlGetMem(block, b, 1); mf_eml_get_mem(block, b, 1);
if (e_sector[i].foundKey[0]) if (e_sector[i].foundKey[0])
num_to_bytes(e_sector[i].Key[0], MIFARE_KEY_SIZE, block); num_to_bytes(e_sector[i].Key[0], MIFARE_KEY_SIZE, block);
@ -3700,7 +3700,7 @@ out:
// Disable fast mode on last packet // Disable fast mode on last packet
g_conn.block_after_ACK = false; g_conn.block_after_ACK = false;
} }
mfEmlSetMem(block, b, 1); mf_elm_set_mem(block, b, 1);
} }
PrintAndLogEx(SUCCESS, "Found keys have been transferred to the emulator memory"); PrintAndLogEx(SUCCESS, "Found keys have been transferred to the emulator memory");
@ -3895,7 +3895,7 @@ static int CmdHF14AMfChk(const char *Cmd) {
uint32_t size = keycnt - c > max_keys ? max_keys : keycnt - c; uint32_t size = keycnt - c > max_keys ? max_keys : keycnt - c;
if (mfCheckKeys(b, trgKeyType, clearLog, size, &keyBlock[MIFARE_KEY_SIZE * c], &key64) == PM3_SUCCESS) { if (mf_check_keys(b, trgKeyType, clearLog, size, &keyBlock[MIFARE_KEY_SIZE * c], &key64) == PM3_SUCCESS) {
e_sector[i].Key[trgKeyType] = key64; e_sector[i].Key[trgKeyType] = key64;
e_sector[i].foundKey[trgKeyType] = true; e_sector[i].foundKey[trgKeyType] = true;
clearLog = false; clearLog = false;
@ -3972,7 +3972,7 @@ out:
uint8_t block[MFBLOCK_SIZE] = {0x00}; uint8_t block[MFBLOCK_SIZE] = {0x00};
for (int i = 0; i < sectors_cnt; ++i) { for (int i = 0; i < sectors_cnt; ++i) {
uint8_t blockno = mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1; uint8_t blockno = mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1;
mfEmlGetMem(block, blockno, 1); mf_eml_get_mem(block, blockno, 1);
if (e_sector[i].foundKey[0]) if (e_sector[i].foundKey[0])
num_to_bytes(e_sector[i].Key[0], MIFARE_KEY_SIZE, block); num_to_bytes(e_sector[i].Key[0], MIFARE_KEY_SIZE, block);
@ -3984,7 +3984,7 @@ out:
// Disable fast mode on last packet // Disable fast mode on last packet
g_conn.block_after_ACK = false; g_conn.block_after_ACK = false;
} }
mfEmlSetMem(block, blockno, 1); mf_elm_set_mem(block, blockno, 1);
} }
PrintAndLogEx(SUCCESS, "Found keys have been transferred to the emulator memory"); PrintAndLogEx(SUCCESS, "Found keys have been transferred to the emulator memory");
} }
@ -4051,7 +4051,7 @@ void readerAttack(sector_t *k_sector, size_t k_sectors_cnt, nonces_t data, bool
//set emulator memory for keys //set emulator memory for keys
if (setEmulatorMem) { if (setEmulatorMem) {
uint8_t memBlock[16]; uint8_t memBlock[16];
mfEmlGetMem(memBlock, (sector * 4) + 3, 1); mf_eml_get_mem(memBlock, (sector * 4) + 3, 1);
if ((memBlock[6] == 0) && (memBlock[7] == 0) && (memBlock[8] == 0)) { if ((memBlock[6] == 0) && (memBlock[7] == 0) && (memBlock[8] == 0)) {
// ACL not yet set? // ACL not yet set?
memBlock[6] = 0xFF; memBlock[6] = 0xFF;
@ -4064,7 +4064,7 @@ void readerAttack(sector_t *k_sector, size_t k_sectors_cnt, nonces_t data, bool
, (sector * 4) + 3 , (sector * 4) + 3
, sprint_hex(memBlock, sizeof(memBlock)) , sprint_hex(memBlock, sizeof(memBlock))
); );
mfEmlSetMem(memBlock, (sector * 4) + 3, 1); mf_elm_set_mem(memBlock, (sector * 4) + 3, 1);
} }
} }
@ -4471,7 +4471,7 @@ static int CmdHF14AMfEGetBlk(const char *Cmd) {
uint8_t blockno = (uint8_t)b; uint8_t blockno = (uint8_t)b;
uint8_t data[16] = {0x00}; uint8_t data[16] = {0x00};
if (mfEmlGetMem(data, blockno, 1) == PM3_SUCCESS) { if (mf_eml_get_mem(data, blockno, 1) == PM3_SUCCESS) {
uint8_t sector = mfSectorNum(blockno); uint8_t sector = mfSectorNum(blockno);
mf_print_sector_hdr(sector); mf_print_sector_hdr(sector);
@ -4515,7 +4515,7 @@ static int CmdHF14AMfEGetSc(const char *Cmd) {
uint8_t data[16] = {0}; uint8_t data[16] = {0};
for (int i = 0; i < blocks; i++) { for (int i = 0; i < blocks; i++) {
int res = mfEmlGetMem(data, start + i, 1); int res = mf_eml_get_mem(data, start + i, 1);
if (res == PM3_SUCCESS) { if (res == PM3_SUCCESS) {
mf_print_block_one(start + i, data, verbose); mf_print_block_one(start + i, data, verbose);
} }
@ -4581,7 +4581,7 @@ static int CmdHF14AMfESet(const char *Cmd) {
} }
// 1 - blocks count // 1 - blocks count
return mfEmlSetMem(data, b, 1); return mf_elm_set_mem(data, b, 1);
} }
int CmdHF14AMfELoad(const char *Cmd) { int CmdHF14AMfELoad(const char *Cmd) {
@ -4734,7 +4734,7 @@ int CmdHF14AMfELoad(const char *Cmd) {
size_t offset = 0; size_t offset = 0;
int cnt = 0; int cnt = 0;
// 12 is the size of the struct the fct mfEmlSetMem_xt uses to transfer to device // 12 is the size of the struct the fct mf_eml_set_mem_xt uses to transfer to device
uint16_t max_avail_blocks = ((PM3_CMD_DATA_SIZE - 12) / block_width) * block_width; uint16_t max_avail_blocks = ((PM3_CMD_DATA_SIZE - 12) / block_width) * block_width;
while (bytes_read && cnt < block_cnt) { while (bytes_read && cnt < block_cnt) {
@ -4746,7 +4746,7 @@ int CmdHF14AMfELoad(const char *Cmd) {
uint16_t chunk_size = MIN(max_avail_blocks, bytes_read); uint16_t chunk_size = MIN(max_avail_blocks, bytes_read);
uint16_t blocks_to_send = chunk_size / block_width; uint16_t blocks_to_send = chunk_size / block_width;
if (mfEmlSetMem_xt(data + offset, cnt, blocks_to_send, block_width) != PM3_SUCCESS) { if (mf_eml_set_mem_xt(data + offset, cnt, blocks_to_send, block_width) != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Can't set emulator mem at block: %3d", cnt); PrintAndLogEx(FAILED, "Can't set emulator mem at block: %3d", cnt);
free(data); free(data);
return PM3_ESOFT; return PM3_ESOFT;
@ -5096,7 +5096,7 @@ static int CmdHF14AMfEKeyPrn(const char *Cmd) {
// read UID from EMUL // read UID from EMUL
uint8_t data[16]; uint8_t data[16];
if (mfEmlGetMem(data, 0, 1) != PM3_SUCCESS) { if (mf_eml_get_mem(data, 0, 1) != PM3_SUCCESS) {
PrintAndLogEx(WARNING, "error get block 0"); PrintAndLogEx(WARNING, "error get block 0");
free(e_sector); free(e_sector);
return PM3_ESOFT; return PM3_ESOFT;
@ -5109,7 +5109,7 @@ static int CmdHF14AMfEKeyPrn(const char *Cmd) {
// download keys from EMUL // download keys from EMUL
for (int i = 0; i < sectors_cnt; i++) { for (int i = 0; i < sectors_cnt; i++) {
if (mfEmlGetMem(data, mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1, 1) != PM3_SUCCESS) { if (mf_eml_get_mem(data, mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1, 1) != PM3_SUCCESS) {
PrintAndLogEx(WARNING, "error get block %d", mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1); PrintAndLogEx(WARNING, "error get block %d", mfFirstBlockOfSector(i) + mfNumBlocksPerSector(i) - 1);
e_sector[i].foundKey[0] = false; e_sector[i].foundKey[0] = false;
e_sector[i].foundKey[1] = false; e_sector[i].foundKey[1] = false;
@ -5191,7 +5191,7 @@ static int CmdHF14AMfCSetUID(const char *Cmd) {
uint8_t old_uid[7] = {0}; uint8_t old_uid[7] = {0};
uint8_t verify_uid[7] = {0}; uint8_t verify_uid[7] = {0};
int res = mfCSetUID( int res = mf_chinese_set_uid(
uid, uid,
uidlen, uidlen,
(alen) ? atqa : NULL, (alen) ? atqa : NULL,
@ -5262,7 +5262,7 @@ static int CmdHF14AMfCWipe(const char *cmd) {
return PM3_EINVARG; return PM3_EINVARG;
} }
int res = mfCWipe((uidlen) ? uid : NULL, (alen) ? atqa : NULL, (slen) ? sak : NULL, gdm); int res = mf_chinese_wipe((uidlen) ? uid : NULL, (alen) ? atqa : NULL, (slen) ? sak : NULL, gdm);
if (res) { if (res) {
PrintAndLogEx(ERR, "Can't wipe card. error %d", res); PrintAndLogEx(ERR, "Can't wipe card. error %d", res);
return PM3_ESOFT; return PM3_ESOFT;
@ -5322,7 +5322,7 @@ static int CmdHF14AMfCSetBlk(const char *Cmd) {
PrintAndLogEx(INFO, "Writing block number:%2d data:%s", b, sprint_hex_inrow(data, sizeof(data))); PrintAndLogEx(INFO, "Writing block number:%2d data:%s", b, sprint_hex_inrow(data, sizeof(data)));
int res = mfCSetBlock(b, data, NULL, params); int res = mf_chinese_set_block(b, data, NULL, params);
if (res) { if (res) {
PrintAndLogEx(ERR, "Can't write block. error=%d", res); PrintAndLogEx(ERR, "Can't write block. error=%d", res);
return PM3_ESOFT; return PM3_ESOFT;
@ -5403,7 +5403,7 @@ static int CmdHF14AMfCLoad(const char *Cmd) {
uint8_t buf8[MFBLOCK_SIZE] = {0x00}; uint8_t buf8[MFBLOCK_SIZE] = {0x00};
// read from emul memory // read from emul memory
if (mfEmlGetMem(buf8, b, 1)) { if (mf_eml_get_mem(buf8, b, 1)) {
PrintAndLogEx(WARNING, "Can't read from emul block: %d", b); PrintAndLogEx(WARNING, "Can't read from emul block: %d", b);
return PM3_ESOFT; return PM3_ESOFT;
} }
@ -5424,7 +5424,7 @@ static int CmdHF14AMfCLoad(const char *Cmd) {
} }
// write to card // write to card
if (mfCSetBlock(b, buf8, NULL, flags)) { if (mf_chinese_set_block(b, buf8, NULL, flags)) {
PrintAndLogEx(WARNING, "Can't set magic card block: %d", b); PrintAndLogEx(WARNING, "Can't set magic card block: %d", b);
return PM3_ESOFT; return PM3_ESOFT;
} }
@ -5471,7 +5471,7 @@ static int CmdHF14AMfCLoad(const char *Cmd) {
flags = MAGIC_HALT + MAGIC_OFF; flags = MAGIC_HALT + MAGIC_OFF;
} }
if (mfCSetBlock(blockno, data + (MFBLOCK_SIZE * blockno), NULL, flags)) { if (mf_chinese_set_block(blockno, data + (MFBLOCK_SIZE * blockno), NULL, flags)) {
PrintAndLogEx(WARNING, "Can't set magic card block: %d", blockno); PrintAndLogEx(WARNING, "Can't set magic card block: %d", blockno);
free(data); free(data);
return PM3_ESOFT; return PM3_ESOFT;
@ -5528,7 +5528,7 @@ static int CmdHF14AMfCGetBlk(const char *Cmd) {
uint8_t blockno = (uint8_t)b; uint8_t blockno = (uint8_t)b;
uint8_t data[16] = {0}; uint8_t data[16] = {0};
int res = mfCGetBlock(blockno, data, MAGIC_SINGLE | (gdm ? MAGIC_GDM_ALT_WUPC : MAGIC_WUPC)); int res = mf_chinese_get_block(blockno, data, MAGIC_SINGLE | (gdm ? MAGIC_GDM_ALT_WUPC : MAGIC_WUPC));
if (res) { if (res) {
PrintAndLogEx(ERR, "Can't read block. error=%d", res); PrintAndLogEx(ERR, "Can't read block. error=%d", res);
return PM3_ESOFT; return PM3_ESOFT;
@ -5587,7 +5587,7 @@ static int CmdHF14AMfCGetSc(const char *Cmd) {
if (i == 1) flags = 0; if (i == 1) flags = 0;
if (i == blocks - 1) flags = MAGIC_HALT + MAGIC_OFF; if (i == blocks - 1) flags = MAGIC_HALT + MAGIC_OFF;
int res = mfCGetBlock(start + i, data, flags); int res = mf_chinese_get_block(start + i, data, flags);
if (res) { if (res) {
PrintAndLogEx(ERR, "Can't read block. %d error=%d", start + i, res); PrintAndLogEx(ERR, "Can't read block. %d error=%d", start + i, res);
return PM3_ESOFT; return PM3_ESOFT;
@ -5712,7 +5712,7 @@ static int CmdHF14AMfCSave(const char *Cmd) {
flags = MAGIC_HALT + MAGIC_OFF; flags = MAGIC_HALT + MAGIC_OFF;
} }
if (mfCGetBlock(i, dump + (i * MFBLOCK_SIZE), flags)) { if (mf_chinese_get_block(i, dump + (i * MFBLOCK_SIZE), flags)) {
PrintAndLogEx(WARNING, "Can't get magic card block: %d", i); PrintAndLogEx(WARNING, "Can't get magic card block: %d", i);
PrintAndLogEx(HINT, "Verify your card size, and try again or try another tag position"); PrintAndLogEx(HINT, "Verify your card size, and try again or try another tag position");
free(dump); free(dump);
@ -5733,7 +5733,7 @@ static int CmdHF14AMfCSave(const char *Cmd) {
// Disable fast mode on last packet // Disable fast mode on last packet
g_conn.block_after_ACK = false; g_conn.block_after_ACK = false;
} }
if (mfEmlSetMem(dump + (i * MFBLOCK_SIZE), i, 5) != PM3_SUCCESS) { if (mf_elm_set_mem(dump + (i * MFBLOCK_SIZE), i, 5) != PM3_SUCCESS) {
PrintAndLogEx(WARNING, "Can't set emul block: " _YELLOW_("%d"), i); PrintAndLogEx(WARNING, "Can't set emul block: " _YELLOW_("%d"), i);
} }
if (i % 64 == 0) { if (i % 64 == 0) {
@ -5861,7 +5861,7 @@ static int CmdHF14AMfCView(const char *Cmd) {
flags = MAGIC_HALT + MAGIC_OFF; flags = MAGIC_HALT + MAGIC_OFF;
} }
if (mfCGetBlock(i, dump + (i * MFBLOCK_SIZE), flags)) { if (mf_chinese_get_block(i, dump + (i * MFBLOCK_SIZE), flags)) {
PrintAndLogEx(WARNING, "Can't get magic card block: " _YELLOW_("%u"), i); PrintAndLogEx(WARNING, "Can't get magic card block: " _YELLOW_("%u"), i);
PrintAndLogEx(HINT, "Verify your card size, and try again or try another tag position"); PrintAndLogEx(HINT, "Verify your card size, and try again or try another tag position");
free(dump); free(dump);
@ -5934,7 +5934,7 @@ static int CmdHf14AMfDecryptBytes(const char *Cmd) {
PrintAndLogEx(INFO, "ar enc... %08X", ar_enc); PrintAndLogEx(INFO, "ar enc... %08X", ar_enc);
PrintAndLogEx(INFO, "at enc... %08X", at_enc); PrintAndLogEx(INFO, "at enc... %08X", at_enc);
return tryDecryptWord(nt, ar_enc, at_enc, data, datalen); return try_decrypt_word(nt, ar_enc, at_enc, data, datalen);
} }
static int CmdHf14AMfSetMod(const char *Cmd) { static int CmdHf14AMfSetMod(const char *Cmd) {
@ -6301,7 +6301,7 @@ static int CmdHF14AMfMAD(const char *Cmd) {
uint8_t sector10[MFBLOCK_SIZE * 4] = {0}; uint8_t sector10[MFBLOCK_SIZE * 4] = {0};
bool got_first = true; bool got_first = true;
if (mfReadSector(MF_MAD1_SECTOR, MF_KEY_A, (uint8_t *)g_mifare_mad_key, sector0) != PM3_SUCCESS) { if (mf_read_sector(MF_MAD1_SECTOR, MF_KEY_A, (uint8_t *)g_mifare_mad_key, sector0) != PM3_SUCCESS) {
PrintAndLogEx(WARNING, "error, read sector 0. card doesn't have MAD or doesn't have MAD on default keys"); PrintAndLogEx(WARNING, "error, read sector 0. card doesn't have MAD or doesn't have MAD on default keys");
got_first = false; got_first = false;
} else { } else {
@ -6311,7 +6311,7 @@ static int CmdHF14AMfMAD(const char *Cmd) {
// User supplied key // User supplied key
if (got_first == false && keylen == 6) { if (got_first == false && keylen == 6) {
PrintAndLogEx(INFO, "Trying user specified key..."); PrintAndLogEx(INFO, "Trying user specified key...");
if (mfReadSector(MF_MAD1_SECTOR, MF_KEY_A, userkey, sector0) != PM3_SUCCESS) { if (mf_read_sector(MF_MAD1_SECTOR, MF_KEY_A, userkey, sector0) != PM3_SUCCESS) {
PrintAndLogEx(ERR, "error, read sector 0. card doesn't have MAD or the custom key is wrong"); PrintAndLogEx(ERR, "error, read sector 0. card doesn't have MAD or the custom key is wrong");
} else { } else {
PrintAndLogEx(INFO, "Authentication ( " _GREEN_("ok") " )"); PrintAndLogEx(INFO, "Authentication ( " _GREEN_("ok") " )");
@ -6325,7 +6325,7 @@ static int CmdHF14AMfMAD(const char *Cmd) {
} }
got_first = true; got_first = true;
if (mfReadSector(MF_MAD2_SECTOR, MF_KEY_A, (uint8_t *)g_mifare_mad_key, sector10) != PM3_SUCCESS) { if (mf_read_sector(MF_MAD2_SECTOR, MF_KEY_A, (uint8_t *)g_mifare_mad_key, sector10) != PM3_SUCCESS) {
if (verbose) { if (verbose) {
PrintAndLogEx(ERR, "error, read sector 0x10. card doesn't have MAD 2 or doesn't have MAD 2 on default keys"); PrintAndLogEx(ERR, "error, read sector 0x10. card doesn't have MAD 2 or doesn't have MAD 2 on default keys");
} }
@ -6337,7 +6337,7 @@ static int CmdHF14AMfMAD(const char *Cmd) {
// User supplied key // User supplied key
if (got_first == false && keylen == 6) { if (got_first == false && keylen == 6) {
PrintAndLogEx(INFO, "Trying user specified key..."); PrintAndLogEx(INFO, "Trying user specified key...");
if (mfReadSector(MF_MAD2_SECTOR, MF_KEY_A, userkey, sector10) != PM3_SUCCESS) { if (mf_read_sector(MF_MAD2_SECTOR, MF_KEY_A, userkey, sector10) != PM3_SUCCESS) {
if (verbose) { if (verbose) {
PrintAndLogEx(ERR, "error, read sector 10. card doesn't have MAD 2 or the custom key is wrong"); PrintAndLogEx(ERR, "error, read sector 10. card doesn't have MAD 2 or the custom key is wrong");
} }
@ -6383,7 +6383,7 @@ static int CmdHF14AMfMAD(const char *Cmd) {
for (int i = 0; i < madlen; i++) { for (int i = 0; i < madlen; i++) {
if (aaid == mad[i]) { if (aaid == mad[i]) {
uint8_t vsector[MFBLOCK_SIZE * 4] = {0}; uint8_t vsector[MFBLOCK_SIZE * 4] = {0};
if (mfReadSector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, akey, vsector)) { if (mf_read_sector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, akey, vsector)) {
PrintAndLogEx(NORMAL, ""); PrintAndLogEx(NORMAL, "");
PrintAndLogEx(ERR, "error, read sector %d", i + 1); PrintAndLogEx(ERR, "error, read sector %d", i + 1);
return PM3_ESOFT; return PM3_ESOFT;
@ -6407,7 +6407,7 @@ static int CmdHF14AMfMAD(const char *Cmd) {
if (aaid == mad[i]) { if (aaid == mad[i]) {
uint8_t vsector[MFBLOCK_SIZE * 4] = {0}; uint8_t vsector[MFBLOCK_SIZE * 4] = {0};
if (mfReadSector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, akey, vsector)) { if (mf_read_sector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, akey, vsector)) {
PrintAndLogEx(NORMAL, ""); PrintAndLogEx(NORMAL, "");
PrintAndLogEx(ERR, "error, read sector %d", i + 1); PrintAndLogEx(ERR, "error, read sector %d", i + 1);
return PM3_ESOFT; return PM3_ESOFT;
@ -6504,7 +6504,7 @@ int CmdHFMFNDEFRead(const char *Cmd) {
PrintAndLogEx(INFO, "reading MAD v1 sector"); PrintAndLogEx(INFO, "reading MAD v1 sector");
} }
if (mfReadSector(MF_MAD1_SECTOR, MF_KEY_A, g_mifare_mad_key, sector0)) { if (mf_read_sector(MF_MAD1_SECTOR, MF_KEY_A, g_mifare_mad_key, sector0)) {
PrintAndLogEx(ERR, "error, read sector 0. card doesn't have MAD or doesn't have MAD on default keys"); PrintAndLogEx(ERR, "error, read sector 0. card doesn't have MAD or doesn't have MAD on default keys");
PrintAndLogEx(HINT, "Try " _YELLOW_("`hf mf ndefread -k `") " with your custom key"); PrintAndLogEx(HINT, "Try " _YELLOW_("`hf mf ndefread -k `") " with your custom key");
return PM3_ESOFT; return PM3_ESOFT;
@ -6514,7 +6514,7 @@ int CmdHFMFNDEFRead(const char *Cmd) {
PrintAndLogEx(INFO, "reading MAD v2 sector"); PrintAndLogEx(INFO, "reading MAD v2 sector");
} }
if (mfReadSector(MF_MAD2_SECTOR, MF_KEY_A, g_mifare_mad_key, sector10)) { if (mf_read_sector(MF_MAD2_SECTOR, MF_KEY_A, g_mifare_mad_key, sector10)) {
if (verbose) { if (verbose) {
PrintAndLogEx(ERR, "error, read sector 0x10. card doesn't have MAD 2 or doesn't have MAD 2 on default keys"); PrintAndLogEx(ERR, "error, read sector 0x10. card doesn't have MAD 2 or doesn't have MAD 2 on default keys");
PrintAndLogEx(INFO, "Skipping MAD 2"); PrintAndLogEx(INFO, "Skipping MAD 2");
@ -6540,7 +6540,7 @@ int CmdHFMFNDEFRead(const char *Cmd) {
for (int i = 0; i < madlen; i++) { for (int i = 0; i < madlen; i++) {
if (ndef_aid == mad[i]) { if (ndef_aid == mad[i]) {
uint8_t vsector[MFBLOCK_SIZE * 4] = {0}; uint8_t vsector[MFBLOCK_SIZE * 4] = {0};
if (mfReadSector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, ndefkey, vsector)) { if (mf_read_sector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, ndefkey, vsector)) {
PrintAndLogEx(ERR, "error, reading sector %d ", i + 1); PrintAndLogEx(ERR, "error, reading sector %d ", i + 1);
return PM3_ESOFT; return PM3_ESOFT;
} }
@ -6689,7 +6689,7 @@ int CmdHFMFNDEFFormat(const char *Cmd) {
uint64_t key64 = 0; uint64_t key64 = 0;
// check if we can authenticate to sector // check if we can authenticate to sector
if (mfCheckKeys(0, MF_KEY_A, true, 1, (uint8_t *)g_mifare_mad_key, &key64) == PM3_SUCCESS) { if (mf_check_keys(0, MF_KEY_A, true, 1, (uint8_t *)g_mifare_mad_key, &key64) == PM3_SUCCESS) {
// if used, assume KEY A is MAD/NDEF set. // if used, assume KEY A is MAD/NDEF set.
memcpy(keyA[0], g_mifare_mad_key, sizeof(g_mifare_mad_key)); memcpy(keyA[0], g_mifare_mad_key, sizeof(g_mifare_mad_key));
@ -6771,9 +6771,9 @@ skipfile:
} }
// write to card, try B key first // write to card, try B key first
if (mfWriteBlock(b, MF_KEY_B, keyB[i], block) != PM3_SUCCESS) { if (mf_write_block(b, MF_KEY_B, keyB[i], block) != PM3_SUCCESS) {
// try A key, // try A key,
if (mfWriteBlock(b, MF_KEY_A, keyA[i], block) != PM3_SUCCESS) { if (mf_write_block(b, MF_KEY_A, keyA[i], block) != PM3_SUCCESS) {
return PM3_EFAILED; return PM3_EFAILED;
} }
} }
@ -6868,7 +6868,7 @@ int CmdHFMFNDEFWrite(const char *Cmd) {
uint64_t key64 = 0; uint64_t key64 = 0;
// check if we can authenticate to sector // check if we can authenticate to sector
int res = mfCheckKeys(0, MF_KEY_A, true, 1, (uint8_t *)g_mifare_mad_key, &key64); int res = mf_check_keys(0, MF_KEY_A, true, 1, (uint8_t *)g_mifare_mad_key, &key64);
if (res != PM3_SUCCESS) { if (res != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Sector 0 failed to authenticate with MAD default key"); PrintAndLogEx(FAILED, "Sector 0 failed to authenticate with MAD default key");
PrintAndLogEx(HINT, "Verify that the tag NDEF formatted"); PrintAndLogEx(HINT, "Verify that the tag NDEF formatted");
@ -6943,7 +6943,7 @@ int CmdHFMFNDEFWrite(const char *Cmd) {
// read MAD Sector 0, block1,2 // read MAD Sector 0, block1,2
uint8_t sector0[MFBLOCK_SIZE * 4] = {0}; uint8_t sector0[MFBLOCK_SIZE * 4] = {0};
if (mfReadSector(MF_MAD1_SECTOR, MF_KEY_A, g_mifare_mad_key, sector0)) { if (mf_read_sector(MF_MAD1_SECTOR, MF_KEY_A, g_mifare_mad_key, sector0)) {
PrintAndLogEx(ERR, "error, reading sector 0. Card doesn't have MAD or doesn't have MAD on default keys"); PrintAndLogEx(ERR, "error, reading sector 0. Card doesn't have MAD or doesn't have MAD on default keys");
PrintAndLogEx(HINT, "Try " _YELLOW_("`hf mf ndefread -k `") " with your custom key"); PrintAndLogEx(HINT, "Try " _YELLOW_("`hf mf ndefread -k `") " with your custom key");
return PM3_ESOFT; return PM3_ESOFT;
@ -6952,7 +6952,7 @@ int CmdHFMFNDEFWrite(const char *Cmd) {
// read MAD Sector 10, block1,2 // read MAD Sector 10, block1,2
uint8_t sector10[MFBLOCK_SIZE * 4] = {0}; uint8_t sector10[MFBLOCK_SIZE * 4] = {0};
if (m4) { if (m4) {
if (mfReadSector(MF_MAD2_SECTOR, MF_KEY_A, g_mifare_mad_key, sector10)) { if (mf_read_sector(MF_MAD2_SECTOR, MF_KEY_A, g_mifare_mad_key, sector10)) {
PrintAndLogEx(ERR, "error, reading sector 10. Card doesn't have MAD or doesn't have MAD on default keys"); PrintAndLogEx(ERR, "error, reading sector 10. Card doesn't have MAD or doesn't have MAD on default keys");
PrintAndLogEx(HINT, "Try " _YELLOW_("`hf mf ndefread -k `") " with your custom key"); PrintAndLogEx(HINT, "Try " _YELLOW_("`hf mf ndefread -k `") " with your custom key");
return PM3_ESOFT; return PM3_ESOFT;
@ -7014,11 +7014,11 @@ int CmdHFMFNDEFWrite(const char *Cmd) {
} }
// write to card, try B key first // write to card, try B key first
if (mfWriteBlock(block_no, MF_KEY_B, g_mifare_default_key, block) != PM3_SUCCESS) { if (mf_write_block(block_no, MF_KEY_B, g_mifare_default_key, block) != PM3_SUCCESS) {
// try A key, // try A key,
if (mfWriteBlock(block_no, MF_KEY_A, g_mifare_ndef_key, block) != PM3_SUCCESS) { if (mf_write_block(block_no, MF_KEY_A, g_mifare_ndef_key, block) != PM3_SUCCESS) {
return PM3_EFAILED; return PM3_EFAILED;
} }
} }
@ -7173,7 +7173,7 @@ static int CmdHf14AGen3UID(const char *Cmd) {
uint8_t old_uid[10] = {0}; uint8_t old_uid[10] = {0};
int res = mfGen3UID(uid, uidlen, old_uid); int res = mf_chinese_gen_3_uid(uid, uidlen, old_uid);
if (res != PM3_SUCCESS) { if (res != PM3_SUCCESS) {
PrintAndLogEx(ERR, "Can't set UID"); PrintAndLogEx(ERR, "Can't set UID");
PrintAndLogEx(HINT, "Are you sure your card is a Gen3 ?"); PrintAndLogEx(HINT, "Are you sure your card is a Gen3 ?");
@ -7213,7 +7213,7 @@ static int CmdHf14AGen3Block(const char *Cmd) {
CLIParserFree(ctx); CLIParserFree(ctx);
uint8_t new_block[MFBLOCK_SIZE] = {0x00}; uint8_t new_block[MFBLOCK_SIZE] = {0x00};
int res = mfGen3Block(data, datalen, new_block); int res = mf_chinese_gen_3_block(data, datalen, new_block);
if (res) { if (res) {
PrintAndLogEx(ERR, "Can't change manufacturer block data. error %d", res); PrintAndLogEx(ERR, "Can't change manufacturer block data. error %d", res);
return PM3_ESOFT; return PM3_ESOFT;
@ -7244,7 +7244,7 @@ static int CmdHf14AGen3Freeze(const char *Cmd) {
return PM3_SUCCESS; return PM3_SUCCESS;
} }
int res = mfGen3Freeze(); int res = mf_chinese_gen_3_freeze();
if (res != PM3_SUCCESS) { if (res != PM3_SUCCESS) {
PrintAndLogEx(ERR, "Can't lock UID changes. error %d", res); PrintAndLogEx(ERR, "Can't lock UID changes. error %d", res);
} else { } else {
@ -8696,7 +8696,7 @@ static int CmdHF14AGen4Save(const char *Cmd) {
int cnt = 0; int cnt = 0;
uint16_t bytes_left = bytes ; uint16_t bytes_left = bytes ;
// 12 is the size of the struct the fct mfEmlSetMem_xt uses to transfer to device // 12 is the size of the struct the fct mf_eml_set_mem_xt uses to transfer to device
uint16_t max_avail_blocks = ((PM3_CMD_DATA_SIZE - 12) / MFBLOCK_SIZE) * MFBLOCK_SIZE; uint16_t max_avail_blocks = ((PM3_CMD_DATA_SIZE - 12) / MFBLOCK_SIZE) * MFBLOCK_SIZE;
while (bytes_left > 0 && cnt < block_cnt) { while (bytes_left > 0 && cnt < block_cnt) {
@ -8708,7 +8708,7 @@ static int CmdHF14AGen4Save(const char *Cmd) {
uint16_t chunk_size = MIN(max_avail_blocks, bytes_left); uint16_t chunk_size = MIN(max_avail_blocks, bytes_left);
uint16_t blocks_to_send = chunk_size / MFBLOCK_SIZE; uint16_t blocks_to_send = chunk_size / MFBLOCK_SIZE;
if (mfEmlSetMem_xt(dump + offset, cnt, blocks_to_send, MFBLOCK_SIZE) != PM3_SUCCESS) { if (mf_eml_set_mem_xt(dump + offset, cnt, blocks_to_send, MFBLOCK_SIZE) != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Can't set emulator mem at block: %3d", cnt); PrintAndLogEx(FAILED, "Can't set emulator mem at block: %3d", cnt);
free(dump); free(dump);
return PM3_ESOFT; return PM3_ESOFT;
@ -9364,12 +9364,12 @@ static int CmdHF14AMfValue(const char *Cmd) {
// already have data from command line // already have data from command line
} else { } else {
if (trnval == -1) { if (trnval == -1) {
res = mfReadBlock(blockno, keytype, key, data); res = mf_read_block(blockno, keytype, key, data);
} else { } else {
if (mfSectorNum(trnval) != mfSectorNum(blockno)) if (mfSectorNum(trnval) != mfSectorNum(blockno))
res = mfReadBlock(trnval, transferkeytype, transferkey, data); res = mf_read_block(trnval, transferkeytype, transferkey, data);
else else
res = mfReadBlock(trnval, keytype, key, data); res = mf_read_block(trnval, keytype, key, data);
} }
} }
@ -9495,8 +9495,8 @@ static int CmdHFMFHidEncode(const char *Cmd) {
PrintAndLogEx(INFO, "Writing %u - %s", (i + 1), sprint_hex_inrow(blocks + (i * MFBLOCK_SIZE), MFBLOCK_SIZE)); PrintAndLogEx(INFO, "Writing %u - %s", (i + 1), sprint_hex_inrow(blocks + (i * MFBLOCK_SIZE), MFBLOCK_SIZE));
} }
if (mfWriteBlock((i + 1), MF_KEY_A, empty, blocks + (i * MFBLOCK_SIZE)) == PM3_EFAILED) { if (mf_write_block((i + 1), MF_KEY_A, empty, blocks + (i * MFBLOCK_SIZE)) == PM3_EFAILED) {
if (mfWriteBlock((i + 1), MF_KEY_B, empty, blocks + (i * MFBLOCK_SIZE)) == PM3_EFAILED) { if (mf_write_block((i + 1), MF_KEY_B, empty, blocks + (i * MFBLOCK_SIZE)) == PM3_EFAILED) {
PrintAndLogEx(WARNING, "failed writing block %d using default empty key", (i + 1)); PrintAndLogEx(WARNING, "failed writing block %d using default empty key", (i + 1));
res = false; res = false;
break; break;
@ -9636,14 +9636,14 @@ static int CmdHF14AMfInfo(const char *Cmd) {
} }
uint8_t blockdata[MFBLOCK_SIZE] = {0}; uint8_t blockdata[MFBLOCK_SIZE] = {0};
res = mfCheckKeys_fast(sectorsCnt, true, true, 1, keycnt, keyBlock, e_sector, false, verbose); res = mf_check_keys_fast(sectorsCnt, true, true, 1, keycnt, keyBlock, e_sector, false, verbose);
if (res == PM3_SUCCESS || res == PM3_EPARTIAL) { if (res == PM3_SUCCESS || res == PM3_EPARTIAL) {
if (e_sector[0].foundKey[MF_KEY_A]) { if (e_sector[0].foundKey[MF_KEY_A]) {
PrintAndLogEx(SUCCESS, "Sector 0 key A... " _GREEN_("%012" PRIX64), e_sector[0].Key[MF_KEY_A]); PrintAndLogEx(SUCCESS, "Sector 0 key A... " _GREEN_("%012" PRIX64), e_sector[0].Key[MF_KEY_A]);
num_to_bytes(e_sector[0].Key[MF_KEY_A], MIFARE_KEY_SIZE, fkey); num_to_bytes(e_sector[0].Key[MF_KEY_A], MIFARE_KEY_SIZE, fkey);
if (mfReadBlock(0, MF_KEY_A, key, blockdata) == PM3_SUCCESS) { if (mf_read_block(0, MF_KEY_A, key, blockdata) == PM3_SUCCESS) {
fKeyType = MF_KEY_A; fKeyType = MF_KEY_A;
} }
} }
@ -9653,7 +9653,7 @@ static int CmdHF14AMfInfo(const char *Cmd) {
if (fKeyType == 0xFF) { if (fKeyType == 0xFF) {
num_to_bytes(e_sector[0].Key[MF_KEY_B], MIFARE_KEY_SIZE, fkey); num_to_bytes(e_sector[0].Key[MF_KEY_B], MIFARE_KEY_SIZE, fkey);
if (mfReadBlock(0, MF_KEY_B, key, blockdata) == PM3_SUCCESS) { if (mf_read_block(0, MF_KEY_B, key, blockdata) == PM3_SUCCESS) {
fKeyType = MF_KEY_B; fKeyType = MF_KEY_B;
} }
} }
@ -9667,16 +9667,16 @@ static int CmdHF14AMfInfo(const char *Cmd) {
uint8_t k08s[6] = {0xA3, 0x96, 0xEF, 0xA4, 0xE2, 0x4F}; uint8_t k08s[6] = {0xA3, 0x96, 0xEF, 0xA4, 0xE2, 0x4F};
uint8_t k08[6] = {0xA3, 0x16, 0x67, 0xA8, 0xCE, 0xC1}; uint8_t k08[6] = {0xA3, 0x16, 0x67, 0xA8, 0xCE, 0xC1};
uint8_t k32[6] = {0x51, 0x8B, 0x33, 0x54, 0xE7, 0x60}; uint8_t k32[6] = {0x51, 0x8B, 0x33, 0x54, 0xE7, 0x60};
if (mfReadBlock(0, 4, k08s, blockdata) == PM3_SUCCESS) { if (mf_read_block(0, 4, k08s, blockdata) == PM3_SUCCESS) {
PrintAndLogEx(SUCCESS, "Backdoor key..... " _YELLOW_("%s"), sprint_hex_inrow(k08s, sizeof(k08s))); PrintAndLogEx(SUCCESS, "Backdoor key..... " _YELLOW_("%s"), sprint_hex_inrow(k08s, sizeof(k08s)));
fKeyType = MF_KEY_BD; fKeyType = MF_KEY_BD;
memcpy(fkey, k08s, sizeof(fkey)); memcpy(fkey, k08s, sizeof(fkey));
} else if (mfReadBlock(0, 4, k08, blockdata) == PM3_SUCCESS) { } else if (mf_read_block(0, 4, k08, blockdata) == PM3_SUCCESS) {
PrintAndLogEx(SUCCESS, "Backdoor key..... " _YELLOW_("%s"), sprint_hex_inrow(k08, sizeof(k08))); PrintAndLogEx(SUCCESS, "Backdoor key..... " _YELLOW_("%s"), sprint_hex_inrow(k08, sizeof(k08)));
fKeyType = MF_KEY_BD; fKeyType = MF_KEY_BD;
memcpy(fkey, k08, sizeof(fkey)); memcpy(fkey, k08, sizeof(fkey));
} else if (mfReadBlock(0, 4, k32, blockdata) == PM3_SUCCESS) { } else if (mf_read_block(0, 4, k32, blockdata) == PM3_SUCCESS) {
PrintAndLogEx(SUCCESS, "Backdoor key..... " _YELLOW_("%s"), sprint_hex_inrow(k32, sizeof(k32))); PrintAndLogEx(SUCCESS, "Backdoor key..... " _YELLOW_("%s"), sprint_hex_inrow(k32, sizeof(k32)));
fKeyType = MF_KEY_BD; fKeyType = MF_KEY_BD;
memcpy(fkey, k32, sizeof(fkey)); memcpy(fkey, k32, sizeof(fkey));

2
client/src/cmdhfmfp.c
View file

@ -1914,7 +1914,7 @@ static int CmdHFMFPMAD(const char *Cmd) {
if (aaid == mad[i]) { if (aaid == mad[i]) {
uint8_t vsector[16 * 4] = {0}; uint8_t vsector[16 * 4] = {0};
if (mfReadSector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, akey, vsector)) { if (mf_read_sector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, akey, vsector)) {
PrintAndLogEx(NORMAL, ""); PrintAndLogEx(NORMAL, "");
PrintAndLogEx(ERR, "error, read sector %d", i + 1); PrintAndLogEx(ERR, "error, read sector %d", i + 1);
return PM3_ESOFT; return PM3_ESOFT;

88
client/src/mifare/mifarehost.c
View file

@ -44,7 +44,7 @@
#include "gen4.h" #include "gen4.h"
#include "parity.h" #include "parity.h"
int mfDarkside(uint8_t blockno, uint8_t key_type, uint64_t *key) { int mf_dark_side(uint8_t blockno, uint8_t key_type, uint64_t *key) {
uint32_t uid = 0; uint32_t uid = 0;
uint32_t nt = 0, nr = 0, ar = 0; uint32_t nt = 0, nr = 0, ar = 0;
uint64_t par_list = 0, ks_list = 0; uint64_t par_list = 0, ks_list = 0;
@ -189,7 +189,7 @@ int mfDarkside(uint8_t blockno, uint8_t key_type, uint64_t *key) {
} }
} }
if (mfCheckKeys(blockno, key_type - 0x60, false, size, keyBlock, key) == PM3_SUCCESS) { if (mf_check_keys(blockno, key_type - 0x60, false, size, keyBlock, key) == PM3_SUCCESS) {
break; break;
} }
} }
@ -208,7 +208,7 @@ int mfDarkside(uint8_t blockno, uint8_t key_type, uint64_t *key) {
return PM3_SUCCESS; return PM3_SUCCESS;
} }
int mfCheckKeys(uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keycnt, uint8_t *keyBlock, uint64_t *key) { int mf_check_keys(uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keycnt, uint8_t *keyBlock, uint64_t *key) {
if (key) { if (key) {
*key = -1; *key = -1;
} }
@ -249,7 +249,7 @@ int mfCheckKeys(uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keyc
// 0 == ok all keys found // 0 == ok all keys found
// 1 == // 1 ==
// 2 == Time-out, aborting // 2 == Time-out, aborting
int mfCheckKeys_fast_ex(uint8_t sectorsCnt, uint8_t firstChunk, uint8_t lastChunk, uint8_t strategy, int mf_check_keys_fast_ex(uint8_t sectorsCnt, uint8_t firstChunk, uint8_t lastChunk, uint8_t strategy,
uint32_t size, uint8_t *keyBlock, sector_t *e_sector, bool use_flashmemory, uint32_t size, uint8_t *keyBlock, sector_t *e_sector, bool use_flashmemory,
bool verbose, bool quiet, uint16_t singleSectorParams) { bool verbose, bool quiet, uint16_t singleSectorParams) {
@ -357,15 +357,15 @@ int mfCheckKeys_fast_ex(uint8_t sectorsCnt, uint8_t firstChunk, uint8_t lastChun
return PM3_ESOFT; return PM3_ESOFT;
} }
int mfCheckKeys_fast(uint8_t sectorsCnt, uint8_t firstChunk, uint8_t lastChunk, uint8_t strategy, int mf_check_keys_fast(uint8_t sectorsCnt, uint8_t firstChunk, uint8_t lastChunk, uint8_t strategy,
uint32_t size, uint8_t *keyBlock, sector_t *e_sector, bool use_flashmemory, bool verbose) { uint32_t size, uint8_t *keyBlock, sector_t *e_sector, bool use_flashmemory, bool verbose) {
return mfCheckKeys_fast_ex(sectorsCnt, firstChunk, lastChunk, strategy, size, keyBlock, e_sector, use_flashmemory, verbose, false, 0); return mf_check_keys_fast_ex(sectorsCnt, firstChunk, lastChunk, strategy, size, keyBlock, e_sector, use_flashmemory, verbose, false, 0);
} }
// Trigger device to use a binary file on flash mem as keylist for mfCheckKeys. // Trigger device to use a binary file on flash mem as keylist for mfCheckKeys.
// As of now, 255 keys possible in the file // As of now, 255 keys possible in the file
// 6 * 255 = 1500 bytes // 6 * 255 = 1500 bytes
int mfCheckKeys_file(uint8_t *destfn, uint64_t *key) { int mf_check_keys_file(uint8_t *destfn, uint64_t *key) {
*key = -1; *key = -1;
clearCommandBuffer(); clearCommandBuffer();
@ -412,7 +412,7 @@ int mfCheckKeys_file(uint8_t *destfn, uint64_t *key) {
// PM3 imp of J-Run mf_key_brute (part 2) // PM3 imp of J-Run mf_key_brute (part 2)
// ref: https://github.com/J-Run/mf_key_brute // ref: https://github.com/J-Run/mf_key_brute
int mfKeyBrute(uint8_t blockNo, uint8_t keyType, const uint8_t *key, uint64_t *resultkey) { int mf_key_brute(uint8_t blockNo, uint8_t keyType, const uint8_t *key, uint64_t *resultkey) {
uint64_t key64; uint64_t key64;
uint8_t found = false; uint8_t found = false;
@ -441,7 +441,7 @@ int mfKeyBrute(uint8_t blockNo, uint8_t keyType, const uint8_t *key, uint64_t *r
memcpy(keyBlock, candidates + i, KEYBLOCK_SIZE); memcpy(keyBlock, candidates + i, KEYBLOCK_SIZE);
// check a block of generated key candidates. // check a block of generated key candidates.
if (mfCheckKeys(blockNo, keyType, true, KEYS_IN_BLOCK, keyBlock, &key64) == PM3_SUCCESS) { if (mf_check_keys(blockNo, keyType, true, KEYS_IN_BLOCK, keyBlock, &key64) == PM3_SUCCESS) {
*resultkey = key64; *resultkey = key64;
found = true; found = true;
break; break;
@ -483,7 +483,7 @@ __attribute__((force_align_arg_pointer))
return statelist->head.slhead; return statelist->head.slhead;
} }
int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t *resultKey, bool calibrate) { int mf_nested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t *resultKey, bool calibrate) {
uint32_t uid; uint32_t uid;
StateList_t statelists[2]; StateList_t statelists[2];
@ -625,7 +625,7 @@ int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo,
num_to_bytes(key64, 6, keyBlock + j * MIFARE_KEY_SIZE); num_to_bytes(key64, 6, keyBlock + j * MIFARE_KEY_SIZE);
} }
if (mfCheckKeys(statelists[0].blockNo, statelists[0].keyType, false, size, keyBlock, &key64) == PM3_SUCCESS) { if (mf_check_keys(statelists[0].blockNo, statelists[0].keyType, false, size, keyBlock, &key64) == PM3_SUCCESS) {
free(statelists[0].head.slhead); free(statelists[0].head.slhead);
free(statelists[1].head.slhead); free(statelists[1].head.slhead);
num_to_bytes(key64, 6, resultKey); num_to_bytes(key64, 6, resultKey);
@ -669,7 +669,7 @@ out:
return PM3_ESOFT; return PM3_ESOFT;
} }
int mfStaticNested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t *resultKey) { int mf_static_nested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t *resultKey) {
uint32_t uid; uint32_t uid;
StateList_t statelists[2]; StateList_t statelists[2];
@ -902,9 +902,9 @@ int mfStaticNested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBl
free(mem); free(mem);
return res; return res;
} }
res = mfCheckKeys_file(fn, &key64); res = mf_check_keys_file(fn, &key64);
} else { } else {
res = mfCheckKeys(statelists[0].blockNo, statelists[0].keyType, true, chunk, mem, &key64); res = mf_check_keys(statelists[0].blockNo, statelists[0].keyType, true, chunk, mem, &key64);
} }
if (res == PM3_SUCCESS) { if (res == PM3_SUCCESS) {
@ -949,7 +949,7 @@ out:
} }
// MIFARE // MIFARE
int mfReadSector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t *data) { int mf_read_sector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t *data) {
clearCommandBuffer(); clearCommandBuffer();
SendCommandMIX(CMD_HF_MIFARE_READSC, sectorNo, keyType, 0, (uint8_t *)key, MIFARE_KEY_SIZE); SendCommandMIX(CMD_HF_MIFARE_READSC, sectorNo, keyType, 0, (uint8_t *)key, MIFARE_KEY_SIZE);
@ -970,7 +970,7 @@ int mfReadSector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t
return PM3_SUCCESS; return PM3_SUCCESS;
} }
int mfReadBlock(uint8_t blockNo, uint8_t keyType, const uint8_t *key, uint8_t *data) { int mf_read_block(uint8_t blockNo, uint8_t keyType, const uint8_t *key, uint8_t *data) {
mf_readblock_t payload = { mf_readblock_t payload = {
.blockno = blockNo, .blockno = blockNo,
.keytype = keyType .keytype = keyType
@ -994,7 +994,7 @@ int mfReadBlock(uint8_t blockNo, uint8_t keyType, const uint8_t *key, uint8_t *d
return PM3_SUCCESS; return PM3_SUCCESS;
} }
int mfWriteBlock(uint8_t blockno, uint8_t keyType, const uint8_t *key, uint8_t *block) { int mf_write_block(uint8_t blockno, uint8_t keyType, const uint8_t *key, uint8_t *block) {
uint8_t data[26]; uint8_t data[26];
memcpy(data, key, MIFARE_KEY_SIZE); memcpy(data, key, MIFARE_KEY_SIZE);
@ -1014,10 +1014,10 @@ int mfWriteBlock(uint8_t blockno, uint8_t keyType, const uint8_t *key, uint8_t *
return res; return res;
} }
int mfWriteSector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t *sector){ int mf_write_sector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t *sector) {
int res;
for (int i = 0; i < 4; i++) { for (int i = 0; i < mfNumBlocksPerSector(sectorNo); i++) {
int res = mfWriteBlock((sectorNo * 4) + i, keyType, key, sector + ( i * MFBLOCK_SIZE )); res = mf_write_block((mfFirstBlockOfSector(sectorNo)) + i, keyType, key, sector + (i * MFBLOCK_SIZE));
if (res != PM3_SUCCESS) { if (res != PM3_SUCCESS) {
return (i == 0) ? PM3_EFAILED : PM3_EPARTIAL; return (i == 0) ? PM3_EFAILED : PM3_EPARTIAL;
} }
@ -1026,7 +1026,7 @@ int mfWriteSector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t
} }
// EMULATOR // EMULATOR
int mfEmlGetMem(uint8_t *data, int blockNum, int blocksCount) { int mf_eml_get_mem(uint8_t *data, int blockNum, int blocksCount) {
size_t size = blocksCount * MFBLOCK_SIZE; size_t size = blocksCount * MFBLOCK_SIZE;
if (size > PM3_CMD_DATA_SIZE) { if (size > PM3_CMD_DATA_SIZE) {
@ -1056,11 +1056,11 @@ int mfEmlGetMem(uint8_t *data, int blockNum, int blocksCount) {
return resp.status; return resp.status;
} }
int mfEmlSetMem(uint8_t *data, int blockNum, int blocksCount) { int mf_elm_set_mem(uint8_t *data, int blockNum, int blocksCount) {
return mfEmlSetMem_xt(data, blockNum, blocksCount, MFBLOCK_SIZE); return mf_eml_set_mem_xt(data, blockNum, blocksCount, MFBLOCK_SIZE);
} }
int mfEmlSetMem_xt(uint8_t *data, int blockNum, int blocksCount, int blockBtWidth) { int mf_eml_set_mem_xt(uint8_t *data, int blockNum, int blocksCount, int blockBtWidth) {
struct p { struct p {
uint8_t blockno; uint8_t blockno;
@ -1089,13 +1089,13 @@ int mfEmlSetMem_xt(uint8_t *data, int blockNum, int blocksCount, int blockBtWidt
} }
// "MAGIC" CARD // "MAGIC" CARD
int mfCSetUID(uint8_t *uid, uint8_t uidlen, const uint8_t *atqa, const uint8_t *sak, uint8_t *old_uid, uint8_t *verifed_uid, uint8_t wipecard, uint8_t gdm) { int mf_chinese_set_uid(uint8_t *uid, uint8_t uidlen, const uint8_t *atqa, const uint8_t *sak, uint8_t *old_uid, uint8_t *verifed_uid, uint8_t wipecard, uint8_t gdm) {
uint8_t params = MAGIC_SINGLE | (gdm ? MAGIC_GDM_ALT_WUPC : MAGIC_WUPC); uint8_t params = MAGIC_SINGLE | (gdm ? MAGIC_GDM_ALT_WUPC : MAGIC_WUPC);
uint8_t block0[MFBLOCK_SIZE]; uint8_t block0[MFBLOCK_SIZE];
memset(block0, 0x00, sizeof(block0)); memset(block0, 0x00, sizeof(block0));
int res = mfCGetBlock(0, block0, params); int res = mf_chinese_get_block(0, block0, params);
if (res == 0) { if (res == 0) {
PrintAndLogEx(SUCCESS, "old block 0... %s", sprint_hex_inrow(block0, sizeof(block0))); PrintAndLogEx(SUCCESS, "old block 0... %s", sprint_hex_inrow(block0, sizeof(block0)));
if (old_uid) { if (old_uid) {
@ -1140,11 +1140,11 @@ int mfCSetUID(uint8_t *uid, uint8_t uidlen, const uint8_t *atqa, const uint8_t *
params |= MAGIC_WIPE; params |= MAGIC_WIPE;
} }
res = mfCSetBlock(0, block0, NULL, params); res = mf_chinese_set_block(0, block0, NULL, params);
if (res == PM3_SUCCESS) { if (res == PM3_SUCCESS) {
params = MAGIC_SINGLE | MAGIC_WUPC; params = MAGIC_SINGLE | MAGIC_WUPC;
memset(block0, 0, sizeof(block0)); memset(block0, 0, sizeof(block0));
res = mfCGetBlock(0, block0, params); res = mf_chinese_get_block(0, block0, params);
if (res == 0) { if (res == 0) {
if (verifed_uid) { if (verifed_uid) {
memcpy(verifed_uid, block0, uidlen); memcpy(verifed_uid, block0, uidlen);
@ -1154,7 +1154,7 @@ int mfCSetUID(uint8_t *uid, uint8_t uidlen, const uint8_t *atqa, const uint8_t *
return res; return res;
} }
int mfCWipe(uint8_t *uid, const uint8_t *atqa, const uint8_t *sak, uint8_t gdm) { int mf_chinese_wipe(uint8_t *uid, const uint8_t *atqa, const uint8_t *sak, uint8_t gdm) {
uint8_t block0[MFBLOCK_SIZE] = {0x00, 0x56, 0x78, 0xBB, 0x95, 0x08, 0x04, 0x00, 0x02, 0xB2, 0x1E, 0x24, 0x23, 0x27, 0x1E, 0x1D}; uint8_t block0[MFBLOCK_SIZE] = {0x00, 0x56, 0x78, 0xBB, 0x95, 0x08, 0x04, 0x00, 0x02, 0xB2, 0x1E, 0x24, 0x23, 0x27, 0x1E, 0x1D};
// uint8_t block0[MFBLOCK_SIZE] = {0x04, 0x03, 0x02, 0x01, 0x04, 0x08, 0x04, 0x00, 0x64, 0xB9, 0x95, 0x11, 0x4D, 0x20, 0x42, 0x09}; // uint8_t block0[MFBLOCK_SIZE] = {0x04, 0x03, 0x02, 0x01, 0x04, 0x08, 0x04, 0x00, 0x64, 0xB9, 0x95, 0x11, 0x4D, 0x20, 0x42, 0x09};
uint8_t blockD[MFBLOCK_SIZE] = {0x00}; uint8_t blockD[MFBLOCK_SIZE] = {0x00};
@ -1180,12 +1180,12 @@ int mfCWipe(uint8_t *uid, const uint8_t *atqa, const uint8_t *sak, uint8_t gdm)
PrintAndLogEx(INPLACE, "wipe block %d", blockNo); PrintAndLogEx(INPLACE, "wipe block %d", blockNo);
if (blockNo == 0) { if (blockNo == 0) {
res = mfCSetBlock(blockNo, block0, NULL, params); res = mf_chinese_set_block(blockNo, block0, NULL, params);
} else { } else {
if (mfIsSectorTrailer(blockNo)) if (mfIsSectorTrailer(blockNo))
res = mfCSetBlock(blockNo, blockK, NULL, params); res = mf_chinese_set_block(blockNo, blockK, NULL, params);
else else
res = mfCSetBlock(blockNo, blockD, NULL, params); res = mf_chinese_set_block(blockNo, blockD, NULL, params);
} }
if (res == PM3_SUCCESS) if (res == PM3_SUCCESS)
@ -1204,7 +1204,7 @@ int mfCWipe(uint8_t *uid, const uint8_t *atqa, const uint8_t *sak, uint8_t gdm)
return PM3_SUCCESS; return PM3_SUCCESS;
} }
int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, uint8_t params) { int mf_chinese_set_block(uint8_t blockNo, uint8_t *data, uint8_t *uid, uint8_t params) {
clearCommandBuffer(); clearCommandBuffer();
SendCommandMIX(CMD_HF_MIFARE_CSETBL, params, blockNo, 0, data, MFBLOCK_SIZE); SendCommandMIX(CMD_HF_MIFARE_CSETBL, params, blockNo, 0, data, MFBLOCK_SIZE);
PacketResponseNG resp; PacketResponseNG resp;
@ -1224,7 +1224,7 @@ int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, uint8_t params) {
return PM3_SUCCESS; return PM3_SUCCESS;
} }
int mfCGetBlock(uint8_t blockNo, uint8_t *data, uint8_t params) { int mf_chinese_get_block(uint8_t blockNo, uint8_t *data, uint8_t params) {
clearCommandBuffer(); clearCommandBuffer();
SendCommandMIX(CMD_HF_MIFARE_CGETBL, params, blockNo, 0, NULL, 0); SendCommandMIX(CMD_HF_MIFARE_CGETBL, params, blockNo, 0, NULL, 0);
PacketResponseNG resp; PacketResponseNG resp;
@ -1241,7 +1241,7 @@ int mfCGetBlock(uint8_t blockNo, uint8_t *data, uint8_t params) {
return PM3_SUCCESS; return PM3_SUCCESS;
} }
int mfGen3UID(uint8_t *uid, uint8_t uidlen, uint8_t *oldUid) { int mf_chinese_gen_3_uid(uint8_t *uid, uint8_t uidlen, uint8_t *oldUid) {
clearCommandBuffer(); clearCommandBuffer();
SendCommandMIX(CMD_HF_MIFARE_GEN3UID, uidlen, 0, 0, uid, uidlen); SendCommandMIX(CMD_HF_MIFARE_GEN3UID, uidlen, 0, 0, uid, uidlen);
PacketResponseNG resp; PacketResponseNG resp;
@ -1256,7 +1256,7 @@ int mfGen3UID(uint8_t *uid, uint8_t uidlen, uint8_t *oldUid) {
} }
} }
int mfGen3Block(uint8_t *block, int blockLen, uint8_t *newBlock) { int mf_chinese_gen_3_block(uint8_t *block, int blockLen, uint8_t *newBlock) {
clearCommandBuffer(); clearCommandBuffer();
SendCommandMIX(CMD_HF_MIFARE_GEN3BLK, blockLen, 0, 0, block, MFBLOCK_SIZE); SendCommandMIX(CMD_HF_MIFARE_GEN3BLK, blockLen, 0, 0, block, MFBLOCK_SIZE);
PacketResponseNG resp; PacketResponseNG resp;
@ -1271,7 +1271,7 @@ int mfGen3Block(uint8_t *block, int blockLen, uint8_t *newBlock) {
} }
} }
int mfGen3Freeze(void) { int mf_chinese_gen_3_freeze(void) {
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_MIFARE_GEN3FREEZ, NULL, 0); SendCommandNG(CMD_HF_MIFARE_GEN3FREEZ, NULL, 0);
PacketResponseNG resp; PacketResponseNG resp;
@ -1301,7 +1301,7 @@ void mf_crypto1_decrypt(struct Crypto1State *pcs, uint8_t *data, int len, bool i
} }
} }
int tryDecryptWord(uint32_t nt, uint32_t ar_enc, uint32_t at_enc, uint8_t *data, int len) { int try_decrypt_word(uint32_t nt, uint32_t ar_enc, uint32_t at_enc, uint8_t *data, int len) {
PrintAndLogEx(SUCCESS, "encrypted data... %s", sprint_hex(data, len)); PrintAndLogEx(SUCCESS, "encrypted data... %s", sprint_hex(data, len));
uint32_t ks2 = ar_enc ^ prng_successor(nt, 64); uint32_t ks2 = ar_enc ^ prng_successor(nt, 64);
@ -1636,7 +1636,7 @@ uint16_t detect_mf_magic(bool is_mfc, uint8_t key_type, uint64_t key) {
bool detect_mfc_ev1_signature(void) { bool detect_mfc_ev1_signature(void) {
uint64_t key = 0; uint64_t key = 0;
int res = mfCheckKeys(69, MF_KEY_B, false, 1, (uint8_t *)g_mifare_signature_key_b, &key); int res = mf_check_keys(69, MF_KEY_B, false, 1, (uint8_t *)g_mifare_signature_key_b, &key);
return (res == PM3_SUCCESS); return (res == PM3_SUCCESS);
} }
@ -1645,17 +1645,17 @@ int read_mfc_ev1_signature(uint8_t *signature) {
return PM3_EINVARG; return PM3_EINVARG;
} }
uint8_t sign[32] = {0}; uint8_t sign[32] = {0};
int res = mfReadBlock(69, MF_KEY_B, g_mifare_signature_key_b, sign); int res = mf_read_block(69, MF_KEY_B, g_mifare_signature_key_b, sign);
if (res == PM3_SUCCESS) { if (res == PM3_SUCCESS) {
res = mfReadBlock(70, MF_KEY_B, g_mifare_signature_key_b, sign + 16); res = mf_read_block(70, MF_KEY_B, g_mifare_signature_key_b, sign + 16);
if (res == PM3_SUCCESS) { if (res == PM3_SUCCESS) {
memcpy(signature, sign, sizeof(sign)); memcpy(signature, sign, sizeof(sign));
} }
} else { } else {
// try QL88 // try QL88
res = mfReadBlock(69, MF_KEY_B, g_mifare_ql88_signature_key_b, sign); res = mf_read_block(69, MF_KEY_B, g_mifare_ql88_signature_key_b, sign);
if (res == PM3_SUCCESS) { if (res == PM3_SUCCESS) {
res = mfReadBlock(70, MF_KEY_B, g_mifare_ql88_signature_key_b, sign + 16); res = mf_read_block(70, MF_KEY_B, g_mifare_ql88_signature_key_b, sign + 16);
if (res == PM3_SUCCESS) { if (res == PM3_SUCCESS) {
memcpy(signature, sign, sizeof(sign)); memcpy(signature, sign, sizeof(sign));
} }

46
client/src/mifare/mifarehost.h
View file

@ -70,41 +70,41 @@ typedef struct {
#define KEYBLOCK_SIZE (KEYS_IN_BLOCK * MIFARE_KEY_SIZE) #define KEYBLOCK_SIZE (KEYS_IN_BLOCK * MIFARE_KEY_SIZE)
#define CANDIDATE_SIZE (0xFFFF * MIFARE_KEY_SIZE) #define CANDIDATE_SIZE (0xFFFF * MIFARE_KEY_SIZE)
int mfDarkside(uint8_t blockno, uint8_t key_type, uint64_t *key); int mf_dark_side(uint8_t blockno, uint8_t key_type, uint64_t *key);
int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t *resultKey, bool calibrate); int mf_nested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t *resultKey, bool calibrate);
int mfStaticNested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t *resultKey); int mf_static_nested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t *resultKey);
int mfCheckKeys(uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keycnt, uint8_t *keyBlock, uint64_t *key); int mf_check_keys(uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keycnt, uint8_t *keyBlock, uint64_t *key);
int mfCheckKeys_fast(uint8_t sectorsCnt, uint8_t firstChunk, uint8_t lastChunk, int mf_check_keys_fast(uint8_t sectorsCnt, uint8_t firstChunk, uint8_t lastChunk,
uint8_t strategy, uint32_t size, uint8_t *keyBlock, sector_t *e_sector, uint8_t strategy, uint32_t size, uint8_t *keyBlock, sector_t *e_sector,
bool use_flashmemory, bool verbose); bool use_flashmemory, bool verbose);
int mfCheckKeys_fast_ex(uint8_t sectorsCnt, uint8_t firstChunk, uint8_t lastChunk, uint8_t strategy, int mf_check_keys_fast_ex(uint8_t sectorsCnt, uint8_t firstChunk, uint8_t lastChunk, uint8_t strategy,
uint32_t size, uint8_t *keyBlock, sector_t *e_sector, bool use_flashmemory, uint32_t size, uint8_t *keyBlock, sector_t *e_sector, bool use_flashmemory,
bool verbose, bool quiet, uint16_t singleSectorParams); bool verbose, bool quiet, uint16_t singleSectorParams);
int mfCheckKeys_file(uint8_t *destfn, uint64_t *key); int mf_check_keys_file(uint8_t *destfn, uint64_t *key);
int mfKeyBrute(uint8_t blockNo, uint8_t keyType, const uint8_t *key, uint64_t *resultkey); int mf_key_brute(uint8_t blockNo, uint8_t keyType, const uint8_t *key, uint64_t *resultkey);
int mfReadSector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t *data); int mf_read_sector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t *data);
int mfReadBlock(uint8_t blockNo, uint8_t keyType, const uint8_t *key, uint8_t *data); int mf_read_block(uint8_t blockNo, uint8_t keyType, const uint8_t *key, uint8_t *data);
int mfWriteBlock(uint8_t blockno, uint8_t keyType, const uint8_t *key, uint8_t *block); int mf_write_block(uint8_t blockno, uint8_t keyType, const uint8_t *key, uint8_t *block);
int mfWriteSector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t *sector); int mf_write_sector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t *sector);
int mfEmlGetMem(uint8_t *data, int blockNum, int blocksCount); int mf_eml_get_mem(uint8_t *data, int blockNum, int blocksCount);
int mfEmlSetMem(uint8_t *data, int blockNum, int blocksCount); int mf_elm_set_mem(uint8_t *data, int blockNum, int blocksCount);
int mfEmlSetMem_xt(uint8_t *data, int blockNum, int blocksCount, int blockBtWidth); int mf_eml_set_mem_xt(uint8_t *data, int blockNum, int blocksCount, int blockBtWidth);
int mfCSetUID(uint8_t *uid, uint8_t uidlen, const uint8_t *atqa, const uint8_t *sak, uint8_t *old_uid, uint8_t *verifed_uid, uint8_t wipecard, uint8_t gdm); int mf_chinese_set_uid(uint8_t *uid, uint8_t uidlen, const uint8_t *atqa, const uint8_t *sak, uint8_t *old_uid, uint8_t *verifed_uid, uint8_t wipecard, uint8_t gdm);
int mfCWipe(uint8_t *uid, const uint8_t *atqa, const uint8_t *sak, uint8_t gdm); int mf_chinese_wipe(uint8_t *uid, const uint8_t *atqa, const uint8_t *sak, uint8_t gdm);
int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, uint8_t params); int mf_chinese_set_block(uint8_t blockNo, uint8_t *data, uint8_t *uid, uint8_t params);
int mfCGetBlock(uint8_t blockNo, uint8_t *data, uint8_t params); int mf_chinese_get_block(uint8_t blockNo, uint8_t *data, uint8_t params);
int mfGen3UID(uint8_t *uid, uint8_t uidlen, uint8_t *oldUid); int mf_chinese_gen_3_uid(uint8_t *uid, uint8_t uidlen, uint8_t *oldUid);
int mfGen3Block(uint8_t *block, int blockLen, uint8_t *newBlock); int mf_chinese_gen_3_block(uint8_t *block, int blockLen, uint8_t *newBlock);
int mfGen3Freeze(void); int mf_chinese_gen_3_freeze(void);
int tryDecryptWord(uint32_t nt, uint32_t ar_enc, uint32_t at_enc, uint8_t *data, int len); int try_decrypt_word(uint32_t nt, uint32_t ar_enc, uint32_t at_enc, uint8_t *data, int len);
int detect_classic_prng(void); int detect_classic_prng(void);
int detect_classic_nackbug(bool verbose); int detect_classic_nackbug(bool verbose);

2
client/src/scripting.c
View file

@ -423,7 +423,7 @@ static int l_mfDarkside(lua_State *L) {
break; break;
} }
int retval = mfDarkside(blockno & 0xFF, keytype & 0xFF, &key); int retval = mf_dark_side(blockno & 0xFF, keytype & 0xFF, &key);
uint8_t dest_key[8]; uint8_t dest_key[8];
num_to_bytes(key, sizeof(dest_key), dest_key); num_to_bytes(key, sizeof(dest_key), dest_key);