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

CHG: spelling errors, added help texts in cmdhfmfu.c

Browse source 
CHG: refactored the "hf mfu rdbl/wrbl/crdbl/wrbl" commands.
CHG: added a cauth test to "hf mfu info" command to see if the tag is a Ultralight-C tag or not.
This commit is contained in:
iceman1001 2015-01-07 18:50:51 +01:00
commit 5f2cb31bca
3 changed files with 157 additions and 215 deletions
Download patch file Download diff file Expand all files Collapse all files

41
armsrc/mifarecmd.c
View file

@ -88,35 +88,38 @@ void MifareReadBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
void MifareUC_Auth1(uint8_t arg0, uint8_t *datain){ void MifareUC_Auth1(uint8_t arg0, uint8_t *datain){
// variables
byte_t isOK = 0; byte_t isOK = 0;
byte_t dataoutbuf[16] = {0x00}; byte_t dataoutbuf[16] = {0x00};
uint8_t uid[10] = {0x00}; uint8_t uid[10] = {0x00};
uint32_t cuid; uint32_t cuid;
// clear trace
iso14a_clear_trace();
iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN);
LED_A_ON(); LED_A_ON();
LED_B_OFF(); LED_B_OFF();
LED_C_OFF(); LED_C_OFF();
iso14a_clear_trace();
iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN);
if(!iso14443a_select_card(uid, NULL, &cuid)) { if(!iso14443a_select_card(uid, NULL, &cuid)) {
if (MF_DBGLEVEL >= 1) Dbprintf("Can't select card, something went wrong before auth"); if (MF_DBGLEVEL >= MF_DBG_ERROR)
Dbprintf("Can't select card");
OnError(0);
return;
}; };
if(mifare_ultra_auth1(cuid, dataoutbuf)){ if(mifare_ultra_auth1(cuid, dataoutbuf)){
if (MF_DBGLEVEL >= 1) Dbprintf("Authentication part1: Fail."); if (MF_DBGLEVEL >= MF_DBG_ERROR)
Dbprintf("Authentication part1: Fail.");
OnError(1);
return;
} }
isOK=1; isOK = 1;
if (MF_DBGLEVEL >= 2) DbpString("AUTH 1 FINISHED"); if (MF_DBGLEVEL >= MF_DBG_EXTENDED)
DbpString("AUTH 1 FINISHED");
LED_B_ON();
cmd_send(CMD_ACK,isOK,cuid,0,dataoutbuf,11); cmd_send(CMD_ACK,isOK,cuid,0,dataoutbuf,11);
LEDsoff(); LEDsoff();
} }
void MifareUC_Auth2(uint32_t arg0, uint8_t *datain){ void MifareUC_Auth2(uint32_t arg0, uint8_t *datain){
@ -133,15 +136,17 @@ void MifareUC_Auth2(uint32_t arg0, uint8_t *datain){
LED_C_OFF(); LED_C_OFF();
if(mifare_ultra_auth2(cuid, key, dataoutbuf)){ if(mifare_ultra_auth2(cuid, key, dataoutbuf)){
if (MF_DBGLEVEL >= 1) Dbprintf("Authentication part2: Fail..."); if (MF_DBGLEVEL >= MF_DBG_ERROR)
Dbprintf("Authentication part2: Fail...");
OnError(1);
return;
} }
isOK = 1; isOK = 1;
if (MF_DBGLEVEL >= 2) DbpString("AUTH 2 FINISHED"); if (MF_DBGLEVEL >= MF_DBG_EXTENDED)
DbpString("AUTH 2 FINISHED");
LED_B_ON();
cmd_send(CMD_ACK,isOK,0,0,dataoutbuf,11); cmd_send(CMD_ACK,isOK,0,0,dataoutbuf,11);
LED_B_OFF();
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LEDsoff(); LEDsoff();
} }

4
client/cmdhf14b.c
View file

@ -403,10 +403,10 @@ int CmdHF14BWrite( const char *Cmd){
bool isSrix4k = true; bool isSrix4k = true;
char str[20]; char str[20];
if (cmdp == 'h' || cmdp == 'H') { if (strlen(Cmd) < 1 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: hf 14b write <1|2> <BLOCK> <DATA>"); PrintAndLog("Usage: hf 14b write <1|2> <BLOCK> <DATA>");
PrintAndLog(" [1 = SRIX4K]"); PrintAndLog(" [1 = SRIX4K]");
PrintAndLog(" [2 = SRIX4K]"); PrintAndLog(" [2 = SRI512]");
PrintAndLog(" [BLOCK number depends on which tag, special block == 255]"); PrintAndLog(" [BLOCK number depends on which tag, special block == 255]");
PrintAndLog(" sample: hf 14b write 1 127 11223344"); PrintAndLog(" sample: hf 14b write 1 127 11223344");
PrintAndLog(" : hf 14b write 1 255 11223344"); PrintAndLog(" : hf 14b write 1 255 11223344");

327
client/cmdhfmfu.c
View file

@ -8,9 +8,11 @@
// High frequency MIFARE ULTRALIGHT (C) commands // High frequency MIFARE ULTRALIGHT (C) commands
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <openssl/des.h> #include <openssl/des.h>
#include "cmdhfmfu.h"
#include "cmdhfmf.h" #include "cmdhfmf.h"
#include "cmdhf14a.h" #include "cmdhf14a.h"
uint8_t MAX_ULTRA_BLOCKS = 0x0f; uint8_t MAX_ULTRA_BLOCKS = 0x0f;
uint8_t MAX_ULTRAC_BLOCKS = 0x2c; uint8_t MAX_ULTRAC_BLOCKS = 0x2c;
uint8_t key1_blnk_data[16] = { 0x00 }; uint8_t key1_blnk_data[16] = { 0x00 };
@ -75,6 +77,10 @@ int CmdHF14AMfUInfo(const char *Cmd){
PrintAndLog(" OneTimePad : %s ", sprint_hex(data + 3*4, 4)); PrintAndLog(" OneTimePad : %s ", sprint_hex(data + 3*4, 4));
PrintAndLog(""); PrintAndLog("");
int len = CmdHF14AMfucAuth("K 0");
// PrintAndLog("CODE: %d",len);
PrintAndLog("Seems to be a Ultralight %s", (len==0) ? "-C" :"");
return 0; return 0;
} }
@ -83,109 +89,65 @@ int CmdHF14AMfUInfo(const char *Cmd){
// //
int CmdHF14AMfUWrBl(const char *Cmd){ int CmdHF14AMfUWrBl(const char *Cmd){
uint8_t blockNo = 0; uint8_t blockNo = 0;
bool chinese_card = 0; bool chinese_card = FALSE;
uint8_t bldata[16] = {0x00}; uint8_t bldata[16] = {0x00};
UsbCommand resp; UsbCommand resp;
if (strlen(Cmd)<3) { char cmdp = param_getchar(Cmd, 0);
PrintAndLog("Usage: hf mfu wrbl <block number> <block data > [w]"); if (strlen(Cmd) < 3 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog(" [block number] "); PrintAndLog("Usage: hf mfu wrbl <block number> <block data (8 hex symbols)> [w]");
PrintAndLog(" [block number]");
PrintAndLog(" [block data] - (8 hex symbols)"); PrintAndLog(" [block data] - (8 hex symbols)");
PrintAndLog(" [w] - Chinese magic ultralight-c tag "); PrintAndLog(" [w] - Chinese magic ultralight tag");
PrintAndLog(""); PrintAndLog("");
PrintAndLog(" sample: hf mfu wrbl 0 01020304"); PrintAndLog(" sample: hf mfu wrbl 0 01020304");
PrintAndLog("");
return 0; return 0;
} }
blockNo = param_get8(Cmd, 0);
if (blockNo>MAX_ULTRA_BLOCKS){ blockNo = param_get8(Cmd, 0);
if (blockNo > MAX_ULTRA_BLOCKS){
PrintAndLog("Error: Maximum number of blocks is 15 for Ultralight Cards!"); PrintAndLog("Error: Maximum number of blocks is 15 for Ultralight Cards!");
return 1; return 1;
} }
if (param_gethex(Cmd, 1, bldata, 8)) { if (param_gethex(Cmd, 1, bldata, 8)) {
PrintAndLog("Block data must include 8 HEX symbols"); PrintAndLog("Block data must include 8 HEX symbols");
return 1; return 1;
} }
if (strchr(Cmd,'w') != 0) {
chinese_card=1; if (strchr(Cmd,'w') != 0 || strchr(Cmd,'W') != 0 ) {
chinese_card = TRUE;
} }
switch(blockNo){
case 0: if ( blockNo <= 3) {
if (!chinese_card){ if (!chinese_card){
PrintAndLog("Access Denied"); PrintAndLog("Access Denied");
}else{ } else {
PrintAndLog("--specialblock no:%02x", blockNo); PrintAndLog("--specialblock no:%02x", blockNo);
PrintAndLog("--data: %s", sprint_hex(bldata, 4)); PrintAndLog("--data: %s", sprint_hex(bldata, 4));
UsbCommand d = {CMD_MIFAREU_WRITEBL, {blockNo}}; UsbCommand d = {CMD_MIFAREU_WRITEBL, {blockNo}};
memcpy(d.d.asBytes,bldata, 4); memcpy(d.d.asBytes,bldata, 4);
SendCommand(&d); SendCommand(&d);
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) { if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff; uint8_t isOK = resp.arg[0] & 0xff;
PrintAndLog("isOk:%02x", isOK); PrintAndLog("isOk:%02x", isOK);
} else { } else {
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
} }
} }
break; } else {
case 1:
if (!chinese_card){
PrintAndLog("Access Denied");
}else{
PrintAndLog("--specialblock no:%02x", blockNo);
PrintAndLog("--data: %s", sprint_hex(bldata, 4));
UsbCommand d = {CMD_MIFAREU_WRITEBL, {blockNo}};
memcpy(d.d.asBytes,bldata, 4);
SendCommand(&d);
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff;
PrintAndLog("isOk:%02x", isOK);
} else {
PrintAndLog("Command execute timeout");
}
}
break;
case 2:
if (!chinese_card){
PrintAndLog("Access Denied");
}else{
PrintAndLog("--specialblock no:%02x", blockNo);
PrintAndLog("--data: %s", sprint_hex(bldata, 4));
UsbCommand c = {CMD_MIFAREU_WRITEBL, {blockNo}};
memcpy(c.d.asBytes, bldata, 4);
SendCommand(&c);
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff;
PrintAndLog("isOk:%02x", isOK);
} else {
PrintAndLog("Command execute timeout");
}
}
break;
case 3:
PrintAndLog("--specialblock no:%02x", blockNo);
PrintAndLog("--data: %s", sprint_hex(bldata, 4));
UsbCommand d = {CMD_MIFAREU_WRITEBL, {blockNo}};
memcpy(d.d.asBytes,bldata, 4);
SendCommand(&d);
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff;
PrintAndLog("isOk:%02x", isOK);
} else {
PrintAndLog("Command execute timeout");
}
break;
default:
PrintAndLog("--block no:%02x", blockNo); PrintAndLog("--block no:%02x", blockNo);
PrintAndLog("--data: %s", sprint_hex(bldata, 4)); PrintAndLog("--data: %s", sprint_hex(bldata, 4));
UsbCommand e = {CMD_MIFAREU_WRITEBL, {blockNo}}; UsbCommand e = {CMD_MIFAREU_WRITEBL, {blockNo}};
memcpy(e.d.asBytes,bldata, 4); memcpy(e.d.asBytes,bldata, 4);
SendCommand(&e); SendCommand(&e);
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) { if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff; uint8_t isOK = resp.arg[0] & 0xff;
PrintAndLog("isOk:%02x", isOK); PrintAndLog("isOk:%02x", isOK);
} else { } else {
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
} }
break;
} }
return 0; return 0;
} }
@ -196,8 +158,10 @@ int CmdHF14AMfUWrBl(const char *Cmd){
int CmdHF14AMfURdBl(const char *Cmd){ int CmdHF14AMfURdBl(const char *Cmd){
uint8_t blockNo = 0; uint8_t blockNo = 0;
if (strlen(Cmd)<1) { char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) < 1 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: hf mfu rdbl <block number>"); PrintAndLog("Usage: hf mfu rdbl <block number>");
PrintAndLog(" sample: hfu mfu rdbl 0"); PrintAndLog(" sample: hfu mfu rdbl 0");
return 0; return 0;
@ -208,7 +172,7 @@ int CmdHF14AMfURdBl(const char *Cmd){
// PrintAndLog("Error: Maximum number of blocks is 15 for Ultralight Cards!"); // PrintAndLog("Error: Maximum number of blocks is 15 for Ultralight Cards!");
// return 1; // return 1;
// } // }
PrintAndLog("--block no:%02x", (int)blockNo); PrintAndLog("--block no:0x%02X (%d)", (int)blockNo, blockNo);
UsbCommand c = {CMD_MIFAREU_READBL, {blockNo}}; UsbCommand c = {CMD_MIFAREU_READBL, {blockNo}};
SendCommand(&c); SendCommand(&c);
@ -216,13 +180,12 @@ int CmdHF14AMfURdBl(const char *Cmd){
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) { if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff; uint8_t isOK = resp.arg[0] & 0xff;
uint8_t * data = resp.d.asBytes; uint8_t * data = resp.d.asBytes;
PrintAndLog("isOk: %02x", isOK);
if (isOK) if (isOK)
PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 4)); PrintAndLog("Data: %s", sprint_hex(data, 4));
else } else {
PrintAndLog("isOk:%02x", isOK);
}
else {
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
} }
return 0; return 0;
@ -441,14 +404,14 @@ int CmdHF14AMfucAuth(const char *Cmd){
memset(iv, 0, 8); memset(iv, 0, 8);
if (cmdp == 'h' || cmdp == 'H') { if (cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: hf mfu auth k <key number>"); PrintAndLog("Usage: hf mfu cauth k <key number>");
PrintAndLog(" 1 = all zeros key"); PrintAndLog(" 1 = all zeros key");
PrintAndLog(" 2 = 0x00-0x0F key"); PrintAndLog(" 2 = 0x00-0x0F key");
PrintAndLog(" 3 = nfc key"); PrintAndLog(" 3 = nfc key");
PrintAndLog(" 4 = all ones key"); PrintAndLog(" 4 = all ones key");
PrintAndLog(" defaults to 3DES standard key"); PrintAndLog(" defaults to 3DES standard key");
PrintAndLog(" sample : hf mfu auth k"); PrintAndLog(" sample : hf mfu cauth k");
PrintAndLog(" : hf mfu auth k 3"); PrintAndLog(" : hf mfu cauth k 3");
return 0; return 0;
} }
@ -495,10 +458,12 @@ int CmdHF14AMfucAuth(const char *Cmd){
if (isOK){ if (isOK){
PrintAndLog("enc(RndB):%s", sprint_hex(data+1, 8)); PrintAndLog("enc(RndB):%s", sprint_hex(data+1, 8));
memcpy(e_RndB,data+1,8); memcpy(e_RndB,data+1,8);
} } else {
return 2; // auth failed.
}
} else { } else {
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
return 0; return 1;
} }
//Do crypto magic //Do crypto magic
@ -525,12 +490,15 @@ int CmdHF14AMfucAuth(const char *Cmd){
if (isOK){ if (isOK){
PrintAndLog("enc(RndA'):%s", sprint_hex(data2+1, 8)); PrintAndLog("enc(RndA'):%s", sprint_hex(data2+1, 8));
} else {
return 2;
} }
} else { } else {
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
return 0; return 1;
} }
return 1; return 0;
} }
// //
@ -538,35 +506,43 @@ int CmdHF14AMfucAuth(const char *Cmd){
// //
int CmdHF14AMfUCRdBl(const char *Cmd) int CmdHF14AMfUCRdBl(const char *Cmd)
{ {
uint8_t blockNo = 0; uint8_t blockNo = -1;
char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd)<1) {
if (strlen(Cmd) < 1 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: hf mfu crdbl <block number>"); PrintAndLog("Usage: hf mfu crdbl <block number>");
PrintAndLog(" sample: hf mfu crdbl 0"); PrintAndLog(" sample: hf mfu crdbl 0");
return 0; return 0;
} }
blockNo = param_get8(Cmd, 0); blockNo = param_get8(Cmd, 0);
if (blockNo>MAX_ULTRAC_BLOCKS){ if (blockNo < 0) {
PrintAndLog("Error: Maximum number of readable blocks is 44 for Ultralight Cards!"); PrintAndLog("Wrong block number");
return 1;
}
if (blockNo > (MAX_ULTRAC_BLOCKS+4) ){
PrintAndLog("Error: Maximum number of readable blocks is 47 for Ultralight-C Cards!");
return 1; return 1;
} }
PrintAndLog("--block no:%02x", (int)blockNo);
PrintAndLog("--block no: 0x%02X (%d)", (int)blockNo, blockNo);
//Read Block //Read Block
UsbCommand e = {CMD_MIFAREU_READBL, {blockNo}}; UsbCommand e = {CMD_MIFAREU_READBL, {blockNo}};
SendCommand(&e); SendCommand(&e);
UsbCommand resp_c; UsbCommand resp_c;
if (WaitForResponseTimeout(CMD_ACK,&resp_c,1500)) { if (WaitForResponseTimeout(CMD_ACK,&resp_c,1500)) {
uint8_t isOK = resp_c.arg[0] & 0xff; uint8_t isOK = resp_c.arg[0] & 0xff;
uint8_t * data = resp_c.d.asBytes; uint8_t *data = resp_c.d.asBytes;
PrintAndLog("isOk: %02x", isOK);
if (isOK) if (isOK)
PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 4)); PrintAndLog("Data: %s", sprint_hex(data, 4));
else
PrintAndLog("isOk:%02x", isOK); } else {
} else { PrintAndLog("Command execute timeout");
PrintAndLog("Command execute timeout"); }
}
return 0; return 0;
} }
@ -576,107 +552,68 @@ int CmdHF14AMfUCRdBl(const char *Cmd)
int CmdHF14AMfUCWrBl(const char *Cmd){ int CmdHF14AMfUCWrBl(const char *Cmd){
uint8_t blockNo = 0; uint8_t blockNo = 0;
bool chinese_card = 0; bool chinese_card = FALSE;
uint8_t bldata[16] = {0x00}; uint8_t bldata[16] = {0x00};
UsbCommand resp; UsbCommand resp;
if (strlen(Cmd)<3) { char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) < 3 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: hf mfu cwrbl <block number> <block data (8 hex symbols)> [w]"); PrintAndLog("Usage: hf mfu cwrbl <block number> <block data (8 hex symbols)> [w]");
PrintAndLog(" sample: hf mfu wrbl 0 01020304"); PrintAndLog(" [block number]");
PrintAndLog(" [block data] - (8 hex symbols)");
PrintAndLog(" [w] - Chinese magic ultralight tag");
PrintAndLog("");
PrintAndLog(" sample: hf mfu cwrbl 0 01020304");
PrintAndLog("");
return 0; return 0;
} }
blockNo = param_get8(Cmd, 0); blockNo = param_get8(Cmd, 0);
if (blockNo>(MAX_ULTRAC_BLOCKS+4)){ if (blockNo > (MAX_ULTRAC_BLOCKS+4) ){
PrintAndLog("Error: Maximum number of blocks is 47 for Ultralight Cards!"); PrintAndLog("Error: Maximum number of blocks is 47 for Ultralight-C Cards!");
return 1; return 1;
} }
if (param_gethex(Cmd, 1, bldata, 8)) { if (param_gethex(Cmd, 1, bldata, 8)) {
PrintAndLog("Block data must include 8 HEX symbols"); PrintAndLog("Block data must include 8 HEX symbols");
return 1; return 1;
} }
if (strchr(Cmd,'w') != 0) {
chinese_card=1; if (strchr(Cmd,'w') != 0 || strchr(Cmd,'W') != 0 ) {
chinese_card = TRUE;
} }
switch(blockNo){
case 0: if ( blockNo <= 3 ) {
if (!chinese_card){ if (!chinese_card){
PrintAndLog("Access Denied"); PrintAndLog("Access Denied");
}else{ } else {
PrintAndLog("--specialblock no:%02x", blockNo); PrintAndLog("--Special block no: 0x%02x", blockNo);
PrintAndLog("--data: %s", sprint_hex(bldata, 4)); PrintAndLog("--Data: %s", sprint_hex(bldata, 4));
UsbCommand d = {CMD_MIFAREU_WRITEBL, {blockNo}}; UsbCommand d = {CMD_MIFAREU_WRITEBL, {blockNo}};
memcpy(d.d.asBytes,bldata, 4); memcpy(d.d.asBytes,bldata, 4);
SendCommand(&d); SendCommand(&d);
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) { if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff; uint8_t isOK = resp.arg[0] & 0xff;
PrintAndLog("isOk:%02x", isOK); PrintAndLog("isOk:%02x", isOK);
} else { } else {
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
} }
} }
break; } else {
case 1: PrintAndLog("--Block no : 0x%02x", blockNo);
if (!chinese_card){ PrintAndLog("--Data: %s", sprint_hex(bldata, 4));
PrintAndLog("Access Denied");
}else{
PrintAndLog("--specialblock no:%02x", blockNo);
PrintAndLog("--data: %s", sprint_hex(bldata, 4));
UsbCommand d = {CMD_MIFAREU_WRITEBL, {blockNo}};
memcpy(d.d.asBytes,bldata, 4);
SendCommand(&d);
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff;
PrintAndLog("isOk:%02x", isOK);
} else {
PrintAndLog("Command execute timeout");
}
}
break;
case 2:
if (!chinese_card){
PrintAndLog("Access Denied");
}else{
PrintAndLog("--specialblock no:%02x", blockNo);
PrintAndLog("--data: %s", sprint_hex(bldata, 4));
UsbCommand c = {CMD_MIFAREU_WRITEBL, {blockNo}};
memcpy(c.d.asBytes, bldata, 4);
SendCommand(&c);
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff;
PrintAndLog("isOk:%02x", isOK);
} else {
PrintAndLog("Command execute timeout");
}
}
break;
case 3:
PrintAndLog("--specialblock no:%02x", blockNo);
PrintAndLog("--data: %s", sprint_hex(bldata, 4));
UsbCommand d = {CMD_MIFAREU_WRITEBL, {blockNo}};
memcpy(d.d.asBytes,bldata, 4);
SendCommand(&d);
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff;
PrintAndLog("isOk:%02x", isOK);
} else {
PrintAndLog("Command execute timeout");
}
break;
default:
PrintAndLog("--block no:%02x", blockNo);
PrintAndLog("--data: %s", sprint_hex(bldata, 4));
UsbCommand e = {CMD_MIFAREU_WRITEBL, {blockNo}}; UsbCommand e = {CMD_MIFAREU_WRITEBL, {blockNo}};
memcpy(e.d.asBytes,bldata, 4); memcpy(e.d.asBytes,bldata, 4);
SendCommand(&e); SendCommand(&e);
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) { if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff; uint8_t isOK = resp.arg[0] & 0xff;
PrintAndLog("isOk:%02x", isOK); PrintAndLog("isOk : %02x", isOK);
} else { } else {
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
} }
break; }
} return 0;
return 0;
} }
//------------------------------------ //------------------------------------
@ -687,12 +624,12 @@ static command_t CommandTable[] =
{"help", CmdHelp, 1,"This help"}, {"help", CmdHelp, 1,"This help"},
{"dbg", CmdHF14AMfDbg, 0,"Set default debug mode"}, {"dbg", CmdHF14AMfDbg, 0,"Set default debug mode"},
{"info", CmdHF14AMfUInfo, 0,"Taginfo"}, {"info", CmdHF14AMfUInfo, 0,"Taginfo"},
{"dump", CmdHF14AMfUDump, 0,"Dump MIFARE Ultralight / Ultralight-C tag to binary file"},
{"rdbl", CmdHF14AMfURdBl, 0,"Read block - MIFARE Ultralight"}, {"rdbl", CmdHF14AMfURdBl, 0,"Read block - MIFARE Ultralight"},
{"dump", CmdHF14AMfUDump, 0,"Dump MIFARE Ultralight / Ultralight-C tag to binary file"}, {"wrbl", CmdHF14AMfUWrBl, 0,"Write block - MIFARE Ultralight"},
{"wrbl", CmdHF14AMfUWrBl, 0,"Write block - MIFARE Ultralight"},
{"crdbl", CmdHF14AMfUCRdBl, 0,"Read block - MIFARE Ultralight C"}, {"crdbl", CmdHF14AMfUCRdBl, 0,"Read block - MIFARE Ultralight C"},
{"cwrbl", CmdHF14AMfUCWrBl, 0,"Write MIFARE Ultralight C block"}, {"cwrbl", CmdHF14AMfUCWrBl, 0,"Write MIFARE Ultralight C block"},
{"cauth", CmdHF14AMfucAuth, 0,"try a Ultralight C Authentication"}, {"cauth", CmdHF14AMfucAuth, 0,"try a Ultralight C Authentication"},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };