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();

88
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,16 +113,15 @@ 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];
}
} }
} }
@ -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,8 +534,7 @@ uint8_t NumBlocksPerSector(uint8_t sectorNo)
{ {
if (sectorNo < 32) if (sectorNo < 32)
return 4; return 4;
else return 16;
return 16;
} }
uint8_t FirstBlockOfSector(uint8_t sectorNo) uint8_t FirstBlockOfSector(uint8_t sectorNo)
@ -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;

184
client/proxmark3.c
View file

@ -35,21 +35,22 @@ volatile static bool txcmd_pending = false;
void SendCommand(UsbCommand *c) { void SendCommand(UsbCommand *c) {
#if 0 #if 0
printf("Sending %d bytes\n", sizeof(UsbCommand)); printf("Sending %d bytes\n", sizeof(UsbCommand));
#endif #endif
if (offline) { if (offline) {
PrintAndLog("Sending bytes to proxmark failed - offline"); PrintAndLog("Sending bytes to proxmark failed - offline");
return; return;
} }
/** /**
The while-loop below causes hangups at times, when the pm3 unit is unresponsive The while-loop below causes hangups at times, when the pm3 unit is unresponsive
or disconnected. The main console thread is alive, but comm thread just spins here. or disconnected. The main console thread is alive, but comm thread just spins here.
Not good.../holiman Not good.../holiman
**/ **/
while(txcmd_pending); while(txcmd_pending);
txcmd = *c;
txcmd_pending = true; txcmd = *c;
txcmd_pending = true;
} }
struct receiver_arg { struct receiver_arg {
@ -65,101 +66,105 @@ byte_t rx[0x1000000];
byte_t* prx = rx; byte_t* prx = rx;
static void *uart_receiver(void *targ) { static void *uart_receiver(void *targ) {
struct receiver_arg *arg = (struct receiver_arg*)targ; struct receiver_arg *arg = (struct receiver_arg*)targ;
size_t rxlen; size_t rxlen;
size_t cmd_count; size_t cmd_count;
while (arg->run) {
rxlen = sizeof(UsbCommand);
while (arg->run) {
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);
for (size_t i = 0; i < cmd_count; i++) { cmd_count = (prx-rx) / sizeof(UsbCommand);
UsbCommandReceived((UsbCommand*)(rx+(i*sizeof(UsbCommand))));
}
}
prx = rx;
if(txcmd_pending) { for (size_t i = 0; i < cmd_count; i++)
if (!uart_send(sp, (byte_t*) &txcmd, sizeof(UsbCommand))) { UsbCommandReceived((UsbCommand*)( rx + ( i * sizeof(UsbCommand))));
PrintAndLog("Sending bytes to proxmark failed");
}
txcmd_pending = false;
}
}
pthread_exit(NULL); }
return NULL; prx = rx;
if (txcmd_pending) {
if ( !uart_send(sp, (byte_t*) &txcmd, sizeof(UsbCommand))) {
PrintAndLog("Sending bytes to proxmark failed");
}
txcmd_pending = false;
}
}
pthread_exit(NULL);
return NULL;
} }
static void *main_loop(void *targ) { static void *main_loop(void *targ) {
struct main_loop_arg *arg = (struct main_loop_arg*)targ; struct main_loop_arg *arg = (struct main_loop_arg*)targ;
struct receiver_arg rarg; struct receiver_arg rarg;
char *cmd = NULL; char *cmd = NULL;
pthread_t reader_thread; pthread_t reader_thread;
if (arg->usb_present == 1) { if (arg->usb_present == 1) {
rarg.run = 1; rarg.run = 1;
pthread_create(&reader_thread, NULL, &uart_receiver, &rarg); pthread_create(&reader_thread, NULL, &uart_receiver, &rarg);
// cache Version information now: // cache Version information now:
CmdVersion(NULL); CmdVersion(NULL);
} }
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) {
printf("using 'scripting' commands file %s\n", arg->script_cmds_file); if (script_file)
} printf("using 'scripting' commands file %s\n", arg->script_cmds_file);
} }
read_history(".history"); read_history(".history");
while(1) { while(1) {
// If there is a script file // If there is a script file
if (script_file) if (script_file)
{ {
if (!fgets(script_cmd_buf, sizeof(script_cmd_buf), script_file)) { if (!fgets(script_cmd_buf, sizeof(script_cmd_buf), script_file)) {
fclose(script_file); fclose(script_file);
script_file = NULL; script_file = NULL;
} 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));
strcpy(cmd, script_cmd_buf); strcpy(cmd, script_cmd_buf);
printf("%s\n", cmd); printf("%s\n", cmd);
} }
} }
} } else {
cmd = readline(PROXPROMPT);
if (!script_file) {
cmd = readline(PROXPROMPT);
} }
if (cmd) { if (cmd) {
while(cmd[strlen(cmd) - 1] == ' ') while(cmd[strlen(cmd) - 1] == ' ')
cmd[strlen(cmd) - 1] = 0x00; cmd[strlen(cmd) - 1] = 0x00;
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 {
@ -170,29 +175,29 @@ static void *main_loop(void *targ) {
write_history(".history"); write_history(".history");
if (arg->usb_present == 1) { if (arg->usb_present == 1) {
rarg.run = 0; rarg.run = 0;
pthread_join(reader_thread, NULL); pthread_join(reader_thread, NULL);
} }
if (script_file) { if (script_file) {
fclose(script_file); fclose(script_file);
script_file = NULL; script_file = NULL;
} }
ExitGraphics(); ExitGraphics();
pthread_exit(NULL); pthread_exit(NULL);
return NULL; return NULL;
} }
static void dumpAllHelp(int markdown) static void dumpAllHelp(int markdown)
{ {
printf("\n%sProxmark3 command dump%s\n\n",markdown?"# ":"",markdown?"":"\n======================"); printf("\n%sProxmark3 command dump%s\n\n",markdown?"# ":"",markdown?"":"\n======================");
printf("Some commands are available only if a Proxmark is actually connected.%s\n",markdown?" ":""); printf("Some commands are available only if a Proxmark is actually connected.%s\n",markdown?" ":"");
printf("Check column \"offline\" for their availability.\n"); printf("Check column \"offline\" for their availability.\n");
printf("\n"); printf("\n");
command_t *cmds = getTopLevelCommandTable(); command_t *cmds = getTopLevelCommandTable();
dumpCommandsRecursive(cmds, markdown); dumpCommandsRecursive(cmds, markdown);
} }
int main(int argc, char* argv[]) { int main(int argc, char* argv[]) {
@ -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,8 +256,9 @@ 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
@ -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);