mirror of
https://github.com/RfidResearchGroup/proxmark3.git
synced 2025-02-14 03:03:14 +08:00
Merge branch 'master' of https://github.com/iceman1001/proxmark3
This commit is contained in:
iceman
commit
2c29cba82a
4 changed files with 176 additions and 178 deletions
|
|
@ -34,9 +34,9 @@ void MifareReadBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
|
|||
|
||||
// variables
|
||||
byte_t isOK = 0;
|
||||
byte_t dataoutbuf[16];
|
||||
uint8_t uid[10];
|
||||
uint32_t cuid;
|
||||
byte_t dataoutbuf[16] = {0x00};
|
||||
uint8_t uid[10] = {0x00};
|
||||
uint32_t cuid = 0;
|
||||
struct Crypto1State mpcs = {0, 0};
|
||||
struct Crypto1State *pcs;
|
||||
pcs = &mpcs;
|
||||
|
|
@ -193,8 +193,8 @@ void MifareReadSector(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
|
|||
// variables
|
||||
byte_t isOK = 0;
|
||||
byte_t dataoutbuf[16 * 16];
|
||||
uint8_t uid[10];
|
||||
uint32_t cuid;
|
||||
uint8_t uid[10] = {0x00};
|
||||
uint32_t cuid = 0;
|
||||
struct Crypto1State mpcs = {0, 0};
|
||||
struct Crypto1State *pcs;
|
||||
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 keyType = arg1;
|
||||
uint64_t ui64Key = 0;
|
||||
byte_t blockdata[16];
|
||||
byte_t blockdata[16] = {0x00};
|
||||
|
||||
ui64Key = bytes_to_num(datain, 6);
|
||||
memcpy(blockdata, datain + 10, 16);
|
||||
|
||||
// variables
|
||||
byte_t isOK = 0;
|
||||
uint8_t uid[10];
|
||||
uint32_t cuid;
|
||||
uint8_t uid[10] = {0x00};
|
||||
uint32_t cuid = 0;
|
||||
struct Crypto1State mpcs = {0, 0};
|
||||
struct Crypto1State *pcs;
|
||||
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)
|
||||
{
|
||||
uint64_t ui64Key = 0;
|
||||
uint8_t uid[10];
|
||||
uint8_t uid[10] = {0x00};
|
||||
uint32_t cuid = 0;
|
||||
uint8_t cascade_levels = 0;
|
||||
struct Crypto1State mpcs = {0, 0};
|
||||
struct Crypto1State *pcs;
|
||||
pcs = &mpcs;
|
||||
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];
|
||||
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
|
||||
int16_t isOK = 0;
|
||||
uint8_t par_enc[1];
|
||||
uint8_t par_enc[1] = {0x00};
|
||||
uint8_t nt_par_enc = 0;
|
||||
uint8_t buf[USB_CMD_DATA_SIZE];
|
||||
uint32_t timeout;
|
||||
uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
|
||||
uint32_t timeout = 0;
|
||||
|
||||
uint8_t blockNo = arg0 & 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
|
||||
uint16_t rtr, i, j, len;
|
||||
uint16_t davg;
|
||||
uint16_t davg = 0;
|
||||
static uint16_t dmin, dmax;
|
||||
uint8_t uid[10];
|
||||
uint8_t uid[10] = {0x00};
|
||||
uint32_t cuid, nt1, nt2, nttmp, nttest, ks1;
|
||||
uint8_t par[1];
|
||||
uint32_t target_nt[2], target_ks[2];
|
||||
uint8_t par[1] = {0x00};
|
||||
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;
|
||||
struct Crypto1State mpcs = {0, 0};
|
||||
struct Crypto1State *pcs;
|
||||
|
|
@ -967,8 +967,8 @@ void MifareChkKeys(uint16_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
|
|||
// variables
|
||||
int i;
|
||||
byte_t isOK = 0;
|
||||
uint8_t uid[10];
|
||||
uint32_t cuid;
|
||||
uint8_t uid[10] = {0x00};
|
||||
uint32_t cuid = 0;
|
||||
struct Crypto1State mpcs = {0, 0};
|
||||
struct Crypto1State *pcs;
|
||||
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){
|
||||
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)
|
||||
|
||||
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 keyType = arg1;
|
||||
uint64_t ui64Key = 0;
|
||||
uint32_t cuid;
|
||||
uint32_t cuid = 0;
|
||||
struct Crypto1State mpcs = {0, 0};
|
||||
struct Crypto1State *pcs;
|
||||
pcs = &mpcs;
|
||||
|
||||
// variables
|
||||
byte_t dataoutbuf[16];
|
||||
byte_t dataoutbuf2[16];
|
||||
uint8_t uid[10];
|
||||
byte_t dataoutbuf[16] = {0x00};
|
||||
byte_t dataoutbuf2[16] = {0x00};
|
||||
uint8_t uid[10] = {0x00};
|
||||
|
||||
LED_A_ON();
|
||||
LED_B_OFF();
|
||||
|
|
@ -1111,7 +1111,7 @@ void MifareECardLoad(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
|
|||
isOK = false;
|
||||
if (MF_DBGLEVEL >= 1) Dbprintf("Error reading sector %2d block %2d", sectorNo, blockNo);
|
||||
break;
|
||||
};
|
||||
}
|
||||
if (isOK) {
|
||||
if (blockNo < NumBlocksPerSector(sectorNo) - 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 (MF_DBGLEVEL >= 1) Dbprintf("Halt error");
|
||||
};
|
||||
if(mifare_classic_halt(pcs, cuid))
|
||||
if (MF_DBGLEVEL >= 1)
|
||||
Dbprintf("Halt error");
|
||||
|
||||
// ----------------------------- crypto1 destroy
|
||||
crypto1_destroy(pcs);
|
||||
|
|
@ -1169,7 +1169,7 @@ void MifareCSetBlock(uint32_t arg0, uint32_t arg1, uint8_t *datain){
|
|||
// variables
|
||||
uint8_t uid[10] = {0x00};
|
||||
uint8_t data[18] = {0x00};
|
||||
uint32_t cuid;
|
||||
uint32_t cuid = 0;
|
||||
|
||||
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];
|
||||
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];
|
||||
|
|
@ -1310,8 +1310,8 @@ void MifareCIdent(){
|
|||
|
||||
// variables
|
||||
bool isOK = true;
|
||||
uint8_t receivedAnswer[1];
|
||||
uint8_t receivedAnswerPar[1];
|
||||
uint8_t receivedAnswer[1] = {0x00};
|
||||
uint8_t receivedAnswerPar[1] = {0x00};
|
||||
|
||||
ReaderTransmitBitsPar(wupC1,7,0, NULL);
|
||||
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};
|
||||
uint8_t uid[10] = {0x00};
|
||||
uint32_t cuid = 0x00;
|
||||
uint32_t cuid = 0;
|
||||
|
||||
iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN);
|
||||
clear_trace();
|
||||
|
|
|
|||
|
|
@ -32,10 +32,10 @@ void mf_crypto1_decrypt(struct Crypto1State *pcs, uint8_t *data, int len){
|
|||
for (i = 0; i < len; i++)
|
||||
data[i] = crypto1_byte(pcs, 0x00, 0) ^ data[i];
|
||||
} else {
|
||||
bt = 0;
|
||||
for (i = 0; i < 4; i++)
|
||||
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data[0], i)) << i;
|
||||
|
||||
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data[0], 0)) << 0;
|
||||
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data[0], 1)) << 1;
|
||||
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;
|
||||
}
|
||||
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++) {
|
||||
bt = 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] |= (((filter(pcs->odd) ^ oddparity8(bt)) & 0x01)<<(7-(i&0x0007)));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
uint8_t mf_crypto1_encrypt4bit(struct Crypto1State *pcs, uint8_t data) {
|
||||
uint8_t bt = 0;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 4; i++)
|
||||
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data, i)) << i;
|
||||
|
||||
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data, 0)) << 0;
|
||||
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data, 1)) << 1;
|
||||
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data, 2)) << 2;
|
||||
bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data, 3)) << 3;
|
||||
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 (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("%02X Cmd failed. Card timeout.", cmd);
|
||||
len = ReaderReceive(answer,answer_parity);
|
||||
//return 0;
|
||||
}
|
||||
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
|
||||
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;
|
||||
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[1] = data;
|
||||
AppendCrc14443a(dcmd, 2);
|
||||
|
|
@ -97,8 +95,7 @@ int mifare_sendcmd_short(struct Crypto1State *pcs, uint8_t crypted, uint8_t cmd,
|
|||
|
||||
if (crypted) {
|
||||
par[0] = 0;
|
||||
for (pos = 0; pos < 4; pos++)
|
||||
{
|
||||
for (pos = 0; pos < 4; pos++) {
|
||||
ecmd[pos] = crypto1_byte(pcs, 0x00, 0) ^ dcmd[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 (len == 1) {
|
||||
res = 0;
|
||||
for (pos = 0; pos < 4; pos++)
|
||||
res |= (crypto1_bit(pcs, 0, 0) ^ BIT(answer[0], pos)) << pos;
|
||||
|
||||
res |= (crypto1_bit(pcs, 0, 0) ^ BIT(answer[0], 0)) << 0;
|
||||
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;
|
||||
|
||||
} else {
|
||||
for (pos = 0; pos < len; 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
|
||||
int len;
|
||||
uint32_t pos;
|
||||
uint8_t tmp4[4];
|
||||
uint8_t tmp4[4] = {0x00};
|
||||
uint8_t par[1] = {0x00};
|
||||
|
||||
// "random" reader nonce:
|
||||
|
|
@ -232,10 +228,10 @@ int mifare_classic_readblock(struct Crypto1State *pcs, uint32_t uid, uint8_t blo
|
|||
{
|
||||
// variables
|
||||
int len;
|
||||
uint8_t bt[2];
|
||||
uint8_t bt[2] = {0x00};
|
||||
|
||||
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];
|
||||
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];
|
||||
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
|
||||
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE] = {0x00};
|
||||
|
||||
// command MIFARE_CLASSIC_READBLOCK
|
||||
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){
|
||||
|
||||
uint16_t len;
|
||||
uint8_t resp[4];
|
||||
uint8_t respPar[1];
|
||||
uint8_t resp[4] = {0x00};
|
||||
uint8_t respPar[1] = {0x00};
|
||||
uint8_t key[4] = {0x00};
|
||||
memcpy(key, keybytes, 4);
|
||||
|
||||
if (MF_DBGLEVEL >= MF_DBG_EXTENDED)
|
||||
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);
|
||||
|
||||
if (len != 4) {
|
||||
|
|
@ -374,10 +371,9 @@ int mifare_ultra_readblock(uint8_t blockNo, uint8_t *blockData)
|
|||
{
|
||||
uint16_t len;
|
||||
uint8_t bt[2];
|
||||
uint8_t receivedAnswer[MAX_FRAME_SIZE];
|
||||
uint8_t receivedAnswerPar[MAX_PARITY_SIZE];
|
||||
uint8_t receivedAnswer[MAX_FRAME_SIZE] = {0x00};
|
||||
uint8_t receivedAnswerPar[MAX_PARITY_SIZE] = {0x00};
|
||||
|
||||
|
||||
len = mifare_sendcmd_short(NULL, 1, 0x30, blockNo, receivedAnswer, receivedAnswerPar, NULL);
|
||||
if (len == 1) {
|
||||
if (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("Cmd Error: %02x", receivedAnswer[0]);
|
||||
|
|
@ -408,8 +404,8 @@ int mifare_classic_writeblock(struct Crypto1State *pcs, uint32_t uid, uint8_t bl
|
|||
byte_t res = 0;
|
||||
|
||||
uint8_t d_block[18], d_block_enc[18];
|
||||
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];
|
||||
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];
|
||||
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
|
||||
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE] = {0x00};
|
||||
|
||||
// command MIFARE_CLASSIC_WRITEBLOCK
|
||||
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;
|
||||
uint8_t d_block[5] = {0x00};
|
||||
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];
|
||||
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];
|
||||
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
|
||||
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE] = {0x00};
|
||||
|
||||
// command MIFARE_CLASSIC_WRITEBLOCK
|
||||
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) {
|
||||
uint16_t len;
|
||||
uint8_t receivedAnswer[4];
|
||||
uint8_t receivedAnswerPar[4];
|
||||
uint8_t receivedAnswer[4] = {0x00};
|
||||
uint8_t receivedAnswerPar[4] = {0x00};
|
||||
|
||||
len = mifare_sendcmd_short(pcs, pcs == NULL ? false:true, 0x50, 0x00, receivedAnswer, receivedAnswerPar, NULL);
|
||||
if (len != 0) {
|
||||
|
|
@ -519,8 +515,8 @@ int mifare_classic_halt(struct Crypto1State *pcs, uint32_t uid) {
|
|||
int mifare_ultra_halt()
|
||||
{
|
||||
uint16_t len;
|
||||
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];
|
||||
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];
|
||||
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
|
||||
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE] = {0x00};
|
||||
|
||||
len = mifare_sendcmd_short(NULL, true, 0x50, 0x00, receivedAnswer, receivedAnswerPar, NULL);
|
||||
if (len != 0) {
|
||||
|
|
@ -538,8 +534,7 @@ uint8_t NumBlocksPerSector(uint8_t sectorNo)
|
|||
{
|
||||
if (sectorNo < 32)
|
||||
return 4;
|
||||
else
|
||||
return 16;
|
||||
return 16;
|
||||
}
|
||||
|
||||
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* data = emCARD + blockNum * 16;
|
||||
|
||||
if (emlCheckValBl(blockNum)) {
|
||||
if (emlCheckValBl(blockNum))
|
||||
return 1;
|
||||
}
|
||||
|
||||
memcpy(blReg, data, 4);
|
||||
*blBlock = data[12];
|
||||
|
|
@ -618,7 +612,7 @@ int emlSetValBl(uint32_t blReg, uint8_t blBlock, int blockNum) {
|
|||
}
|
||||
|
||||
uint64_t emlGetKey(int sectorNum, int keyType) {
|
||||
uint8_t key[6];
|
||||
uint8_t key[6] = {0x00};
|
||||
uint8_t* emCARD = BigBuf_get_EM_addr();
|
||||
|
||||
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;
|
||||
// load key, keynumber
|
||||
uint8_t data[2]={0x0a, 0x00};
|
||||
uint8_t receivedAnswer[MAX_FRAME_SIZE];
|
||||
uint8_t receivedAnswerPar[MAX_PARITY_SIZE];
|
||||
uint8_t receivedAnswer[MAX_FRAME_SIZE] = {0x00};
|
||||
uint8_t receivedAnswerPar[MAX_PARITY_SIZE] = {0x00};
|
||||
|
||||
len = mifare_sendcmd_special(NULL, 1, 0x02, data, receivedAnswer,receivedAnswerPar,NULL);
|
||||
if (len == 1) {
|
||||
|
|
@ -715,8 +709,8 @@ int mifare_desfire_des_auth2(uint32_t uid, uint8_t *key, uint8_t *blockData){
|
|||
data[0] = 0xAF;
|
||||
memcpy(data+1,key,16);
|
||||
|
||||
uint8_t receivedAnswer[MAX_FRAME_SIZE];
|
||||
uint8_t receivedAnswerPar[MAX_PARITY_SIZE];
|
||||
uint8_t receivedAnswer[MAX_FRAME_SIZE] = {0x00};
|
||||
uint8_t receivedAnswerPar[MAX_PARITY_SIZE] = {0x00};
|
||||
|
||||
len = mifare_sendcmd_special2(NULL, 1, 0x03, data, receivedAnswer, receivedAnswerPar ,NULL);
|
||||
|
||||
|
|
|
|||
|
|
@ -182,7 +182,7 @@ int CmdLegicLoad(const char *Cmd) {
|
|||
|
||||
char cmdp = param_getchar(Cmd, 0);
|
||||
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(" sample: hf legic load filename");
|
||||
return 0;
|
||||
|
|
@ -209,17 +209,16 @@ int CmdLegicLoad(const char *Cmd) {
|
|||
int res = sscanf(line, "%x %x %x %x %x %x %x %x",
|
||||
&data[0], &data[1], &data[2], &data[3],
|
||||
&data[4], &data[5], &data[6], &data[7]);
|
||||
|
||||
if(res != 8) {
|
||||
PrintAndLog("Error: could not read samples");
|
||||
fclose(f);
|
||||
return -1;
|
||||
}
|
||||
UsbCommand c = { CMD_DOWNLOADED_SIM_SAMPLES_125K, {offset, 0, 0}};
|
||||
|
||||
for( j = 0; j < 8; j++) {
|
||||
c.d.asBytes[j] = data[j];
|
||||
}
|
||||
|
||||
UsbCommand c = { CMD_DOWNLOADED_SIM_SAMPLES_125K, {offset, 0, 0}};
|
||||
memcpy(c.d.asBytes, data, 8);
|
||||
clearCommandBuffer();
|
||||
SendCommand(&c);
|
||||
WaitForResponse(CMD_ACK, NULL);
|
||||
offset += 8;
|
||||
|
|
@ -240,9 +239,8 @@ int CmdLegicSave(const char *Cmd) {
|
|||
|
||||
/* If no length given save entire legic read buffer */
|
||||
/* round up to nearest 8 bytes so the saved data can be used with legicload */
|
||||
if (requested == 0) {
|
||||
if (requested == 0)
|
||||
requested = 1024;
|
||||
}
|
||||
|
||||
if (requested % 8 != 0) {
|
||||
int remainder = requested % 8;
|
||||
|
|
|
|||
|
|
@ -35,21 +35,22 @@ volatile static bool txcmd_pending = false;
|
|||
|
||||
void SendCommand(UsbCommand *c) {
|
||||
#if 0
|
||||
printf("Sending %d bytes\n", sizeof(UsbCommand));
|
||||
printf("Sending %d bytes\n", sizeof(UsbCommand));
|
||||
#endif
|
||||
|
||||
if (offline) {
|
||||
PrintAndLog("Sending bytes to proxmark failed - offline");
|
||||
return;
|
||||
}
|
||||
/**
|
||||
PrintAndLog("Sending bytes to proxmark failed - offline");
|
||||
return;
|
||||
}
|
||||
/**
|
||||
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.
|
||||
Not good.../holiman
|
||||
**/
|
||||
while(txcmd_pending);
|
||||
txcmd = *c;
|
||||
txcmd_pending = true;
|
||||
while(txcmd_pending);
|
||||
|
||||
txcmd = *c;
|
||||
txcmd_pending = true;
|
||||
}
|
||||
|
||||
struct receiver_arg {
|
||||
|
|
@ -65,101 +66,105 @@ byte_t rx[0x1000000];
|
|||
byte_t* prx = rx;
|
||||
|
||||
static void *uart_receiver(void *targ) {
|
||||
struct receiver_arg *arg = (struct receiver_arg*)targ;
|
||||
size_t rxlen;
|
||||
size_t cmd_count;
|
||||
struct receiver_arg *arg = (struct receiver_arg*)targ;
|
||||
size_t rxlen;
|
||||
size_t cmd_count;
|
||||
|
||||
while (arg->run) {
|
||||
|
||||
rxlen = sizeof(UsbCommand);
|
||||
|
||||
while (arg->run) {
|
||||
rxlen = sizeof(UsbCommand);
|
||||
if (uart_receive(sp, prx, &rxlen)) {
|
||||
prx += rxlen;
|
||||
if (((prx-rx) % sizeof(UsbCommand)) != 0) {
|
||||
continue;
|
||||
}
|
||||
cmd_count = (prx-rx) / sizeof(UsbCommand);
|
||||
prx += rxlen;
|
||||
if (((prx-rx) % sizeof(UsbCommand)) != 0)
|
||||
continue;
|
||||
|
||||
cmd_count = (prx-rx) / sizeof(UsbCommand);
|
||||
|
||||
for (size_t i = 0; i < cmd_count; i++) {
|
||||
UsbCommandReceived((UsbCommand*)(rx+(i*sizeof(UsbCommand))));
|
||||
}
|
||||
}
|
||||
prx = rx;
|
||||
for (size_t i = 0; i < cmd_count; i++)
|
||||
UsbCommandReceived((UsbCommand*)( rx + ( i * sizeof(UsbCommand))));
|
||||
|
||||
if(txcmd_pending) {
|
||||
if (!uart_send(sp, (byte_t*) &txcmd, sizeof(UsbCommand))) {
|
||||
PrintAndLog("Sending bytes to proxmark failed");
|
||||
}
|
||||
txcmd_pending = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
prx = rx;
|
||||
|
||||
pthread_exit(NULL);
|
||||
return NULL;
|
||||
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) {
|
||||
struct main_loop_arg *arg = (struct main_loop_arg*)targ;
|
||||
struct receiver_arg rarg;
|
||||
char *cmd = NULL;
|
||||
pthread_t reader_thread;
|
||||
struct main_loop_arg *arg = (struct main_loop_arg*)targ;
|
||||
struct receiver_arg rarg;
|
||||
char *cmd = NULL;
|
||||
pthread_t reader_thread;
|
||||
|
||||
if (arg->usb_present == 1) {
|
||||
if (arg->usb_present == 1) {
|
||||
rarg.run = 1;
|
||||
pthread_create(&reader_thread, NULL, &uart_receiver, &rarg);
|
||||
pthread_create(&reader_thread, NULL, &uart_receiver, &rarg);
|
||||
// cache Version information now:
|
||||
CmdVersion(NULL);
|
||||
}
|
||||
}
|
||||
|
||||
FILE *script_file = NULL;
|
||||
char script_cmd_buf[256]; // iceman, needs lua script the same file_path_buffer as the rest
|
||||
FILE *script_file = NULL;
|
||||
char script_cmd_buf[256] = {0x00}; // iceman, needs lua script the same file_path_buffer as the rest
|
||||
|
||||
if (arg->script_cmds_file) {
|
||||
script_file = fopen(arg->script_cmds_file, "r");
|
||||
if (script_file) {
|
||||
printf("using 'scripting' commands file %s\n", arg->script_cmds_file);
|
||||
}
|
||||
}
|
||||
script_file = fopen(arg->script_cmds_file, "r");
|
||||
|
||||
if (script_file)
|
||||
printf("using 'scripting' commands file %s\n", arg->script_cmds_file);
|
||||
}
|
||||
|
||||
read_history(".history");
|
||||
|
||||
while(1) {
|
||||
|
||||
// If there is a script file
|
||||
if (script_file)
|
||||
{
|
||||
// If there is a script file
|
||||
if (script_file)
|
||||
{
|
||||
if (!fgets(script_cmd_buf, sizeof(script_cmd_buf), script_file)) {
|
||||
fclose(script_file);
|
||||
script_file = NULL;
|
||||
fclose(script_file);
|
||||
script_file = NULL;
|
||||
} else {
|
||||
char *nl;
|
||||
nl = strrchr(script_cmd_buf, '\r');
|
||||
if (nl) *nl = '\0';
|
||||
char *nl;
|
||||
nl = strrchr(script_cmd_buf, '\r');
|
||||
if (nl)
|
||||
*nl = '\0';
|
||||
|
||||
nl = strrchr(script_cmd_buf, '\n');
|
||||
if (nl) *nl = '\0';
|
||||
nl = strrchr(script_cmd_buf, '\n');
|
||||
|
||||
if (nl)
|
||||
*nl = '\0';
|
||||
|
||||
if ((cmd = (char*) malloc(strlen(script_cmd_buf) + 1)) != NULL) {
|
||||
memset(cmd, 0, strlen(script_cmd_buf));
|
||||
strcpy(cmd, script_cmd_buf);
|
||||
printf("%s\n", cmd);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!script_file) {
|
||||
cmd = readline(PROXPROMPT);
|
||||
memset(cmd, 0, strlen(script_cmd_buf));
|
||||
strcpy(cmd, script_cmd_buf);
|
||||
printf("%s\n", cmd);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
cmd = readline(PROXPROMPT);
|
||||
}
|
||||
|
||||
if (cmd) {
|
||||
|
||||
while(cmd[strlen(cmd) - 1] == ' ')
|
||||
cmd[strlen(cmd) - 1] = 0x00;
|
||||
|
||||
cmd[strlen(cmd) - 1] = 0x00;
|
||||
|
||||
if (cmd[0] != 0x00) {
|
||||
int ret = CommandReceived(cmd);
|
||||
add_history(cmd);
|
||||
if (ret == 99) { // exit or quit
|
||||
|
||||
// exit or quit
|
||||
if (ret == 99)
|
||||
break;
|
||||
}
|
||||
}
|
||||
free(cmd);
|
||||
} else {
|
||||
|
|
@ -170,29 +175,29 @@ static void *main_loop(void *targ) {
|
|||
|
||||
write_history(".history");
|
||||
|
||||
if (arg->usb_present == 1) {
|
||||
rarg.run = 0;
|
||||
pthread_join(reader_thread, NULL);
|
||||
}
|
||||
if (arg->usb_present == 1) {
|
||||
rarg.run = 0;
|
||||
pthread_join(reader_thread, NULL);
|
||||
}
|
||||
|
||||
if (script_file) {
|
||||
fclose(script_file);
|
||||
script_file = NULL;
|
||||
}
|
||||
fclose(script_file);
|
||||
script_file = NULL;
|
||||
}
|
||||
|
||||
ExitGraphics();
|
||||
pthread_exit(NULL);
|
||||
return NULL;
|
||||
ExitGraphics();
|
||||
pthread_exit(NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void dumpAllHelp(int markdown)
|
||||
{
|
||||
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("Check column \"offline\" for their availability.\n");
|
||||
printf("\n");
|
||||
command_t *cmds = getTopLevelCommandTable();
|
||||
dumpCommandsRecursive(cmds, markdown);
|
||||
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("Check column \"offline\" for their availability.\n");
|
||||
printf("\n");
|
||||
command_t *cmds = getTopLevelCommandTable();
|
||||
dumpCommandsRecursive(cmds, markdown);
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
|
|
@ -222,6 +227,7 @@ int main(int argc, char* argv[]) {
|
|||
.usb_present = 0,
|
||||
.script_cmds_file = NULL
|
||||
};
|
||||
|
||||
pthread_t main_loop_threat;
|
||||
|
||||
|
||||
|
|
@ -250,8 +256,9 @@ int main(int argc, char* argv[]) {
|
|||
printf("Output will be flushed after every print.\n");
|
||||
flushAfterWrite = 1;
|
||||
}
|
||||
else
|
||||
marg.script_cmds_file = argv[2];
|
||||
else {
|
||||
marg.script_cmds_file = argv[2];
|
||||
}
|
||||
}
|
||||
|
||||
// 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);
|
||||
|
||||
// Clean up the port
|
||||
if (offline == 0) {
|
||||
uart_close(sp);
|
||||
}
|
||||
if (offline == 0)
|
||||
uart_close(sp);
|
||||
|
||||
// clean up mutex
|
||||
pthread_mutex_destroy(&print_lock);
|
||||
|
|
|
|||
Loading…
Reference in a new issue