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

chf: hf mf eget\nhf mf eset\nhf mf eclr - uses NG

Browse source
This commit is contained in:
iceman1001 2019-05-27 07:46:27 -04:00
commit 53f2058c7a
7 changed files with 106 additions and 41 deletions
Download patch file Download diff file Expand all files Collapse all files

29
armsrc/appmain.c
View file

@ -771,7 +771,7 @@ static void PacketReceived(PacketCommandNG *packet) {
}
case CMD_LF_SNIFF_RAW_ADC_SAMPLES: {
uint32_t bits = SniffLF();
reply_old(CMD_ACK, bits, 0, 0, 0, 0);
reply_mix(CMD_ACK, bits, 0, 0, 0, 0);
break;
}
case CMD_HID_DEMOD_FSK: {
@ -1091,22 +1091,37 @@ static void PacketReceived(PacketCommandNG *packet) {
} PACKED;
struct p* payload = (struct p*) packet->data.asBytes;
Mifare1ksim(payload->flags, payload->exitAfter, payload->uid);
}
break;
}
// emulator
case CMD_MIFARE_SET_DBGMODE:
MifareSetDbgLvl(packet->data.asBytes[0]);
reply_ng(CMD_MIFARE_SET_DBGMODE, PM3_SUCCESS, NULL, 0);
break;
case CMD_MIFARE_EML_MEMCLR:
MifareEMemClr();
reply_ng(CMD_MIFARE_EML_MEMCLR, PM3_SUCCESS, NULL, 0);
break;
case CMD_MIFARE_EML_MEMSET:
MifareEMemSet(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes);
case CMD_MIFARE_EML_MEMSET: {
struct p {
uint8_t blockno;
uint8_t blockcnt;
uint8_t blockwidth;
uint8_t data[];
} PACKED;
struct p* payload = (struct p*) packet->data.asBytes;
MifareEMemSet(payload->blockno, payload->blockcnt, payload->blockwidth, payload->data);
break;
case CMD_MIFARE_EML_MEMGET:
MifareEMemGet(packet->oldarg[0], packet->oldarg[1]);
}
case CMD_MIFARE_EML_MEMGET: {
struct p {
uint8_t blockno;
uint8_t blockcnt;
} PACKED;
struct p* payload = (struct p*) packet->data.asBytes;
MifareEMemGet(payload->blockno, payload->blockcnt);
break;
}
case CMD_MIFARE_EML_CARDLOAD:
MifareECardLoad(packet->oldarg[0], packet->oldarg[1]);
break;

7
armsrc/apps.h
View file

@ -158,13 +158,16 @@ void MifareAcquireNonces(uint32_t arg0, uint32_t flags);
void MifareChkKeys(uint8_t *datain);
void MifareChkKeys_fast(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain);
void MifareSetDbgLvl(uint16_t arg0);
void MifareEMemClr(void);
void MifareEMemSet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain);
void MifareEMemGet(uint32_t arg0, uint32_t arg1);
void MifareEMemSet(uint8_t blockno, uint8_t blockcnt, uint8_t blockwidth, uint8_t *datain);
void MifareEMemGet(uint8_t blockno, uint8_t blockcnt);
int MifareECardLoad(uint32_t arg0, uint32_t arg1);
void MifareCSetBlock(uint32_t arg0, uint32_t arg1, uint8_t *datain); // Work with "magic Chinese" card
void MifareCGetBlock(uint32_t arg0, uint32_t arg1, uint8_t *datain);
void MifareCIdent(); // is "magic chinese" card?
void MifareSetMod(uint8_t *datain);
void MifareUSetPwd(uint8_t arg0, uint8_t *datain);
void OnSuccessMagic();

27
armsrc/mifarecmd.c
View file

@ -1630,20 +1630,33 @@ void MifareEMemClr(void) {
emlClearMem();
}
void MifareEMemSet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain) {
void MifareEMemSet(uint8_t blockno, uint8_t blockcnt, uint8_t blockwidth, uint8_t *datain) {
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
if (arg2 == 0) arg2 = 16; // backwards compat... default bytewidth
emlSetMem_xt(datain, arg0, arg1, arg2); // data, block num, blocks count, block byte width
if (blockwidth == 0)
blockwidth = 16; // backwards compat... default bytewidth
emlSetMem_xt(datain, blockno, blockcnt, blockwidth); // data, block num, blocks count, block byte width
}
void MifareEMemGet(uint32_t arg0, uint32_t arg1) {
void MifareEMemGet(uint8_t blockno, uint8_t blockcnt) {
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
uint8_t buf[PM3_CMD_DATA_SIZE] = {0x00};
emlGetMem(buf, arg0, arg1); // data, block num, blocks count (max 4)
//
size_t size = blockcnt * 16;
if ( size > PM3_CMD_DATA_SIZE) {
reply_ng(CMD_MIFARE_EML_MEMGET, PM3_EMALLOC, NULL, 0);
return;
}
uint8_t *buf = BigBuf_malloc(size);
emlGetMem(buf, blockno, blockcnt); // data, block num, blocks count (max 4)
LED_B_ON();
reply_old(CMD_ACK, arg0, arg1, 0, buf, PM3_CMD_DATA_SIZE);
reply_ng(CMD_MIFARE_EML_MEMGET, PM3_SUCCESS, buf, size);
LED_B_OFF();
BigBuf_free_keep_EM();
}
//-----------------------------------------------------------------------------

5
armsrc/mifareutil.c
View file

@ -1,4 +1,3 @@
//-----------------------------------------------------------------------------
// Merlok, May 2011, 2012
// Many authors, whom made it possible
//
@ -530,9 +529,9 @@ void emlGetMem(uint8_t *data, int blockNum, int blocksCount) {
memcpy(data, emCARD + blockNum * 16, blocksCount * 16);
}
void emlGetMemBt(uint8_t *data, int bytePtr, int byteCount) {
void emlGetMemBt(uint8_t *data, int offset, int byteCount) {
uint8_t *emCARD = BigBuf_get_EM_addr();
memcpy(data, emCARD + bytePtr, byteCount);
memcpy(data, emCARD + offset, byteCount);
}
int emlCheckValBl(int blockNum) {

2
armsrc/mifareutil.h
View file

@ -108,7 +108,7 @@ void emlClearMem(void);
void emlSetMem(uint8_t *data, int blockNum, int blocksCount);
void emlSetMem_xt(uint8_t *data, int blockNum, int blocksCount, int blockBtWidth);
void emlGetMem(uint8_t *data, int blockNum, int blocksCount);
void emlGetMemBt(uint8_t *data, int bytePtr, int byteCount);
void emlGetMemBt(uint8_t *data, int offset, int byteCount);
uint64_t emlGetKey(int sectorNum, int keyType);
int emlGetValBl(uint32_t *blReg, uint8_t *blBlock, int blockNum);
int emlSetValBl(uint32_t blReg, uint8_t blBlock, int blockNum);

25
client/cmdhfmf.c
View file

@ -2514,21 +2514,17 @@ void printKeyTable(uint8_t sectorscnt, sector_t *e_sector) {
// EMULATOR COMMANDS
static int CmdHF14AMfEGet(const char *Cmd) {
uint8_t blockNo = 0;
uint8_t data[16] = {0x00};
char c = tolower(param_getchar(Cmd, 0));
if (strlen(Cmd) < 1 || c == 'h') return usage_hf14_eget();
blockNo = param_get8(Cmd, 0);
uint8_t data[16] = {0x00};
uint8_t blockNo = param_get8(Cmd, 0);
PrintAndLogEx(NORMAL, "");
if (!mfEmlGetMem(data, blockNo, 1)) {
if (mfEmlGetMem(data, blockNo, 1) == PM3_SUCCESS) {
PrintAndLogEx(NORMAL, "data[%3d]:%s", blockNo, sprint_hex(data, sizeof(data)));
} else {
PrintAndLogEx(WARNING, "Command execute timeout");
}
return 0;
return PM3_SUCCESS;
}
static int CmdHF14AMfEClear(const char *Cmd) {
@ -2537,23 +2533,22 @@ static int CmdHF14AMfEClear(const char *Cmd) {
clearCommandBuffer();
SendCommandNG(CMD_MIFARE_EML_MEMCLR, NULL, 0);
return 0;
return PM3_SUCCESS;
}
static int CmdHF14AMfESet(const char *Cmd) {
char c = tolower(param_getchar(Cmd, 0));
uint8_t memBlock[16];
uint8_t blockNo = 0;
memset(memBlock, 0x00, sizeof(memBlock));
if (strlen(Cmd) < 3 || c == 'h')
return usage_hf14_eset();
blockNo = param_get8(Cmd, 0);
uint8_t memBlock[16];
memset(memBlock, 0x00, sizeof(memBlock));
uint8_t blockNo = param_get8(Cmd, 0);
if (param_gethex(Cmd, 1, memBlock, 32)) {
PrintAndLogEx(WARNING, "block data must include 32 HEX symbols");
return 1;
return PM3_ESOFT;
}
// 1 - blocks count

50
client/mifare/mifarehost.c
View file

@ -445,12 +445,33 @@ int mfReadSector(uint8_t sectorNo, uint8_t keyType, uint8_t *key, uint8_t *data)
// EMULATOR
int mfEmlGetMem(uint8_t *data, int blockNum, int blocksCount) {
size_t size = blocksCount * 16;
if (size > PM3_CMD_DATA_SIZE) {
return PM3_ESOFT;
}
struct {
uint8_t blockno;
uint8_t blockcnt;
} PACKED payload;
payload.blockno = blockNum;
payload.blockcnt = blocksCount;
clearCommandBuffer();
SendCommandMIX(CMD_MIFARE_EML_MEMGET, blockNum, blocksCount, 0, NULL, 0);
SendCommandNG(CMD_MIFARE_EML_MEMGET, (uint8_t*)&payload, sizeof(payload));
PacketResponseNG resp;
if (!WaitForResponseTimeout(CMD_ACK, &resp, 1500)) return PM3_ETIMEOUT;
memcpy(data, resp.data.asBytes, blocksCount * 16);
return PM3_SUCCESS;
if (WaitForResponseTimeout(CMD_MIFARE_EML_MEMGET, &resp, 1500) == 0) {
PrintAndLogEx(WARNING, "Command execute timeout");
return PM3_ETIMEOUT;
}
if (resp.status == PM3_SUCCESS)
memcpy(data, resp.data.asBytes, size);
return resp.status;
}
int mfEmlSetMem(uint8_t *data, int blockNum, int blocksCount) {
@ -458,8 +479,27 @@ int mfEmlSetMem(uint8_t *data, int blockNum, int blocksCount) {
}
int mfEmlSetMem_xt(uint8_t *data, int blockNum, int blocksCount, int blockBtWidth) {
struct p {
uint8_t blockno;
uint8_t blockcnt;
uint8_t blockwidth;
uint8_t data[];
} PACKED;
size_t size = blocksCount * blockBtWidth;
if (size > (PM3_CMD_DATA_SIZE - sizeof(struct p))) {
return PM3_ESOFT;
}
struct p *payload = calloc(1, sizeof(struct p) + size);
payload->blockno = blockNum;
payload->blockcnt = blocksCount;
payload->blockwidth = blockBtWidth;
memcpy(payload->data, data, size);
clearCommandBuffer();
SendCommandOLD(CMD_MIFARE_EML_MEMSET, blockNum, blocksCount, blockBtWidth, data, blocksCount * blockBtWidth);
SendCommandNG(CMD_MIFARE_EML_MEMSET, (uint8_t*)payload, sizeof(payload) + size );
return PM3_SUCCESS;
}