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

Merge branch 'master' of https://github.com/iceman1001/proxmark3

Browse source
This commit is contained in:
iceman 2016-01-12 17:18:11 +01:00
commit 2c29cba82a
4 changed files with 176 additions and 178 deletions
Download patch file Download diff file Expand all files Collapse all files

66
armsrc/mifarecmd.c
View file

@ -34,9 +34,9 @@ void MifareReadBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
// variables // variables
byte_t isOK = 0; byte_t isOK = 0;
byte_t dataoutbuf[16]; byte_t dataoutbuf[16] = {0x00};
uint8_t uid[10]; uint8_t uid[10] = {0x00};
uint32_t cuid; uint32_t cuid = 0;
struct Crypto1State mpcs = {0, 0}; struct Crypto1State mpcs = {0, 0};
struct Crypto1State *pcs; struct Crypto1State *pcs;
pcs = &mpcs; pcs = &mpcs;
@ -193,8 +193,8 @@ void MifareReadSector(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
// variables // variables
byte_t isOK = 0; byte_t isOK = 0;
byte_t dataoutbuf[16 * 16]; byte_t dataoutbuf[16 * 16];
uint8_t uid[10]; uint8_t uid[10] = {0x00};
uint32_t cuid; uint32_t cuid = 0;
struct Crypto1State mpcs = {0, 0}; struct Crypto1State mpcs = {0, 0};
struct Crypto1State *pcs; struct Crypto1State *pcs;
pcs = &mpcs; pcs = &mpcs;
@ -352,15 +352,15 @@ void MifareWriteBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
uint8_t blockNo = arg0; uint8_t blockNo = arg0;
uint8_t keyType = arg1; uint8_t keyType = arg1;
uint64_t ui64Key = 0; uint64_t ui64Key = 0;
byte_t blockdata[16]; byte_t blockdata[16] = {0x00};
ui64Key = bytes_to_num(datain, 6); ui64Key = bytes_to_num(datain, 6);
memcpy(blockdata, datain + 10, 16); memcpy(blockdata, datain + 10, 16);
// variables // variables
byte_t isOK = 0; byte_t isOK = 0;
uint8_t uid[10]; uint8_t uid[10] = {0x00};
uint32_t cuid; uint32_t cuid = 0;
struct Crypto1State mpcs = {0, 0}; struct Crypto1State mpcs = {0, 0};
struct Crypto1State *pcs; struct Crypto1State *pcs;
pcs = &mpcs; pcs = &mpcs;
@ -607,18 +607,18 @@ int valid_nonce(uint32_t Nt, uint32_t NtEnc, uint32_t Ks1, uint8_t *parity) {
void MifareAcquireEncryptedNonces(uint32_t arg0, uint32_t arg1, uint32_t flags, uint8_t *datain) void MifareAcquireEncryptedNonces(uint32_t arg0, uint32_t arg1, uint32_t flags, uint8_t *datain)
{ {
uint64_t ui64Key = 0; uint64_t ui64Key = 0;
uint8_t uid[10]; uint8_t uid[10] = {0x00};
uint32_t cuid = 0; uint32_t cuid = 0;
uint8_t cascade_levels = 0; uint8_t cascade_levels = 0;
struct Crypto1State mpcs = {0, 0}; struct Crypto1State mpcs = {0, 0};
struct Crypto1State *pcs; struct Crypto1State *pcs;
pcs = &mpcs; pcs = &mpcs;
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE]; uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
int16_t isOK = 0; int16_t isOK = 0;
uint8_t par_enc[1]; uint8_t par_enc[1] = {0x00};
uint8_t nt_par_enc = 0; uint8_t nt_par_enc = 0;
uint8_t buf[USB_CMD_DATA_SIZE]; uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
uint32_t timeout; uint32_t timeout = 0;
uint8_t blockNo = arg0 & 0xff; uint8_t blockNo = arg0 & 0xff;
uint8_t keyType = (arg0 >> 8) & 0xff; uint8_t keyType = (arg0 >> 8) & 0xff;
@ -747,14 +747,14 @@ void MifareNested(uint32_t arg0, uint32_t arg1, uint32_t calibrate, uint8_t *dat
// variables // variables
uint16_t rtr, i, j, len; uint16_t rtr, i, j, len;
uint16_t davg; uint16_t davg = 0;
static uint16_t dmin, dmax; static uint16_t dmin, dmax;
uint8_t uid[10]; uint8_t uid[10] = {0x00};
uint32_t cuid, nt1, nt2, nttmp, nttest, ks1; uint32_t cuid, nt1, nt2, nttmp, nttest, ks1;
uint8_t par[1]; uint8_t par[1] = {0x00};
uint32_t target_nt[2], target_ks[2]; uint32_t target_nt[2] = {0x00}, target_ks[2] = {0x00};
uint8_t par_array[4]; uint8_t par_array[4] = {0x00};
uint16_t ncount = 0; uint16_t ncount = 0;
struct Crypto1State mpcs = {0, 0}; struct Crypto1State mpcs = {0, 0};
struct Crypto1State *pcs; struct Crypto1State *pcs;
@ -967,8 +967,8 @@ void MifareChkKeys(uint16_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
// variables // variables
int i; int i;
byte_t isOK = 0; byte_t isOK = 0;
uint8_t uid[10]; uint8_t uid[10] = {0x00};
uint32_t cuid; uint32_t cuid = 0;
struct Crypto1State mpcs = {0, 0}; struct Crypto1State mpcs = {0, 0};
struct Crypto1State *pcs; struct Crypto1State *pcs;
pcs = &mpcs; pcs = &mpcs;
@ -1049,7 +1049,7 @@ void MifareEMemSet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
void MifareEMemGet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain){ void MifareEMemGet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain){
FpgaDownloadAndGo(FPGA_BITSTREAM_HF); FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
byte_t buf[USB_CMD_DATA_SIZE]; byte_t buf[USB_CMD_DATA_SIZE] = {0x00};
emlGetMem(buf, arg0, arg1); // data, block num, blocks count (max 4) emlGetMem(buf, arg0, arg1); // data, block num, blocks count (max 4)
LED_B_ON(); LED_B_ON();
@ -1065,15 +1065,15 @@ void MifareECardLoad(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
uint8_t numSectors = arg0; uint8_t numSectors = arg0;
uint8_t keyType = arg1; uint8_t keyType = arg1;
uint64_t ui64Key = 0; uint64_t ui64Key = 0;
uint32_t cuid; uint32_t cuid = 0;
struct Crypto1State mpcs = {0, 0}; struct Crypto1State mpcs = {0, 0};
struct Crypto1State *pcs; struct Crypto1State *pcs;
pcs = &mpcs; pcs = &mpcs;
// variables // variables
byte_t dataoutbuf[16]; byte_t dataoutbuf[16] = {0x00};
byte_t dataoutbuf2[16]; byte_t dataoutbuf2[16] = {0x00};
uint8_t uid[10]; uint8_t uid[10] = {0x00};
LED_A_ON(); LED_A_ON();
LED_B_OFF(); LED_B_OFF();
@ -1111,7 +1111,7 @@ void MifareECardLoad(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
isOK = false; isOK = false;
if (MF_DBGLEVEL >= 1) Dbprintf("Error reading sector %2d block %2d", sectorNo, blockNo); if (MF_DBGLEVEL >= 1) Dbprintf("Error reading sector %2d block %2d", sectorNo, blockNo);
break; break;
}; }
if (isOK) { if (isOK) {
if (blockNo < NumBlocksPerSector(sectorNo) - 1) { if (blockNo < NumBlocksPerSector(sectorNo) - 1) {
emlSetMem(dataoutbuf, FirstBlockOfSector(sectorNo) + blockNo, 1); emlSetMem(dataoutbuf, FirstBlockOfSector(sectorNo) + blockNo, 1);
@ -1125,9 +1125,9 @@ void MifareECardLoad(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
} }
if(mifare_classic_halt(pcs, cuid)) { if(mifare_classic_halt(pcs, cuid))
if (MF_DBGLEVEL >= 1) Dbprintf("Halt error"); if (MF_DBGLEVEL >= 1)
}; Dbprintf("Halt error");
// ----------------------------- crypto1 destroy // ----------------------------- crypto1 destroy
crypto1_destroy(pcs); crypto1_destroy(pcs);
@ -1169,7 +1169,7 @@ void MifareCSetBlock(uint32_t arg0, uint32_t arg1, uint8_t *datain){
// variables // variables
uint8_t uid[10] = {0x00}; uint8_t uid[10] = {0x00};
uint8_t data[18] = {0x00}; uint8_t data[18] = {0x00};
uint32_t cuid; uint32_t cuid = 0;
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE]; uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE]; uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];
@ -1310,8 +1310,8 @@ void MifareCIdent(){
// variables // variables
bool isOK = true; bool isOK = true;
uint8_t receivedAnswer[1]; uint8_t receivedAnswer[1] = {0x00};
uint8_t receivedAnswerPar[1]; uint8_t receivedAnswerPar[1] = {0x00};
ReaderTransmitBitsPar(wupC1,7,0, NULL); ReaderTransmitBitsPar(wupC1,7,0, NULL);
if(!ReaderReceive(receivedAnswer, receivedAnswerPar) || (receivedAnswer[0] != 0x0a)) { if(!ReaderReceive(receivedAnswer, receivedAnswerPar) || (receivedAnswer[0] != 0x0a)) {
@ -1350,7 +1350,7 @@ void Mifare_DES_Auth1(uint8_t arg0, uint8_t *datain){
byte_t dataout[12] = {0x00}; byte_t dataout[12] = {0x00};
uint8_t uid[10] = {0x00}; uint8_t uid[10] = {0x00};
uint32_t cuid = 0x00; uint32_t cuid = 0;
iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN); iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN);
clear_trace(); clear_trace();

86
armsrc/mifareutil.c
View file

@ -32,10 +32,10 @@ void mf_crypto1_decrypt(struct Crypto1State *pcs, uint8_t *data, int len){
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
data[i] = crypto1_byte(pcs, 0x00, 0) ^ data[i]; data[i] = crypto1_byte(pcs, 0x00, 0) ^ data[i];
} else { } else {
bt = 0; bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data[0], 0)) << 0;
for (i = 0; i < 4; i++) bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data[0], 1)) << 1;
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data[0], i)) << i; bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data[0], 2)) << 2;
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data[0], 3)) << 3;
data[0] = bt; data[0] = bt;
} }
return; return;
@ -49,20 +49,18 @@ void mf_crypto1_encrypt(struct Crypto1State *pcs, uint8_t *data, uint16_t len, u
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
bt = data[i]; bt = data[i];
data[i] = crypto1_byte(pcs, 0x00, 0) ^ data[i]; data[i] = crypto1_byte(pcs, 0x00, 0) ^ data[i];
if((i&0x0007) == 0) if ((i&0x0007) == 0)
par[i>>3] = 0; par[i>>3] = 0;
par[i>>3] |= (((filter(pcs->odd) ^ oddparity8(bt)) & 0x01)<<(7-(i&0x0007))); par[i>>3] |= (((filter(pcs->odd) ^ oddparity8(bt)) & 0x01)<<(7-(i&0x0007)));
} }
return;
} }
uint8_t mf_crypto1_encrypt4bit(struct Crypto1State *pcs, uint8_t data) { uint8_t mf_crypto1_encrypt4bit(struct Crypto1State *pcs, uint8_t data) {
uint8_t bt = 0; uint8_t bt = 0;
int i; bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data, 0)) << 0;
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data, 1)) << 1;
for (i = 0; i < 4; i++) bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data, 2)) << 2;
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data, i)) << i; bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data, 3)) << 3;
return bt; return bt;
} }
@ -78,7 +76,6 @@ int mifare_sendcmd(uint8_t cmd, uint8_t* data, uint8_t data_size, uint8_t* answe
if(!len) { if(!len) {
if (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("%02X Cmd failed. Card timeout.", cmd); if (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("%02X Cmd failed. Card timeout.", cmd);
len = ReaderReceive(answer,answer_parity); len = ReaderReceive(answer,answer_parity);
//return 0;
} }
return len; return len;
} }
@ -86,9 +83,10 @@ int mifare_sendcmd(uint8_t cmd, uint8_t* data, uint8_t data_size, uint8_t* answe
// send 2 byte commands // send 2 byte commands
int mifare_sendcmd_short(struct Crypto1State *pcs, uint8_t crypted, uint8_t cmd, uint8_t data, uint8_t *answer, uint8_t *answer_parity, uint32_t *timing) int mifare_sendcmd_short(struct Crypto1State *pcs, uint8_t crypted, uint8_t cmd, uint8_t data, uint8_t *answer, uint8_t *answer_parity, uint32_t *timing)
{ {
uint8_t dcmd[4], ecmd[4]; uint8_t dcmd[4] = {0x00};
uint8_t ecmd[4] = {0x00};
uint16_t pos, res; uint16_t pos, res;
uint8_t par[1]; // 1 Byte parity is enough here uint8_t par[1] = {0x00}; // 1 Byte parity is enough here
dcmd[0] = cmd; dcmd[0] = cmd;
dcmd[1] = data; dcmd[1] = data;
AppendCrc14443a(dcmd, 2); AppendCrc14443a(dcmd, 2);
@ -97,8 +95,7 @@ int mifare_sendcmd_short(struct Crypto1State *pcs, uint8_t crypted, uint8_t cmd,
if (crypted) { if (crypted) {
par[0] = 0; par[0] = 0;
for (pos = 0; pos < 4; pos++) for (pos = 0; pos < 4; pos++) {
{
ecmd[pos] = crypto1_byte(pcs, 0x00, 0) ^ dcmd[pos]; ecmd[pos] = crypto1_byte(pcs, 0x00, 0) ^ dcmd[pos];
par[0] |= (((filter(pcs->odd) ^ oddparity8(dcmd[pos])) & 0x01) << (7-pos)); par[0] |= (((filter(pcs->odd) ^ oddparity8(dcmd[pos])) & 0x01) << (7-pos));
} }
@ -116,18 +113,17 @@ int mifare_sendcmd_short(struct Crypto1State *pcs, uint8_t crypted, uint8_t cmd,
if (crypted == CRYPT_ALL) { if (crypted == CRYPT_ALL) {
if (len == 1) { if (len == 1) {
res = 0; res = 0;
for (pos = 0; pos < 4; pos++) res |= (crypto1_bit(pcs, 0, 0) ^ BIT(answer[0], 0)) << 0;
res |= (crypto1_bit(pcs, 0, 0) ^ BIT(answer[0], pos)) << pos; res |= (crypto1_bit(pcs, 0, 0) ^ BIT(answer[0], 1)) << 1;
res |= (crypto1_bit(pcs, 0, 0) ^ BIT(answer[0], 2)) << 2;
res |= (crypto1_bit(pcs, 0, 0) ^ BIT(answer[0], 3)) << 3;
answer[0] = res; answer[0] = res;
} else { } else {
for (pos = 0; pos < len; pos++) for (pos = 0; pos < len; pos++)
{
answer[pos] = crypto1_byte(pcs, 0x00, 0) ^ answer[pos]; answer[pos] = crypto1_byte(pcs, 0x00, 0) ^ answer[pos];
} }
} }
}
return len; return len;
} }
@ -143,7 +139,7 @@ int mifare_classic_authex(struct Crypto1State *pcs, uint32_t uid, uint8_t blockN
// variables // variables
int len; int len;
uint32_t pos; uint32_t pos;
uint8_t tmp4[4]; uint8_t tmp4[4] = {0x00};
uint8_t par[1] = {0x00}; uint8_t par[1] = {0x00};
// "random" reader nonce: // "random" reader nonce:
@ -232,10 +228,10 @@ int mifare_classic_readblock(struct Crypto1State *pcs, uint32_t uid, uint8_t blo
{ {
// variables // variables
int len; int len;
uint8_t bt[2]; uint8_t bt[2] = {0x00};
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE]; uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE]; uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE] = {0x00};
// command MIFARE_CLASSIC_READBLOCK // command MIFARE_CLASSIC_READBLOCK
len = mifare_sendcmd_short(pcs, 1, 0x30, blockNo, receivedAnswer, receivedAnswerPar, NULL); len = mifare_sendcmd_short(pcs, 1, 0x30, blockNo, receivedAnswer, receivedAnswerPar, NULL);
@ -263,13 +259,14 @@ int mifare_classic_readblock(struct Crypto1State *pcs, uint32_t uid, uint8_t blo
int mifare_ul_ev1_auth(uint8_t *keybytes, uint8_t *pack){ int mifare_ul_ev1_auth(uint8_t *keybytes, uint8_t *pack){
uint16_t len; uint16_t len;
uint8_t resp[4]; uint8_t resp[4] = {0x00};
uint8_t respPar[1]; uint8_t respPar[1] = {0x00};
uint8_t key[4] = {0x00}; uint8_t key[4] = {0x00};
memcpy(key, keybytes, 4); memcpy(key, keybytes, 4);
if (MF_DBGLEVEL >= MF_DBG_EXTENDED) if (MF_DBGLEVEL >= MF_DBG_EXTENDED)
Dbprintf("EV1 Auth : %02x%02x%02x%02x", key[0], key[1], key[2], key[3]); Dbprintf("EV1 Auth : %02x%02x%02x%02x", key[0], key[1], key[2], key[3]);
len = mifare_sendcmd(0x1B, key, sizeof(key), resp, respPar, NULL); len = mifare_sendcmd(0x1B, key, sizeof(key), resp, respPar, NULL);
if (len != 4) { if (len != 4) {
@ -374,9 +371,8 @@ int mifare_ultra_readblock(uint8_t blockNo, uint8_t *blockData)
{ {
uint16_t len; uint16_t len;
uint8_t bt[2]; uint8_t bt[2];
uint8_t receivedAnswer[MAX_FRAME_SIZE]; uint8_t receivedAnswer[MAX_FRAME_SIZE] = {0x00};
uint8_t receivedAnswerPar[MAX_PARITY_SIZE]; uint8_t receivedAnswerPar[MAX_PARITY_SIZE] = {0x00};
len = mifare_sendcmd_short(NULL, 1, 0x30, blockNo, receivedAnswer, receivedAnswerPar, NULL); len = mifare_sendcmd_short(NULL, 1, 0x30, blockNo, receivedAnswer, receivedAnswerPar, NULL);
if (len == 1) { if (len == 1) {
@ -408,8 +404,8 @@ int mifare_classic_writeblock(struct Crypto1State *pcs, uint32_t uid, uint8_t bl
byte_t res = 0; byte_t res = 0;
uint8_t d_block[18], d_block_enc[18]; uint8_t d_block[18], d_block_enc[18];
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE]; uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE]; uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE] = {0x00};
// command MIFARE_CLASSIC_WRITEBLOCK // command MIFARE_CLASSIC_WRITEBLOCK
len = mifare_sendcmd_short(pcs, 1, 0xA0, blockNo, receivedAnswer, receivedAnswerPar, NULL); len = mifare_sendcmd_short(pcs, 1, 0xA0, blockNo, receivedAnswer, receivedAnswerPar, NULL);
@ -483,8 +479,8 @@ int mifare_ultra_writeblock(uint8_t blockNo, uint8_t *blockData)
{ {
uint16_t len; uint16_t len;
uint8_t d_block[5] = {0x00}; uint8_t d_block[5] = {0x00};
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE]; uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE]; uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE] = {0x00};
// command MIFARE_CLASSIC_WRITEBLOCK // command MIFARE_CLASSIC_WRITEBLOCK
d_block[0]= blockNo; d_block[0]= blockNo;
@ -502,8 +498,8 @@ int mifare_ultra_writeblock(uint8_t blockNo, uint8_t *blockData)
} }
int mifare_classic_halt_ex(struct Crypto1State *pcs) { int mifare_classic_halt_ex(struct Crypto1State *pcs) {
uint16_t len; uint16_t len;
uint8_t receivedAnswer[4]; uint8_t receivedAnswer[4] = {0x00};
uint8_t receivedAnswerPar[4]; uint8_t receivedAnswerPar[4] = {0x00};
len = mifare_sendcmd_short(pcs, pcs == NULL ? false:true, 0x50, 0x00, receivedAnswer, receivedAnswerPar, NULL); len = mifare_sendcmd_short(pcs, pcs == NULL ? false:true, 0x50, 0x00, receivedAnswer, receivedAnswerPar, NULL);
if (len != 0) { if (len != 0) {
@ -519,8 +515,8 @@ int mifare_classic_halt(struct Crypto1State *pcs, uint32_t uid) {
int mifare_ultra_halt() int mifare_ultra_halt()
{ {
uint16_t len; uint16_t len;
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE]; uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE]; uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE] = {0x00};
len = mifare_sendcmd_short(NULL, true, 0x50, 0x00, receivedAnswer, receivedAnswerPar, NULL); len = mifare_sendcmd_short(NULL, true, 0x50, 0x00, receivedAnswer, receivedAnswerPar, NULL);
if (len != 0) { if (len != 0) {
@ -538,7 +534,6 @@ uint8_t NumBlocksPerSector(uint8_t sectorNo)
{ {
if (sectorNo < 32) if (sectorNo < 32)
return 4; return 4;
else
return 16; return 16;
} }
@ -591,9 +586,8 @@ int emlGetValBl(uint32_t *blReg, uint8_t *blBlock, int blockNum) {
uint8_t* emCARD = BigBuf_get_EM_addr(); uint8_t* emCARD = BigBuf_get_EM_addr();
uint8_t* data = emCARD + blockNum * 16; uint8_t* data = emCARD + blockNum * 16;
if (emlCheckValBl(blockNum)) { if (emlCheckValBl(blockNum))
return 1; return 1;
}
memcpy(blReg, data, 4); memcpy(blReg, data, 4);
*blBlock = data[12]; *blBlock = data[12];
@ -618,7 +612,7 @@ int emlSetValBl(uint32_t blReg, uint8_t blBlock, int blockNum) {
} }
uint64_t emlGetKey(int sectorNum, int keyType) { uint64_t emlGetKey(int sectorNum, int keyType) {
uint8_t key[6]; uint8_t key[6] = {0x00};
uint8_t* emCARD = BigBuf_get_EM_addr(); uint8_t* emCARD = BigBuf_get_EM_addr();
memcpy(key, emCARD + 16 * (FirstBlockOfSector(sectorNum) + NumBlocksPerSector(sectorNum) - 1) + keyType * 10, 6); memcpy(key, emCARD + 16 * (FirstBlockOfSector(sectorNum) + NumBlocksPerSector(sectorNum) - 1) + keyType * 10, 6);
@ -685,8 +679,8 @@ int mifare_desfire_des_auth1(uint32_t uid, uint8_t *blockData){
int len; int len;
// load key, keynumber // load key, keynumber
uint8_t data[2]={0x0a, 0x00}; uint8_t data[2]={0x0a, 0x00};
uint8_t receivedAnswer[MAX_FRAME_SIZE]; uint8_t receivedAnswer[MAX_FRAME_SIZE] = {0x00};
uint8_t receivedAnswerPar[MAX_PARITY_SIZE]; uint8_t receivedAnswerPar[MAX_PARITY_SIZE] = {0x00};
len = mifare_sendcmd_special(NULL, 1, 0x02, data, receivedAnswer,receivedAnswerPar,NULL); len = mifare_sendcmd_special(NULL, 1, 0x02, data, receivedAnswer,receivedAnswerPar,NULL);
if (len == 1) { if (len == 1) {
@ -715,8 +709,8 @@ int mifare_desfire_des_auth2(uint32_t uid, uint8_t *key, uint8_t *blockData){
data[0] = 0xAF; data[0] = 0xAF;
memcpy(data+1,key,16); memcpy(data+1,key,16);
uint8_t receivedAnswer[MAX_FRAME_SIZE]; uint8_t receivedAnswer[MAX_FRAME_SIZE] = {0x00};
uint8_t receivedAnswerPar[MAX_PARITY_SIZE]; uint8_t receivedAnswerPar[MAX_PARITY_SIZE] = {0x00};
len = mifare_sendcmd_special2(NULL, 1, 0x03, data, receivedAnswer, receivedAnswerPar ,NULL); len = mifare_sendcmd_special2(NULL, 1, 0x03, data, receivedAnswer, receivedAnswerPar ,NULL);

14
client/cmdhflegic.c
View file

@ -182,7 +182,7 @@ int CmdLegicLoad(const char *Cmd) {
char cmdp = param_getchar(Cmd, 0); char cmdp = param_getchar(Cmd, 0);
if ( cmdp == 'H' || cmdp == 'h' || cmdp == 0x00) { if ( cmdp == 'H' || cmdp == 'h' || cmdp == 0x00) {
PrintAndLog("It loads datasamples from the file `filename`"); PrintAndLog("It loads datasamples from the file `filename` to device memory");
PrintAndLog("Usage: hf legic load <file name>"); PrintAndLog("Usage: hf legic load <file name>");
PrintAndLog(" sample: hf legic load filename"); PrintAndLog(" sample: hf legic load filename");
return 0; return 0;
@ -209,17 +209,16 @@ int CmdLegicLoad(const char *Cmd) {
int res = sscanf(line, "%x %x %x %x %x %x %x %x", int res = sscanf(line, "%x %x %x %x %x %x %x %x",
&data[0], &data[1], &data[2], &data[3], &data[0], &data[1], &data[2], &data[3],
&data[4], &data[5], &data[6], &data[7]); &data[4], &data[5], &data[6], &data[7]);
if(res != 8) { if(res != 8) {
PrintAndLog("Error: could not read samples"); PrintAndLog("Error: could not read samples");
fclose(f); fclose(f);
return -1; return -1;
} }
UsbCommand c = { CMD_DOWNLOADED_SIM_SAMPLES_125K, {offset, 0, 0}}; UsbCommand c = { CMD_DOWNLOADED_SIM_SAMPLES_125K, {offset, 0, 0}};
memcpy(c.d.asBytes, data, 8);
for( j = 0; j < 8; j++) { clearCommandBuffer();
c.d.asBytes[j] = data[j];
}
SendCommand(&c); SendCommand(&c);
WaitForResponse(CMD_ACK, NULL); WaitForResponse(CMD_ACK, NULL);
offset += 8; offset += 8;
@ -240,9 +239,8 @@ int CmdLegicSave(const char *Cmd) {
/* If no length given save entire legic read buffer */ /* If no length given save entire legic read buffer */
/* round up to nearest 8 bytes so the saved data can be used with legicload */ /* round up to nearest 8 bytes so the saved data can be used with legicload */
if (requested == 0) { if (requested == 0)
requested = 1024; requested = 1024;
}
if (requested % 8 != 0) { if (requested % 8 != 0) {
int remainder = requested % 8; int remainder = requested % 8;

46
client/proxmark3.c
View file

@ -48,6 +48,7 @@ void SendCommand(UsbCommand *c) {
Not good.../holiman Not good.../holiman
**/ **/
while(txcmd_pending); while(txcmd_pending);
txcmd = *c; txcmd = *c;
txcmd_pending = true; txcmd_pending = true;
} }
@ -70,22 +71,24 @@ static void *uart_receiver(void *targ) {
size_t cmd_count; size_t cmd_count;
while (arg->run) { while (arg->run) {
rxlen = sizeof(UsbCommand); rxlen = sizeof(UsbCommand);
if (uart_receive(sp, prx, &rxlen)) { if (uart_receive(sp, prx, &rxlen)) {
prx += rxlen; prx += rxlen;
if (((prx-rx) % sizeof(UsbCommand)) != 0) { if (((prx-rx) % sizeof(UsbCommand)) != 0)
continue; continue;
}
cmd_count = (prx-rx) / sizeof(UsbCommand); cmd_count = (prx-rx) / sizeof(UsbCommand);
for (size_t i = 0; i < cmd_count; i++) { for (size_t i = 0; i < cmd_count; i++)
UsbCommandReceived((UsbCommand*)(rx+(i*sizeof(UsbCommand)))); UsbCommandReceived((UsbCommand*)( rx + ( i * sizeof(UsbCommand))));
}
} }
prx = rx; prx = rx;
if(txcmd_pending) { if (txcmd_pending) {
if (!uart_send(sp, (byte_t*) &txcmd, sizeof(UsbCommand))) { if ( !uart_send(sp, (byte_t*) &txcmd, sizeof(UsbCommand))) {
PrintAndLog("Sending bytes to proxmark failed"); PrintAndLog("Sending bytes to proxmark failed");
} }
txcmd_pending = false; txcmd_pending = false;
@ -110,13 +113,13 @@ static void *main_loop(void *targ) {
} }
FILE *script_file = NULL; FILE *script_file = NULL;
char script_cmd_buf[256]; // iceman, needs lua script the same file_path_buffer as the rest char script_cmd_buf[256] = {0x00}; // iceman, needs lua script the same file_path_buffer as the rest
if (arg->script_cmds_file) { if (arg->script_cmds_file) {
script_file = fopen(arg->script_cmds_file, "r"); script_file = fopen(arg->script_cmds_file, "r");
if (script_file) {
if (script_file)
printf("using 'scripting' commands file %s\n", arg->script_cmds_file); printf("using 'scripting' commands file %s\n", arg->script_cmds_file);
}
} }
read_history(".history"); read_history(".history");
@ -132,10 +135,13 @@ static void *main_loop(void *targ) {
} else { } else {
char *nl; char *nl;
nl = strrchr(script_cmd_buf, '\r'); nl = strrchr(script_cmd_buf, '\r');
if (nl) *nl = '\0'; if (nl)
*nl = '\0';
nl = strrchr(script_cmd_buf, '\n'); nl = strrchr(script_cmd_buf, '\n');
if (nl) *nl = '\0';
if (nl)
*nl = '\0';
if ((cmd = (char*) malloc(strlen(script_cmd_buf) + 1)) != NULL) { if ((cmd = (char*) malloc(strlen(script_cmd_buf) + 1)) != NULL) {
memset(cmd, 0, strlen(script_cmd_buf)); memset(cmd, 0, strlen(script_cmd_buf));
@ -143,9 +149,7 @@ static void *main_loop(void *targ) {
printf("%s\n", cmd); printf("%s\n", cmd);
} }
} }
} } else {
if (!script_file) {
cmd = readline(PROXPROMPT); cmd = readline(PROXPROMPT);
} }
@ -157,10 +161,11 @@ static void *main_loop(void *targ) {
if (cmd[0] != 0x00) { if (cmd[0] != 0x00) {
int ret = CommandReceived(cmd); int ret = CommandReceived(cmd);
add_history(cmd); add_history(cmd);
if (ret == 99) { // exit or quit
// exit or quit
if (ret == 99)
break; break;
} }
}
free(cmd); free(cmd);
} else { } else {
printf("\n"); printf("\n");
@ -222,6 +227,7 @@ int main(int argc, char* argv[]) {
.usb_present = 0, .usb_present = 0,
.script_cmds_file = NULL .script_cmds_file = NULL
}; };
pthread_t main_loop_threat; pthread_t main_loop_threat;
@ -250,9 +256,10 @@ int main(int argc, char* argv[]) {
printf("Output will be flushed after every print.\n"); printf("Output will be flushed after every print.\n");
flushAfterWrite = 1; flushAfterWrite = 1;
} }
else else {
marg.script_cmds_file = argv[2]; marg.script_cmds_file = argv[2];
} }
}
// create a mutex to avoid interlacing print commands from our different threads // create a mutex to avoid interlacing print commands from our different threads
pthread_mutex_init(&print_lock, NULL); pthread_mutex_init(&print_lock, NULL);
@ -265,9 +272,8 @@ int main(int argc, char* argv[]) {
pthread_join(main_loop_threat, NULL); pthread_join(main_loop_threat, NULL);
// Clean up the port // Clean up the port
if (offline == 0) { if (offline == 0)
uart_close(sp); uart_close(sp);
}
// clean up mutex // clean up mutex
pthread_mutex_destroy(&print_lock); pthread_mutex_destroy(&print_lock);