mirror of
https://github.com/Proxmark/proxmark3.git
synced 2025-07-16 02:03:00 -07:00
Ndef and MAD (#801)
* move mifare stuff to separate folder * add mad and ndef
This commit is contained in:
Oleg Moiseenko
pwpiwi
parent
3d057cfb91
commit
fdd9395d1a
27 changed files with 2843 additions and 1588 deletions
256
client/mifare/mad.c
Normal file
256
client/mifare/mad.c
Normal file
|
|
@ -0,0 +1,256 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2019 Merlok
|
||||
//
|
||||
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
|
||||
// at your option, any later version. See the LICENSE.txt file for the text of
|
||||
// the license.
|
||||
//-----------------------------------------------------------------------------
|
||||
// MIFARE Application Directory (MAD) functions
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "mad.h"
|
||||
#include "ui.h"
|
||||
#include "crc.h"
|
||||
#include "util.h"
|
||||
|
||||
// https://www.nxp.com/docs/en/application-note/AN10787.pdf
|
||||
static madAIDDescr madKnownAIDs[] = {
|
||||
{0x0000, "free"},
|
||||
{0x0001, "defect, e.g. access keys are destroyed or unknown"},
|
||||
{0x0002, "reserved"},
|
||||
{0x0003, "contains additional directory info"},
|
||||
{0x0004, "contains card holder information in ASCII format."},
|
||||
{0x0005, "not applicable (above memory size)"},
|
||||
|
||||
{0x03e1, "NDEF"},
|
||||
};
|
||||
|
||||
static madAIDDescr madKnownClusterCodes[] = {
|
||||
{0x00, "cluster: card administration"},
|
||||
{0x01, "cluster: miscellaneous applications"},
|
||||
{0x02, "cluster: miscellaneous applications"},
|
||||
{0x03, "cluster: miscellaneous applications"},
|
||||
{0x04, "cluster: miscellaneous applications"},
|
||||
{0x05, "cluster: miscellaneous applications"},
|
||||
{0x06, "cluster: miscellaneous applications"},
|
||||
{0x07, "cluster: miscellaneous applications"},
|
||||
{0x08, "cluster: airlines"},
|
||||
{0x09, "cluster: ferry traffic"},
|
||||
{0x10, "cluster: railway services"},
|
||||
{0x11, "cluster: miscellaneous applications"},
|
||||
{0x12, "cluster: transport"},
|
||||
{0x14, "cluster: security solutions"},
|
||||
{0x18, "cluster: city traffic"},
|
||||
{0x19, "cluster: Czech Railways"},
|
||||
{0x20, "cluster: bus services"},
|
||||
{0x21, "cluster: multi modal transit"},
|
||||
{0x28, "cluster: taxi"},
|
||||
{0x30, "cluster: road toll"},
|
||||
{0x31, "cluster: generic transport"},
|
||||
{0x38, "cluster: company services"},
|
||||
{0x40, "cluster: city card services"},
|
||||
{0x47, "cluster: access control & security"},
|
||||
{0x48, "cluster: access control & security"},
|
||||
{0x49, "cluster: VIGIK"},
|
||||
{0x4A, "cluster: Ministry of Defence, Netherlands"},
|
||||
{0x4B, "cluster: Bosch Telecom, Germany"},
|
||||
{0x4C, "cluster: European Union Institutions"},
|
||||
{0x50, "cluster: ski ticketing"},
|
||||
{0x51, "cluster: access control & security"},
|
||||
{0x52, "cluster: access control & security"},
|
||||
{0x53, "cluster: access control & security"},
|
||||
{0x54, "cluster: access control & security"},
|
||||
{0x55, "cluster: SOAA standard for offline access standard"},
|
||||
{0x56, "cluster: access control & security"},
|
||||
{0x58, "cluster: academic services"},
|
||||
{0x60, "cluster: food"},
|
||||
{0x68, "cluster: non-food trade"},
|
||||
{0x70, "cluster: hotel"},
|
||||
{0x71, "cluster: loyalty"},
|
||||
{0x75, "cluster: airport services"},
|
||||
{0x78, "cluster: car rental"},
|
||||
{0x79, "cluster: Dutch government"},
|
||||
{0x80, "cluster: administration services"},
|
||||
{0x88, "cluster: electronic purse"},
|
||||
{0x90, "cluster: television"},
|
||||
{0x91, "cluster: cruise ship"},
|
||||
{0x95, "cluster: IOPTA"},
|
||||
{0x97, "cluster: metering"},
|
||||
{0x98, "cluster: telephone"},
|
||||
{0xA0, "cluster: health services"},
|
||||
{0xA8, "cluster: warehouse"},
|
||||
{0xB0, "cluster: electronic trade"},
|
||||
{0xB8, "cluster: banking"},
|
||||
{0xC0, "cluster: entertainment & sports"},
|
||||
{0xC8, "cluster: car parking"},
|
||||
{0xC9, "cluster: fleet management"},
|
||||
{0xD0, "cluster: fuel, gasoline"},
|
||||
{0xD8, "cluster: info services"},
|
||||
{0xE0, "cluster: press"},
|
||||
{0xE1, "cluster: NFC Forum"},
|
||||
{0xE8, "cluster: computer"},
|
||||
{0xF0, "cluster: mail"},
|
||||
{0xF8, "cluster: miscellaneous applications"},
|
||||
};
|
||||
|
||||
static const char unknownAID[] = "";
|
||||
|
||||
static const char *GetAIDDescription(uint16_t AID) {
|
||||
for (int i = 0; i < ARRAYLEN(madKnownAIDs); i++)
|
||||
if (madKnownAIDs[i].AID == AID)
|
||||
return madKnownAIDs[i].Description;
|
||||
|
||||
for (int i = 0; i < ARRAYLEN(madKnownClusterCodes); i++)
|
||||
if (madKnownClusterCodes[i].AID == (AID >> 8)) // high byte - cluster code
|
||||
return madKnownClusterCodes[i].Description;
|
||||
|
||||
return unknownAID;
|
||||
}
|
||||
|
||||
int madCRCCheck(uint8_t *sector, bool verbose, int MADver) {
|
||||
if (MADver == 1) {
|
||||
uint8_t crc = CRC8Mad(§or[16 + 1], 15 + 16);
|
||||
if (crc != sector[16]) {
|
||||
PrintAndLogEx(WARNING, "Wrong MAD%d CRC. Calculated: 0x%02x, from card: 0x%02x", MADver, crc, sector[16]);
|
||||
return 3;
|
||||
};
|
||||
} else {
|
||||
uint8_t crc = CRC8Mad(§or[1], 15 + 16 + 16);
|
||||
if (crc != sector[0]) {
|
||||
PrintAndLogEx(WARNING, "Wrong MAD%d CRC. Calculated: 0x%02x, from card: 0x%02x", MADver, crc, sector[16]);
|
||||
return 3;
|
||||
};
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint16_t madGetAID(uint8_t *sector, int MADver, int sectorNo) {
|
||||
if (MADver == 1)
|
||||
return (sector[16 + 2 + (sectorNo - 1) * 2] << 8) + (sector[16 + 2 + (sectorNo - 1) * 2 + 1]);
|
||||
else
|
||||
return (sector[2 + (sectorNo - 1) * 2] << 8) + (sector[2 + (sectorNo - 1) * 2 + 1]);
|
||||
}
|
||||
|
||||
int MADCheck(uint8_t *sector0, uint8_t *sector10, bool verbose, bool *haveMAD2) {
|
||||
int res = 0;
|
||||
|
||||
if (!sector0)
|
||||
return 1;
|
||||
|
||||
uint8_t GPB = sector0[3 * 16 + 9];
|
||||
if (verbose)
|
||||
PrintAndLogEx(NORMAL, "GPB: 0x%02x", GPB);
|
||||
|
||||
// DA (MAD available)
|
||||
if (!(GPB & 0x80)) {
|
||||
PrintAndLogEx(ERR, "DA=0! MAD not available.");
|
||||
return 1;
|
||||
}
|
||||
|
||||
// MA (multi-application card)
|
||||
if (verbose) {
|
||||
if (GPB & 0x40)
|
||||
PrintAndLogEx(NORMAL, "Multi application card.");
|
||||
else
|
||||
PrintAndLogEx(NORMAL, "Single application card.");
|
||||
}
|
||||
|
||||
uint8_t MADVer = GPB & 0x03;
|
||||
if (verbose)
|
||||
PrintAndLogEx(NORMAL, "MAD version: %d", MADVer);
|
||||
|
||||
// MAD version
|
||||
if ((MADVer != 0x01) && (MADVer != 0x02)) {
|
||||
PrintAndLogEx(ERR, "Wrong MAD version: 0x%02x", MADVer);
|
||||
return 2;
|
||||
};
|
||||
|
||||
if (haveMAD2)
|
||||
*haveMAD2 = (MADVer == 2);
|
||||
|
||||
res = madCRCCheck(sector0, true, 1);
|
||||
|
||||
if (verbose && !res)
|
||||
PrintAndLogEx(NORMAL, "CRC8-MAD1 OK.");
|
||||
|
||||
if (MADVer == 2 && sector10) {
|
||||
int res2 = madCRCCheck(sector10, true, 2);
|
||||
if (!res)
|
||||
res = res2;
|
||||
|
||||
if (verbose & !res2)
|
||||
PrintAndLogEx(NORMAL, "CRC8-MAD2 OK.");
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
int MADDecode(uint8_t *sector0, uint8_t *sector10, uint16_t *mad, size_t *madlen) {
|
||||
*madlen = 0;
|
||||
bool haveMAD2 = false;
|
||||
MADCheck(sector0, sector10, false, &haveMAD2);
|
||||
|
||||
for (int i = 1; i < 16; i++) {
|
||||
mad[*madlen] = madGetAID(sector0, 1, i);
|
||||
(*madlen)++;
|
||||
}
|
||||
|
||||
if (haveMAD2) {
|
||||
// mad2 sector (0x10 == 16dec) here
|
||||
mad[*madlen] = 0x0005;
|
||||
(*madlen)++;
|
||||
|
||||
for (int i = 1; i < 24; i++) {
|
||||
mad[*madlen] = madGetAID(sector10, 2, i);
|
||||
(*madlen)++;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int MAD1DecodeAndPrint(uint8_t *sector, bool verbose, bool *haveMAD2) {
|
||||
|
||||
// check MAD1 only
|
||||
MADCheck(sector, NULL, verbose, haveMAD2);
|
||||
|
||||
// info byte
|
||||
uint8_t InfoByte = sector[16 + 1] & 0x3f;
|
||||
if (InfoByte) {
|
||||
PrintAndLogEx(NORMAL, "Card publisher sector: 0x%02x", InfoByte);
|
||||
} else {
|
||||
if (verbose)
|
||||
PrintAndLogEx(NORMAL, "Card publisher sector not present.");
|
||||
}
|
||||
if (InfoByte == 0x10 || InfoByte >= 0x28)
|
||||
PrintAndLogEx(WARNING, "Info byte error");
|
||||
|
||||
PrintAndLogEx(NORMAL, "00 MAD1");
|
||||
for (int i = 1; i < 16; i++) {
|
||||
uint16_t AID = madGetAID(sector, 1, i);
|
||||
PrintAndLogEx(NORMAL, "%02d [%04X] %s", i, AID, GetAIDDescription(AID));
|
||||
};
|
||||
|
||||
return 0;
|
||||
};
|
||||
|
||||
int MAD2DecodeAndPrint(uint8_t *sector, bool verbose) {
|
||||
PrintAndLogEx(NORMAL, "16 MAD2");
|
||||
|
||||
int res = madCRCCheck(sector, true, 2);
|
||||
|
||||
if (verbose && !res)
|
||||
PrintAndLogEx(NORMAL, "CRC8-MAD2 OK.");
|
||||
|
||||
uint8_t InfoByte = sector[1] & 0x3f;
|
||||
PrintAndLogEx(NORMAL, "MAD2 Card publisher sector: 0x%02x", InfoByte);
|
||||
|
||||
for (int i = 1; i < 8 + 8 + 7 + 1; i++) {
|
||||
uint16_t AID = madGetAID(sector, 2, i);
|
||||
PrintAndLogEx(NORMAL, "%02d [%04X] %s", i + 16, AID, GetAIDDescription(AID));
|
||||
};
|
||||
|
||||
return 0;
|
||||
};
|
||||
29
client/mifare/mad.h
Normal file
29
client/mifare/mad.h
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2019 Merlok
|
||||
//
|
||||
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
|
||||
// at your option, any later version. See the LICENSE.txt file for the text of
|
||||
// the license.
|
||||
//-----------------------------------------------------------------------------
|
||||
// MIFARE Application Directory (MAD) functions
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef _MAD_H_
|
||||
#define _MAD_H_
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
|
||||
typedef struct {
|
||||
uint16_t AID;
|
||||
const char *Description;
|
||||
} madAIDDescr;
|
||||
|
||||
extern int MADCheck(uint8_t *sector0, uint8_t *sector10, bool verbose, bool *haveMAD2);
|
||||
extern int MADDecode(uint8_t *sector0, uint8_t *sector10, uint16_t *mad, size_t *madlen);
|
||||
extern int MAD1DecodeAndPrint(uint8_t *sector, bool verbose, bool *haveMAD2);
|
||||
extern int MAD2DecodeAndPrint(uint8_t *sector, bool verbose);
|
||||
|
||||
|
||||
#endif // _MAD_H_
|
||||
122
client/mifare/mfkey.c
Normal file
122
client/mifare/mfkey.c
Normal file
|
|
@ -0,0 +1,122 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Merlok - June 2011
|
||||
// Roel - Dec 2009
|
||||
// Unknown author
|
||||
//
|
||||
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
|
||||
// at your option, any later version. See the LICENSE.txt file for the text of
|
||||
// the license.
|
||||
//-----------------------------------------------------------------------------
|
||||
// MIFARE Darkside hack
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "mfkey.h"
|
||||
|
||||
#include "mifare.h"
|
||||
#include "crapto1/crapto1.h"
|
||||
|
||||
|
||||
// recover key from 2 different reader responses on same tag challenge
|
||||
bool mfkey32(nonces_t data, uint64_t *outputkey) {
|
||||
struct Crypto1State *s,*t;
|
||||
uint64_t outkey = 0;
|
||||
uint64_t key = 0; // recovered key
|
||||
bool isSuccess = false;
|
||||
uint8_t counter = 0;
|
||||
|
||||
s = lfsr_recovery32(data.ar ^ prng_successor(data.nonce, 64), 0);
|
||||
|
||||
for(t = s; t->odd | t->even; ++t) {
|
||||
lfsr_rollback_word(t, 0, 0);
|
||||
lfsr_rollback_word(t, data.nr, 1);
|
||||
lfsr_rollback_word(t, data.cuid ^ data.nonce, 0);
|
||||
crypto1_get_lfsr(t, &key);
|
||||
crypto1_word(t, data.cuid ^ data.nonce, 0);
|
||||
crypto1_word(t, data.nr2, 1);
|
||||
if (data.ar2 == (crypto1_word(t, 0, 0) ^ prng_successor(data.nonce, 64))) {
|
||||
//PrintAndLog("Found Key: [%012" PRIx64 "]",key);
|
||||
outkey = key;
|
||||
counter++;
|
||||
if (counter == 20) break;
|
||||
}
|
||||
}
|
||||
isSuccess = (counter == 1);
|
||||
*outputkey = ( isSuccess ) ? outkey : 0;
|
||||
crypto1_destroy(s);
|
||||
/* //un-comment to save all keys to a stats.txt file
|
||||
FILE *fout;
|
||||
if ((fout = fopen("stats.txt","ab")) == NULL) {
|
||||
PrintAndLog("Could not create file name stats.txt");
|
||||
return 1;
|
||||
}
|
||||
fprintf(fout, "mfkey32,%d,%08x,%d,%s,%04x%08x,%.0Lf\r\n", counter, data.cuid, data.sector, (data.keytype) ? "B" : "A", (uint32_t)(outkey>>32) & 0xFFFF,(uint32_t)(outkey&0xFFFFFFFF),(long double)t1);
|
||||
fclose(fout);
|
||||
*/
|
||||
return isSuccess;
|
||||
}
|
||||
|
||||
// recover key from 2 reader responses on 2 different tag challenges
|
||||
bool mfkey32_moebius(nonces_t data, uint64_t *outputkey) {
|
||||
struct Crypto1State *s, *t;
|
||||
uint64_t outkey = 0;
|
||||
uint64_t key = 0; // recovered key
|
||||
bool isSuccess = false;
|
||||
int counter = 0;
|
||||
|
||||
s = lfsr_recovery32(data.ar ^ prng_successor(data.nonce, 64), 0);
|
||||
|
||||
for(t = s; t->odd | t->even; ++t) {
|
||||
lfsr_rollback_word(t, 0, 0);
|
||||
lfsr_rollback_word(t, data.nr, 1);
|
||||
lfsr_rollback_word(t, data.cuid ^ data.nonce, 0);
|
||||
crypto1_get_lfsr(t, &key);
|
||||
|
||||
crypto1_word(t, data.cuid ^ data.nonce2, 0);
|
||||
crypto1_word(t, data.nr2, 1);
|
||||
if (data.ar2 == (crypto1_word(t, 0, 0) ^ prng_successor(data.nonce2, 64))) {
|
||||
//PrintAndLog("Found Key: [%012" PRIx64 "]",key);
|
||||
outkey=key;
|
||||
++counter;
|
||||
if (counter==20)
|
||||
break;
|
||||
}
|
||||
}
|
||||
isSuccess = (counter == 1);
|
||||
*outputkey = ( isSuccess ) ? outkey : 0;
|
||||
crypto1_destroy(s);
|
||||
/* // un-comment to output all keys to stats.txt
|
||||
FILE *fout;
|
||||
if ((fout = fopen("stats.txt","ab")) == NULL) {
|
||||
PrintAndLog("Could not create file name stats.txt");
|
||||
return 1;
|
||||
}
|
||||
fprintf(fout, "moebius,%d,%08x,%d,%s,%04x%08x,%0.Lf\r\n", counter, data.cuid, data.sector, (data.keytype) ? "B" : "A", (uint32_t) (outkey>>32),(uint32_t)(outkey&0xFFFFFFFF),(long double)t1);
|
||||
fclose(fout);
|
||||
*/
|
||||
return isSuccess;
|
||||
}
|
||||
|
||||
// recover key from reader response and tag response of one authentication sequence
|
||||
int mfkey64(nonces_t data, uint64_t *outputkey){
|
||||
uint64_t key = 0; // recovered key
|
||||
uint32_t ks2; // keystream used to encrypt reader response
|
||||
uint32_t ks3; // keystream used to encrypt tag response
|
||||
struct Crypto1State *revstate;
|
||||
|
||||
// Extract the keystream from the messages
|
||||
ks2 = data.ar ^ prng_successor(data.nonce, 64);
|
||||
ks3 = data.at ^ prng_successor(data.nonce, 96);
|
||||
revstate = lfsr_recovery64(ks2, ks3);
|
||||
lfsr_rollback_word(revstate, 0, 0);
|
||||
lfsr_rollback_word(revstate, 0, 0);
|
||||
lfsr_rollback_word(revstate, data.nr, 1);
|
||||
lfsr_rollback_word(revstate, data.cuid ^ data.nonce, 0);
|
||||
crypto1_get_lfsr(revstate, &key);
|
||||
// PrintAndLog("Found Key: [%012" PRIx64 "]", key);
|
||||
crypto1_destroy(revstate);
|
||||
*outputkey = key;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
24
client/mifare/mfkey.h
Normal file
24
client/mifare/mfkey.h
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Merlok - June 2011
|
||||
// Roel - Dec 2009
|
||||
// Unknown author
|
||||
//
|
||||
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
|
||||
// at your option, any later version. See the LICENSE.txt file for the text of
|
||||
// the license.
|
||||
//-----------------------------------------------------------------------------
|
||||
// MIFARE Darkside hack
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MFKEY_H
|
||||
#define MFKEY_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include "mifare.h"
|
||||
|
||||
extern bool mfkey32(nonces_t data, uint64_t *outputkey);
|
||||
extern bool mfkey32_moebius(nonces_t data, uint64_t *outputkey);
|
||||
extern int mfkey64(nonces_t data, uint64_t *outputkey);
|
||||
|
||||
#endif
|
||||
469
client/mifare/mifare4.c
Normal file
469
client/mifare/mifare4.c
Normal file
|
|
@ -0,0 +1,469 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2018 Merlok
|
||||
// Copyright (C) 2018 drHatson
|
||||
//
|
||||
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
|
||||
// at your option, any later version. See the LICENSE.txt file for the text of
|
||||
// the license.
|
||||
//-----------------------------------------------------------------------------
|
||||
// iso14443-4 mifare commands
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "mifare4.h"
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include "cmdhf14a.h"
|
||||
#include "util.h"
|
||||
#include "ui.h"
|
||||
#include "crypto/libpcrypto.h"
|
||||
|
||||
static bool VerboseMode = false;
|
||||
void mfpSetVerboseMode(bool verbose) {
|
||||
VerboseMode = verbose;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
uint8_t Code;
|
||||
const char *Description;
|
||||
} PlusErrorsElm;
|
||||
|
||||
static const PlusErrorsElm PlusErrors[] = {
|
||||
{0xFF, ""},
|
||||
{0x00, "Transfer cannot be granted within the current authentication."},
|
||||
{0x06, "Access Conditions not fulfilled. Block does not exist, block is not a value block."},
|
||||
{0x07, "Too many read or write commands in the session or in the transaction."},
|
||||
{0x08, "Invalid MAC in command or response"},
|
||||
{0x09, "Block Number is not valid"},
|
||||
{0x0a, "Invalid block number, not existing block number"},
|
||||
{0x0b, "The current command code not available at the current card state."},
|
||||
{0x0c, "Length error"},
|
||||
{0x0f, "General Manipulation Error. Failure in the operation of the PICC (cannot write to the data block), etc."},
|
||||
{0x90, "OK"},
|
||||
};
|
||||
int PlusErrorsLen = sizeof(PlusErrors) / sizeof(PlusErrorsElm);
|
||||
|
||||
const char *mfpGetErrorDescription(uint8_t errorCode) {
|
||||
for (int i = 0; i < PlusErrorsLen; i++)
|
||||
if (errorCode == PlusErrors[i].Code)
|
||||
return PlusErrors[i].Description;
|
||||
|
||||
return PlusErrors[0].Description;
|
||||
}
|
||||
|
||||
AccessConditions_t MFAccessConditions[] = {
|
||||
{0x00, "read AB; write AB; increment AB; decrement transfer restore AB"},
|
||||
{0x01, "read AB; decrement transfer restore AB"},
|
||||
{0x02, "read AB"},
|
||||
{0x03, "read B; write B"},
|
||||
{0x04, "read AB; writeB"},
|
||||
{0x05, "read B"},
|
||||
{0x06, "read AB; write B; increment B; decrement transfer restore AB"},
|
||||
{0x07, "none"}
|
||||
};
|
||||
|
||||
AccessConditions_t MFAccessConditionsTrailer[] = {
|
||||
{0x00, "read A by A; read ACCESS by A; read B by A; write B by A"},
|
||||
{0x01, "write A by A; read ACCESS by A write ACCESS by A; read B by A; write B by A"},
|
||||
{0x02, "read ACCESS by A; read B by A"},
|
||||
{0x03, "write A by B; read ACCESS by AB; write ACCESS by B; write B by B"},
|
||||
{0x04, "write A by B; read ACCESS by AB; write B by B"},
|
||||
{0x05, "read ACCESS by AB; write ACCESS by B"},
|
||||
{0x06, "read ACCESS by AB"},
|
||||
{0x07, "read ACCESS by AB"}
|
||||
};
|
||||
|
||||
char *mfGetAccessConditionsDesc(uint8_t blockn, uint8_t *data) {
|
||||
static char StaticNone[] = "none";
|
||||
|
||||
uint8_t data1 = ((data[1] >> 4) & 0x0f) >> blockn;
|
||||
uint8_t data2 = ((data[2]) & 0x0f) >> blockn;
|
||||
uint8_t data3 = ((data[2] >> 4) & 0x0f) >> blockn;
|
||||
|
||||
uint8_t cond = (data1 & 0x01) << 2 | (data2 & 0x01) << 1 | (data3 & 0x01);
|
||||
|
||||
if (blockn == 3) {
|
||||
for (int i = 0; i < ARRAYLEN(MFAccessConditionsTrailer); i++)
|
||||
if (MFAccessConditionsTrailer[i].cond == cond) {
|
||||
return MFAccessConditionsTrailer[i].description;
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < ARRAYLEN(MFAccessConditions); i++)
|
||||
if (MFAccessConditions[i].cond == cond) {
|
||||
return MFAccessConditions[i].description;
|
||||
}
|
||||
};
|
||||
|
||||
return StaticNone;
|
||||
};
|
||||
|
||||
int CalculateEncIVCommand(mf4Session *session, uint8_t *iv, bool verbose) {
|
||||
memcpy(&iv[0], session->TI, 4);
|
||||
memcpy(&iv[4], &session->R_Ctr, 2);
|
||||
memcpy(&iv[6], &session->W_Ctr, 2);
|
||||
memcpy(&iv[8], &session->R_Ctr, 2);
|
||||
memcpy(&iv[10], &session->W_Ctr, 2);
|
||||
memcpy(&iv[12], &session->R_Ctr, 2);
|
||||
memcpy(&iv[14], &session->W_Ctr, 2);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CalculateEncIVResponse(mf4Session *session, uint8_t *iv, bool verbose) {
|
||||
memcpy(&iv[0], &session->R_Ctr, 2);
|
||||
memcpy(&iv[2], &session->W_Ctr, 2);
|
||||
memcpy(&iv[4], &session->R_Ctr, 2);
|
||||
memcpy(&iv[6], &session->W_Ctr, 2);
|
||||
memcpy(&iv[8], &session->R_Ctr, 2);
|
||||
memcpy(&iv[10], &session->W_Ctr, 2);
|
||||
memcpy(&iv[12], session->TI, 4);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int CalculateMAC(mf4Session *session, MACType_t mtype, uint8_t blockNum, uint8_t blockCount, uint8_t *data, int datalen, uint8_t *mac, bool verbose) {
|
||||
if (!session || !session->Authenticated || !mac || !data || !datalen || datalen < 1)
|
||||
return 1;
|
||||
|
||||
memset(mac, 0x00, 8);
|
||||
|
||||
uint16_t ctr = session->R_Ctr;
|
||||
switch (mtype) {
|
||||
case mtypWriteCmd:
|
||||
case mtypWriteResp:
|
||||
ctr = session->W_Ctr;
|
||||
break;
|
||||
case mtypReadCmd:
|
||||
case mtypReadResp:
|
||||
break;
|
||||
}
|
||||
|
||||
uint8_t macdata[2049] = {data[0], (ctr & 0xFF), (ctr >> 8), 0};
|
||||
int macdatalen = datalen;
|
||||
memcpy(&macdata[3], session->TI, 4);
|
||||
|
||||
switch (mtype) {
|
||||
case mtypReadCmd:
|
||||
memcpy(&macdata[7], &data[1], datalen - 1);
|
||||
macdatalen = datalen + 6;
|
||||
break;
|
||||
case mtypReadResp:
|
||||
macdata[7] = blockNum;
|
||||
macdata[8] = 0;
|
||||
macdata[9] = blockCount;
|
||||
memcpy(&macdata[10], &data[1], datalen - 1);
|
||||
macdatalen = datalen + 9;
|
||||
break;
|
||||
case mtypWriteCmd:
|
||||
memcpy(&macdata[7], &data[1], datalen - 1);
|
||||
macdatalen = datalen + 6;
|
||||
break;
|
||||
case mtypWriteResp:
|
||||
macdatalen = 1 + 6;
|
||||
break;
|
||||
}
|
||||
|
||||
if (verbose)
|
||||
PrintAndLog("MAC data[%d]: %s", macdatalen, sprint_hex(macdata, macdatalen));
|
||||
|
||||
return aes_cmac8(NULL, session->Kmac, macdata, mac, macdatalen);
|
||||
}
|
||||
|
||||
int MifareAuth4(mf4Session *session, uint8_t *keyn, uint8_t *key, bool activateField, bool leaveSignalON, bool verbose) {
|
||||
uint8_t data[257] = {0};
|
||||
int datalen = 0;
|
||||
|
||||
uint8_t RndA[17] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00};
|
||||
uint8_t RndB[17] = {0};
|
||||
|
||||
if (session)
|
||||
session->Authenticated = false;
|
||||
|
||||
uint8_t cmd1[] = {0x70, keyn[1], keyn[0], 0x00};
|
||||
int res = ExchangeRAW14a(cmd1, sizeof(cmd1), activateField, true, data, sizeof(data), &datalen);
|
||||
if (res) {
|
||||
PrintAndLogEx(ERR, "Exchande raw error: %d", res);
|
||||
DropField();
|
||||
return 2;
|
||||
}
|
||||
|
||||
if (verbose)
|
||||
PrintAndLogEx(INFO, "<phase1: %s", sprint_hex(data, datalen));
|
||||
|
||||
if (datalen < 1) {
|
||||
PrintAndLogEx(ERR, "Card response wrong length: %d", datalen);
|
||||
DropField();
|
||||
return 3;
|
||||
}
|
||||
|
||||
if (data[0] != 0x90) {
|
||||
PrintAndLogEx(ERR, "Card response error: %02x", data[2]);
|
||||
DropField();
|
||||
return 3;
|
||||
}
|
||||
|
||||
if (datalen != 19) { // code 1b + 16b + crc 2b
|
||||
PrintAndLogEx(ERR, "Card response must be 19 bytes long instead of: %d", datalen);
|
||||
DropField();
|
||||
return 3;
|
||||
}
|
||||
|
||||
aes_decode(NULL, key, &data[1], RndB, 16);
|
||||
RndB[16] = RndB[0];
|
||||
if (verbose)
|
||||
PrintAndLogEx(INFO, "RndB: %s", sprint_hex(RndB, 16));
|
||||
|
||||
uint8_t cmd2[33] = {0};
|
||||
cmd2[0] = 0x72;
|
||||
|
||||
uint8_t raw[32] = {0};
|
||||
memmove(raw, RndA, 16);
|
||||
memmove(&raw[16], &RndB[1], 16);
|
||||
|
||||
aes_encode(NULL, key, raw, &cmd2[1], 32);
|
||||
if (verbose)
|
||||
PrintAndLogEx(INFO, ">phase2: %s", sprint_hex(cmd2, 33));
|
||||
|
||||
res = ExchangeRAW14a(cmd2, sizeof(cmd2), false, true, data, sizeof(data), &datalen);
|
||||
if (res) {
|
||||
PrintAndLogEx(ERR, "Exchande raw error: %d", res);
|
||||
DropField();
|
||||
return 4;
|
||||
}
|
||||
|
||||
if (verbose)
|
||||
PrintAndLogEx(INFO, "<phase2: %s", sprint_hex(data, datalen));
|
||||
|
||||
aes_decode(NULL, key, &data[1], raw, 32);
|
||||
|
||||
if (verbose) {
|
||||
PrintAndLogEx(INFO, "res: %s", sprint_hex(raw, 32));
|
||||
PrintAndLogEx(INFO, "RndA`: %s", sprint_hex(&raw[4], 16));
|
||||
}
|
||||
|
||||
if (memcmp(&raw[4], &RndA[1], 16)) {
|
||||
PrintAndLogEx(ERR, "\nAuthentication FAILED. rnd not equal");
|
||||
if (verbose) {
|
||||
PrintAndLogEx(ERR, "RndA reader: %s", sprint_hex(&RndA[1], 16));
|
||||
PrintAndLogEx(ERR, "RndA card: %s", sprint_hex(&raw[4], 16));
|
||||
}
|
||||
DropField();
|
||||
return 5;
|
||||
}
|
||||
|
||||
if (verbose) {
|
||||
PrintAndLogEx(INFO, " TI: %s", sprint_hex(raw, 4));
|
||||
PrintAndLogEx(INFO, "pic: %s", sprint_hex(&raw[20], 6));
|
||||
PrintAndLogEx(INFO, "pcd: %s", sprint_hex(&raw[26], 6));
|
||||
}
|
||||
|
||||
uint8_t kenc[16] = {0};
|
||||
memcpy(&kenc[0], &RndA[11], 5);
|
||||
memcpy(&kenc[5], &RndB[11], 5);
|
||||
for (int i = 0; i < 5; i++)
|
||||
kenc[10 + i] = RndA[4 + i] ^ RndB[4 + i];
|
||||
kenc[15] = 0x11;
|
||||
|
||||
aes_encode(NULL, key, kenc, kenc, 16);
|
||||
if (verbose) {
|
||||
PrintAndLogEx(INFO, "kenc: %s", sprint_hex(kenc, 16));
|
||||
}
|
||||
|
||||
uint8_t kmac[16] = {0};
|
||||
memcpy(&kmac[0], &RndA[7], 5);
|
||||
memcpy(&kmac[5], &RndB[7], 5);
|
||||
for(int i = 0; i < 5; i++)
|
||||
kmac[10 + i] = RndA[0 + i] ^ RndB[0 + i];
|
||||
kmac[15] = 0x22;
|
||||
|
||||
aes_encode(NULL, key, kmac, kmac, 16);
|
||||
if (verbose) {
|
||||
PrintAndLog("kmac: %s", sprint_hex(kmac, 16));
|
||||
}
|
||||
|
||||
if (!leaveSignalON)
|
||||
DropField();
|
||||
|
||||
if (verbose)
|
||||
PrintAndLog("");
|
||||
|
||||
if (session) {
|
||||
session->Authenticated = true;
|
||||
session->R_Ctr = 0;
|
||||
session->W_Ctr = 0;
|
||||
session->KeyNum = keyn[1] + (keyn[0] << 8);
|
||||
memmove(session->RndA, RndA, 16);
|
||||
memmove(session->RndB, RndB, 16);
|
||||
memmove(session->Key, key, 16);
|
||||
memmove(session->TI, raw, 4);
|
||||
memmove(session->PICCap2, &raw[20], 6);
|
||||
memmove(session->PCDCap2, &raw[26], 6);
|
||||
memmove(session->Kenc, kenc, 16);
|
||||
memmove(session->Kmac, kmac, 16);
|
||||
}
|
||||
|
||||
if (verbose)
|
||||
PrintAndLogEx(INFO, "Authentication OK");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int intExchangeRAW14aPlus(uint8_t *datain, int datainlen, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen) {
|
||||
if (VerboseMode)
|
||||
PrintAndLogEx(INFO, ">>> %s", sprint_hex(datain, datainlen));
|
||||
|
||||
int res = ExchangeRAW14a(datain, datainlen, activateField, leaveSignalON, dataout, maxdataoutlen, dataoutlen);
|
||||
|
||||
if (VerboseMode)
|
||||
PrintAndLogEx(INFO, "<<< %s", sprint_hex(dataout, *dataoutlen));
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
int MFPWritePerso(uint8_t *keyNum, uint8_t *key, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen) {
|
||||
uint8_t rcmd[3 + 16] = {0xa8, keyNum[1], keyNum[0], 0x00};
|
||||
memmove(&rcmd[3], key, 16);
|
||||
|
||||
return intExchangeRAW14aPlus(rcmd, sizeof(rcmd), activateField, leaveSignalON, dataout, maxdataoutlen, dataoutlen);
|
||||
}
|
||||
|
||||
int MFPCommitPerso(bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen) {
|
||||
uint8_t rcmd[1] = {0xaa};
|
||||
|
||||
return intExchangeRAW14aPlus(rcmd, sizeof(rcmd), activateField, leaveSignalON, dataout, maxdataoutlen, dataoutlen);
|
||||
}
|
||||
|
||||
int MFPReadBlock(mf4Session *session, bool plain, uint8_t blockNum, uint8_t blockCount, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac) {
|
||||
uint8_t rcmd[4 + 8] = {(plain ? (0x37) : (0x33)), blockNum, 0x00, blockCount};
|
||||
if (!plain && session)
|
||||
CalculateMAC(session, mtypReadCmd, blockNum, blockCount, rcmd, 4, &rcmd[4], VerboseMode);
|
||||
|
||||
int res = intExchangeRAW14aPlus(rcmd, plain ? 4 : sizeof(rcmd), activateField, leaveSignalON, dataout, maxdataoutlen, dataoutlen);
|
||||
if (res)
|
||||
return res;
|
||||
|
||||
if (session)
|
||||
session->R_Ctr++;
|
||||
|
||||
if (session && mac && *dataoutlen > 11)
|
||||
CalculateMAC(session, mtypReadResp, blockNum, blockCount, dataout, *dataoutlen - 8 - 2, mac, VerboseMode);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int MFPWriteBlock(mf4Session *session, uint8_t blockNum, uint8_t *data, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac) {
|
||||
uint8_t rcmd[1 + 2 + 16 + 8] = {0xA3, blockNum, 0x00};
|
||||
memmove(&rcmd[3], data, 16);
|
||||
if (session)
|
||||
CalculateMAC(session, mtypWriteCmd, blockNum, 1, rcmd, 19, &rcmd[19], VerboseMode);
|
||||
|
||||
int res = intExchangeRAW14aPlus(rcmd, sizeof(rcmd), activateField, leaveSignalON, dataout, maxdataoutlen, dataoutlen);
|
||||
if (res)
|
||||
return res;
|
||||
|
||||
if (session)
|
||||
session->W_Ctr++;
|
||||
|
||||
if (session && mac && *dataoutlen > 3)
|
||||
CalculateMAC(session, mtypWriteResp, blockNum, 1, dataout, *dataoutlen, mac, VerboseMode);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mfpReadSector(uint8_t sectorNo, uint8_t keyType, uint8_t *key, uint8_t *dataout, bool verbose) {
|
||||
uint8_t keyn[2] = {0};
|
||||
bool plain = false;
|
||||
|
||||
uint16_t uKeyNum = 0x4000 + sectorNo * 2 + (keyType ? 1 : 0);
|
||||
keyn[0] = uKeyNum >> 8;
|
||||
keyn[1] = uKeyNum & 0xff;
|
||||
if (verbose)
|
||||
PrintAndLogEx(INFO, "--sector[%d]:%02x key:%04x", mfNumBlocksPerSector(sectorNo), sectorNo, uKeyNum);
|
||||
|
||||
mf4Session session;
|
||||
int res = MifareAuth4(&session, keyn, key, true, true, verbose);
|
||||
if (res) {
|
||||
PrintAndLogEx(ERR, "Sector %d authentication error: %d", sectorNo, res);
|
||||
return res;
|
||||
}
|
||||
|
||||
uint8_t data[250] = {0};
|
||||
int datalen = 0;
|
||||
uint8_t mac[8] = {0};
|
||||
uint8_t firstBlockNo = mfFirstBlockOfSector(sectorNo);
|
||||
for (int n = firstBlockNo; n < firstBlockNo + mfNumBlocksPerSector(sectorNo); n++) {
|
||||
res = MFPReadBlock(&session, plain, n & 0xff, 1, false, true, data, sizeof(data), &datalen, mac);
|
||||
if (res) {
|
||||
PrintAndLogEx(ERR, "Sector %d read error: %d", sectorNo, res);
|
||||
DropField();
|
||||
return res;
|
||||
}
|
||||
|
||||
if (datalen && data[0] != 0x90) {
|
||||
PrintAndLogEx(ERR, "Sector %d card read error: %02x %s", sectorNo, data[0], mfpGetErrorDescription(data[0]));
|
||||
DropField();
|
||||
return 5;
|
||||
}
|
||||
if (datalen != 1 + 16 + 8 + 2) {
|
||||
PrintAndLogEx(ERR, "Sector %d error returned data length:%d", sectorNo, datalen);
|
||||
DropField();
|
||||
return 6;
|
||||
}
|
||||
|
||||
memcpy(&dataout[(n - firstBlockNo) * 16], &data[1], 16);
|
||||
|
||||
if (verbose)
|
||||
PrintAndLogEx(INFO, "data[%03d]: %s", n, sprint_hex(&data[1], 16));
|
||||
|
||||
if (memcmp(&data[1 + 16], mac, 8)) {
|
||||
PrintAndLogEx(WARNING, "WARNING: mac on block %d not equal...", n);
|
||||
PrintAndLogEx(WARNING, "MAC card: %s", sprint_hex(&data[1 + 16], 8));
|
||||
PrintAndLogEx(WARNING, "MAC reader: %s", sprint_hex(mac, 8));
|
||||
|
||||
if (!verbose)
|
||||
return 7;
|
||||
} else {
|
||||
if (verbose)
|
||||
PrintAndLogEx(INFO, "MAC: %s", sprint_hex(&data[1 + 16], 8));
|
||||
}
|
||||
}
|
||||
DropField();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Mifare Memory Structure: up to 32 Sectors with 4 blocks each (1k and 2k cards),
|
||||
// plus evtl. 8 sectors with 16 blocks each (4k cards)
|
||||
uint8_t mfNumBlocksPerSector(uint8_t sectorNo) {
|
||||
if (sectorNo < 32)
|
||||
return 4;
|
||||
else
|
||||
return 16;
|
||||
}
|
||||
|
||||
uint8_t mfFirstBlockOfSector(uint8_t sectorNo) {
|
||||
if (sectorNo < 32)
|
||||
return sectorNo * 4;
|
||||
else
|
||||
return 32 * 4 + (sectorNo - 32) * 16;
|
||||
}
|
||||
|
||||
uint8_t mfSectorTrailer(uint8_t blockNo) {
|
||||
if (blockNo < 32 * 4) {
|
||||
return (blockNo | 0x03);
|
||||
} else {
|
||||
return (blockNo | 0x0f);
|
||||
}
|
||||
}
|
||||
|
||||
bool mfIsSectorTrailer(uint8_t blockNo) {
|
||||
return (blockNo == mfSectorTrailer(blockNo));
|
||||
}
|
||||
|
||||
uint8_t mfSectorNum(uint8_t blockNo) {
|
||||
if (blockNo < 32 * 4)
|
||||
return blockNo / 4;
|
||||
else
|
||||
return 32 + (blockNo - 32 * 4) / 16;
|
||||
|
||||
}
|
||||
67
client/mifare/mifare4.h
Normal file
67
client/mifare/mifare4.h
Normal file
|
|
@ -0,0 +1,67 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2018 Merlok
|
||||
// Copyright (C) 2018 drHatson
|
||||
//
|
||||
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
|
||||
// at your option, any later version. See the LICENSE.txt file for the text of
|
||||
// the license.
|
||||
//-----------------------------------------------------------------------------
|
||||
// iso14443-4 mifare commands
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MIFARE4_H
|
||||
#define MIFARE4_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
|
||||
typedef struct {
|
||||
bool Authenticated;
|
||||
uint8_t Key[16];
|
||||
uint16_t KeyNum;
|
||||
uint8_t RndA[16];
|
||||
uint8_t RndB[16];
|
||||
uint8_t TI[4];
|
||||
uint8_t PICCap2[6];
|
||||
uint8_t PCDCap2[6];
|
||||
uint8_t Kenc[16];
|
||||
uint8_t Kmac[16];
|
||||
uint16_t R_Ctr;
|
||||
uint16_t W_Ctr;
|
||||
}mf4Session;
|
||||
|
||||
typedef enum {
|
||||
mtypReadCmd,
|
||||
mtypReadResp,
|
||||
mtypWriteCmd,
|
||||
mtypWriteResp,
|
||||
} MACType_t;
|
||||
|
||||
typedef struct {
|
||||
uint8_t cond;
|
||||
char *description;
|
||||
} AccessConditions_t;
|
||||
|
||||
extern void mfpSetVerboseMode(bool verbose);
|
||||
extern const char *mfpGetErrorDescription(uint8_t errorCode);
|
||||
|
||||
extern int CalculateMAC(mf4Session *session, MACType_t mtype, uint8_t blockNum, uint8_t blockCount, uint8_t *data, int datalen, uint8_t *mac, bool verbose);
|
||||
extern int MifareAuth4(mf4Session *session, uint8_t *keyn, uint8_t *key, bool activateField, bool leaveSignalON, bool verbose);
|
||||
|
||||
extern int MFPWritePerso(uint8_t *keyNum, uint8_t *key, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);
|
||||
extern int MFPCommitPerso(bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);
|
||||
extern int MFPReadBlock(mf4Session *session, bool plain, uint8_t blockNum, uint8_t blockCount, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac);
|
||||
extern int MFPWriteBlock(mf4Session *session, uint8_t blockNum, uint8_t *data, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac);
|
||||
extern int mfpReadSector(uint8_t sectorNo, uint8_t keyType, uint8_t *key, uint8_t *dataout, bool verbose);
|
||||
|
||||
extern char *mfGetAccessConditionsDesc(uint8_t blockn, uint8_t *data);
|
||||
|
||||
extern uint8_t mfNumBlocksPerSector(uint8_t sectorNo);
|
||||
extern uint8_t mfFirstBlockOfSector(uint8_t sectorNo);
|
||||
extern uint8_t mfSectorTrailer(uint8_t blockNo);
|
||||
extern bool mfIsSectorTrailer(uint8_t blockNo);
|
||||
extern uint8_t mfSectorNum(uint8_t blockNo);
|
||||
|
||||
|
||||
#endif // mifare4.h
|
||||
45
client/mifare/mifaredefault.h
Normal file
45
client/mifare/mifaredefault.h
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2017 Merlok
|
||||
//
|
||||
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
|
||||
// at your option, any later version. See the LICENSE.txt file for the text of
|
||||
// the license.
|
||||
//-----------------------------------------------------------------------------
|
||||
// Mifare default constants
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MIFAREDEFAULT_H__
|
||||
#define MIFAREDEFAULT_H__
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
#define MifareDefaultKeysSize sizeof(MifareDefaultKeys) / sizeof(uint64_t)
|
||||
|
||||
static const uint64_t MifareDefaultKeys[] =
|
||||
{
|
||||
0xffffffffffff, // Default key (first key used by program if no user defined key)
|
||||
0x000000000000, // Blank key
|
||||
0xa0a1a2a3a4a5, // NFCForum MAD key
|
||||
0xb0b1b2b3b4b5,
|
||||
0xaabbccddeeff,
|
||||
0x1a2b3c4d5e6f,
|
||||
0x123456789abc,
|
||||
0x010203040506,
|
||||
0x123456abcdef,
|
||||
0xabcdef123456,
|
||||
0x4d3a99c351dd,
|
||||
0x1a982c7e459a,
|
||||
0xd3f7d3f7d3f7,
|
||||
0x714c5c886e97,
|
||||
0x587ee5f9350f,
|
||||
0xa0478cc39091,
|
||||
0x533cb6c723f6,
|
||||
0x8fd0a4f256e9
|
||||
};
|
||||
|
||||
static const uint8_t g_mifare_mad_key[] = {0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5};
|
||||
static const uint8_t g_mifare_ndef_key[] = {0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7};
|
||||
static const uint8_t g_mifarep_mad_key[] = {0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7};
|
||||
static const uint8_t g_mifarep_ndef_key[] = {0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7};
|
||||
|
||||
#endif
|
||||
1114
client/mifare/mifarehost.c
Normal file
1114
client/mifare/mifarehost.c
Normal file
File diff suppressed because it is too large
Load diff
70
client/mifare/mifarehost.h
Normal file
70
client/mifare/mifarehost.h
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
// Merlok, 2011, 2017
|
||||
// people from mifare@nethemba.com, 2010
|
||||
//
|
||||
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
|
||||
// at your option, any later version. See the LICENSE.txt file for the text of
|
||||
// the license.
|
||||
//-----------------------------------------------------------------------------
|
||||
// High frequency ISO14443A commands
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef MIFAREHOST_H
|
||||
#define MIFAREHOST_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include "crapto1/crapto1.h"
|
||||
#include "util.h"
|
||||
|
||||
// defaults
|
||||
// timeout in units. (ms * 106)/10 or us*0.0106
|
||||
// 5 == 500us
|
||||
#define MF_CHKKEYS_DEFTIMEOUT 5
|
||||
|
||||
// mfCSetBlock work flags
|
||||
#define CSETBLOCK_UID 0x01
|
||||
#define CSETBLOCK_WUPC 0x02
|
||||
#define CSETBLOCK_HALT 0x04
|
||||
#define CSETBLOCK_INIT_FIELD 0x08
|
||||
#define CSETBLOCK_RESET_FIELD 0x10
|
||||
#define CSETBLOCK_SINGLE_OPER 0x1F
|
||||
#define CSETBLOCK_MAGIC_1B 0x40
|
||||
|
||||
typedef struct {
|
||||
uint64_t Key[2];
|
||||
int foundKey[2];
|
||||
} sector_t;
|
||||
|
||||
extern char logHexFileName[FILE_PATH_SIZE];
|
||||
|
||||
extern int mfDarkside(uint64_t *key);
|
||||
extern int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t *ResultKeys, bool calibrate);
|
||||
extern int mfCheckKeys (uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keycnt, uint8_t *keyBlock, uint64_t *key);
|
||||
extern int mfCheckKeysSec(uint8_t sectorCnt, uint8_t keyType, uint8_t timeout14a, bool clear_trace, uint8_t keycnt, uint8_t * keyBlock, sector_t * e_sector);
|
||||
|
||||
extern int mfReadSector(uint8_t sectorNo, uint8_t keyType, uint8_t *key, uint8_t *data);
|
||||
|
||||
extern int mfEmlGetMem(uint8_t *data, int blockNum, int blocksCount);
|
||||
extern int mfEmlSetMem(uint8_t *data, int blockNum, int blocksCount);
|
||||
|
||||
extern int mfCWipe(uint32_t numSectors, bool gen1b, bool wantWipe, bool wantFill);
|
||||
extern int mfCSetUID(uint8_t *uid, uint8_t *atqa, uint8_t *sak, uint8_t *oldUID);
|
||||
extern int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, bool wantWipe, uint8_t params);
|
||||
extern int mfCGetBlock(uint8_t blockNo, uint8_t *data, uint8_t params);
|
||||
|
||||
extern int mfTraceInit(uint8_t *tuid, uint8_t *atqa, uint8_t sak, bool wantSaveToEmlFile);
|
||||
extern int mfTraceDecode(uint8_t *data_src, int len, uint8_t parity, bool wantSaveToEmlFile);
|
||||
|
||||
extern int isTraceCardEmpty(void);
|
||||
extern int isBlockEmpty(int blockN);
|
||||
extern int isBlockTrailer(int blockN);
|
||||
extern int loadTraceCard(uint8_t *tuid);
|
||||
extern int saveTraceCard(void);
|
||||
extern int tryDecryptWord(uint32_t nt, uint32_t ar_enc, uint32_t at_enc, uint8_t *data, int len);
|
||||
|
||||
extern int mfCIdentify();
|
||||
extern int DetectClassicPrng(void);
|
||||
extern bool validate_prng_nonce(uint32_t nonce);
|
||||
extern void mf_crypto1_decrypt(struct Crypto1State *pcs, uint8_t *data, int len, bool isEncrypted);
|
||||
|
||||
#endif
|
||||
359
client/mifare/ndef.c
Normal file
359
client/mifare/ndef.c
Normal file
|
|
@ -0,0 +1,359 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2019 Merlok
|
||||
//
|
||||
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
|
||||
// at your option, any later version. See the LICENSE.txt file for the text of
|
||||
// the license.
|
||||
//-----------------------------------------------------------------------------
|
||||
// NFC Data Exchange Format (NDEF) functions
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "ndef.h"
|
||||
#include "ui.h"
|
||||
#include "emv/dump.h"
|
||||
#include "crypto/asn1utils.h"
|
||||
#include "util.h"
|
||||
#include <string.h>
|
||||
|
||||
#define STRBOOL(p) ((p) ? "+" : "-")
|
||||
|
||||
static const char *TypeNameFormat_s[] = {
|
||||
"Empty Record",
|
||||
"Well Known Record",
|
||||
"MIME Media Record",
|
||||
"Absolute URI Record",
|
||||
"External Record",
|
||||
"Unknown Record",
|
||||
"Unchanged Record",
|
||||
"n/a"
|
||||
};
|
||||
|
||||
static const char *ndefSigType_s[] = {
|
||||
"Not present", // No signature present
|
||||
"RSASSA_PSS_SHA_1", // PKCS_1
|
||||
"RSASSA_PKCS1_v1_5_WITH_SHA_1", // PKCS_1
|
||||
"DSA",
|
||||
"ECDSA",
|
||||
"n/a"
|
||||
};
|
||||
|
||||
static const char *ndefCertificateFormat_s[] = {
|
||||
"X_509",
|
||||
"X9_68",
|
||||
"n/a"
|
||||
};
|
||||
|
||||
static const char *URI_s[] = {
|
||||
"", // 0x00
|
||||
"http://www.", // 0x01
|
||||
"https://www.", // 0x02
|
||||
"http://", // 0x03
|
||||
"https://", // 0x04
|
||||
"tel:", // 0x05
|
||||
"mailto:", // 0x06
|
||||
"ftp://anonymous:anonymous@", // 0x07
|
||||
"ftp://ftp.", // 0x08
|
||||
"ftps://", // 0x09
|
||||
"sftp://", // 0x0A
|
||||
"smb://", // 0x0B
|
||||
"nfs://", // 0x0C
|
||||
"ftp://", // 0x0D
|
||||
"dav://", // 0x0E
|
||||
"news:", // 0x0F
|
||||
"telnet://", // 0x10
|
||||
"imap:", // 0x11
|
||||
"rtsp://", // 0x12
|
||||
"urn:", // 0x13
|
||||
"pop:", // 0x14
|
||||
"sip:", // 0x15
|
||||
"sips:", // 0x16
|
||||
"tftp:", // 0x17
|
||||
"btspp://", // 0x18
|
||||
"btl2cap://", // 0x19
|
||||
"btgoep://", // 0x1A
|
||||
"tcpobex://", // 0x1B
|
||||
"irdaobex://", // 0x1C
|
||||
"file://", // 0x1D
|
||||
"urn:epc:id:", // 0x1E
|
||||
"urn:epc:tag:", // 0x1F
|
||||
"urn:epc:pat:", // 0x20
|
||||
"urn:epc:raw:", // 0x21
|
||||
"urn:epc:", // 0x22
|
||||
"urn:nfc:" // 0x23
|
||||
};
|
||||
|
||||
uint16_t ndefTLVGetLength(uint8_t *data, size_t *indx) {
|
||||
uint16_t len = 0;
|
||||
if (data[0] == 0xff) {
|
||||
len = (data[1] << 8) + data[2];
|
||||
*indx += 3;
|
||||
} else {
|
||||
len = data[0];
|
||||
*indx += 1;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
int ndefDecodeHeader(uint8_t *data, size_t datalen, NDEFHeader_t *header) {
|
||||
header->Type = NULL;
|
||||
header->Payload = NULL;
|
||||
header->ID = NULL;
|
||||
|
||||
header->MessageBegin = data[0] & 0x80;
|
||||
header->MessageEnd = data[0] & 0x40;
|
||||
header->ChunkFlag = data[0] & 0x20;
|
||||
header->ShortRecordBit = data[0] & 0x10;
|
||||
header->IDLenPresent = data[0] & 0x08;
|
||||
header->TypeNameFormat = data[0] & 0x07;
|
||||
header->len = 1 + 1 + (header->ShortRecordBit ? 1 : 4) + (header->IDLenPresent ? 1 : 0); // header + typelen + payloadlen + idlen
|
||||
if (header->len > datalen)
|
||||
return 1;
|
||||
|
||||
header->TypeLen = data[1];
|
||||
header->Type = data + header->len;
|
||||
|
||||
header->PayloadLen = (header->ShortRecordBit ? (data[2]) : ((data[2] << 24) + (data[3] << 16) + (data[4] << 8) + data[5]));
|
||||
|
||||
if (header->IDLenPresent) {
|
||||
header->IDLen = (header->ShortRecordBit ? (data[3]) : (data[6]));
|
||||
header->Payload = header->Type + header->TypeLen;
|
||||
} else {
|
||||
header->IDLen = 0;
|
||||
}
|
||||
|
||||
header->Payload = header->Type + header->TypeLen + header->IDLen;
|
||||
|
||||
header->RecLen = header->len + header->TypeLen + header->PayloadLen + header->IDLen;
|
||||
|
||||
if (header->RecLen > datalen)
|
||||
return 3;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ndefPrintHeader(NDEFHeader_t *header) {
|
||||
PrintAndLogEx(INFO, "Header:");
|
||||
|
||||
PrintAndLogEx(NORMAL, "\tMessage Begin: %s", STRBOOL(header->MessageBegin));
|
||||
PrintAndLogEx(NORMAL, "\tMessage End: %s", STRBOOL(header->MessageEnd));
|
||||
PrintAndLogEx(NORMAL, "\tChunk Flag: %s", STRBOOL(header->ChunkFlag));
|
||||
PrintAndLogEx(NORMAL, "\tShort Record Bit: %s", STRBOOL(header->ShortRecordBit));
|
||||
PrintAndLogEx(NORMAL, "\tID Len Present: %s", STRBOOL(header->IDLenPresent));
|
||||
PrintAndLogEx(NORMAL, "\tType Name Format: [0x%02x] %s", header->TypeNameFormat, TypeNameFormat_s[header->TypeNameFormat]);
|
||||
|
||||
PrintAndLogEx(NORMAL, "\tHeader length : %d", header->len);
|
||||
PrintAndLogEx(NORMAL, "\tType length : %d", header->TypeLen);
|
||||
PrintAndLogEx(NORMAL, "\tPayload length : %d", header->PayloadLen);
|
||||
PrintAndLogEx(NORMAL, "\tID length : %d", header->IDLen);
|
||||
PrintAndLogEx(NORMAL, "\tRecord length : %d", header->RecLen);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ndefDecodeSig(uint8_t *sig, size_t siglen) {
|
||||
size_t indx = 0;
|
||||
PrintAndLogEx(NORMAL, "\tsignature version: 0x%02x", sig[0]);
|
||||
if (sig[0] != 0x01) {
|
||||
PrintAndLogEx(ERR, "signature version unknown.");
|
||||
return 1;
|
||||
}
|
||||
indx++;
|
||||
|
||||
uint8_t sigType = sig[indx] & 0x7f;
|
||||
bool sigURI = sig[indx] & 0x80;
|
||||
|
||||
PrintAndLogEx(NORMAL, "\tsignature type: %s", ((sigType < stNA) ? ndefSigType_s[sigType] : ndefSigType_s[stNA]));
|
||||
PrintAndLogEx(NORMAL, "\tsignature uri: %s", (sigURI ? "present" : "not present"));
|
||||
|
||||
size_t intsiglen = (sig[indx + 1] << 8) + sig[indx + 2];
|
||||
// ecdsa 0x04
|
||||
if (sigType == stECDSA) {
|
||||
indx += 3;
|
||||
PrintAndLogEx(NORMAL, "\tsignature [%d]: %s", intsiglen, sprint_hex_inrow(&sig[indx], intsiglen));
|
||||
|
||||
uint8_t rval[300] = {0};
|
||||
uint8_t sval[300] = {0};
|
||||
int res = ecdsa_asn1_get_signature(&sig[indx], intsiglen, rval, sval);
|
||||
if (!res) {
|
||||
PrintAndLogEx(NORMAL, "\t\tr: %s", sprint_hex(rval, 32));
|
||||
PrintAndLogEx(NORMAL, "\t\ts: %s", sprint_hex(sval, 32));
|
||||
}
|
||||
}
|
||||
indx += intsiglen;
|
||||
|
||||
if (sigURI) {
|
||||
size_t intsigurilen = (sig[indx] << 8) + sig[indx + 1];
|
||||
indx += 2;
|
||||
PrintAndLogEx(NORMAL, "\tsignature uri [%d]: %.*s", intsigurilen, intsigurilen, &sig[indx]);
|
||||
indx += intsigurilen;
|
||||
}
|
||||
|
||||
uint8_t certFormat = (sig[indx] >> 4) & 0x07;
|
||||
uint8_t certCount = sig[indx] & 0x0f;
|
||||
bool certURI = sig[indx] & 0x80;
|
||||
|
||||
PrintAndLogEx(NORMAL, "\tcertificate format: %s", ((certFormat < sfNA) ? ndefCertificateFormat_s[certFormat] : ndefCertificateFormat_s[sfNA]));
|
||||
PrintAndLogEx(NORMAL, "\tcertificates count: %d", certCount);
|
||||
|
||||
// print certificates
|
||||
indx++;
|
||||
for (int i = 0; i < certCount; i++) {
|
||||
size_t intcertlen = (sig[indx + 1] << 8) + sig[indx + 2];
|
||||
indx += 2;
|
||||
|
||||
PrintAndLogEx(NORMAL, "\tcertificate %d [%d]: %s", i + 1, intcertlen, sprint_hex_inrow(&sig[indx], intcertlen));
|
||||
indx += intcertlen;
|
||||
}
|
||||
|
||||
// have certificate uri
|
||||
if ((indx <= siglen) && certURI) {
|
||||
size_t inturilen = (sig[indx] << 8) + sig[indx + 1];
|
||||
indx += 2;
|
||||
PrintAndLogEx(NORMAL, "\tcertificate uri [%d]: %.*s", inturilen, inturilen, &sig[indx]);
|
||||
indx += inturilen;
|
||||
}
|
||||
|
||||
return 0;
|
||||
};
|
||||
|
||||
int ndefDecodePayload(NDEFHeader_t *ndef) {
|
||||
|
||||
switch (ndef->TypeNameFormat) {
|
||||
case tnfWellKnownRecord:
|
||||
PrintAndLogEx(INFO, "Well Known Record");
|
||||
PrintAndLogEx(NORMAL, "\ttype: %.*s", ndef->TypeLen, ndef->Type);
|
||||
|
||||
if (!strncmp((char *)ndef->Type, "T", ndef->TypeLen)) {
|
||||
PrintAndLogEx(NORMAL, "\ttext : %.*s", ndef->PayloadLen, ndef->Payload);
|
||||
}
|
||||
|
||||
if (!strncmp((char *)ndef->Type, "U", ndef->TypeLen)) {
|
||||
PrintAndLogEx(NORMAL, "\turi : %s%.*s", (ndef->Payload[0] <= 0x23 ? URI_s[ndef->Payload[0]] : "[err]"), ndef->PayloadLen, &ndef->Payload[1]);
|
||||
}
|
||||
|
||||
if (!strncmp((char *)ndef->Type, "Sig", ndef->TypeLen)) {
|
||||
ndefDecodeSig(ndef->Payload, ndef->PayloadLen);
|
||||
}
|
||||
|
||||
break;
|
||||
case tnfAbsoluteURIRecord:
|
||||
PrintAndLogEx(INFO, "Absolute URI Record");
|
||||
PrintAndLogEx(NORMAL, "\ttype: %.*s", ndef->TypeLen, ndef->Type);
|
||||
PrintAndLogEx(NORMAL, "\tpayload: %.*s", ndef->PayloadLen, ndef->Payload);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ndefRecordDecodeAndPrint(uint8_t *ndefRecord, size_t ndefRecordLen) {
|
||||
NDEFHeader_t NDEFHeader = {0};
|
||||
int res = ndefDecodeHeader(ndefRecord, ndefRecordLen, &NDEFHeader);
|
||||
if (res)
|
||||
return res;
|
||||
|
||||
ndefPrintHeader(&NDEFHeader);
|
||||
|
||||
if (NDEFHeader.TypeLen) {
|
||||
PrintAndLogEx(INFO, "Type data:");
|
||||
dump_buffer(NDEFHeader.Type, NDEFHeader.TypeLen, stdout, 1);
|
||||
}
|
||||
if (NDEFHeader.IDLen) {
|
||||
PrintAndLogEx(INFO, "ID data:");
|
||||
dump_buffer(NDEFHeader.ID, NDEFHeader.IDLen, stdout, 1);
|
||||
}
|
||||
if (NDEFHeader.PayloadLen) {
|
||||
PrintAndLogEx(INFO, "Payload data:");
|
||||
dump_buffer(NDEFHeader.Payload, NDEFHeader.PayloadLen, stdout, 1);
|
||||
if (NDEFHeader.TypeLen)
|
||||
ndefDecodePayload(&NDEFHeader);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ndefRecordsDecodeAndPrint(uint8_t *ndefRecord, size_t ndefRecordLen) {
|
||||
bool firstRec = true;
|
||||
size_t len = 0;
|
||||
|
||||
while (len < ndefRecordLen) {
|
||||
NDEFHeader_t NDEFHeader = {0};
|
||||
int res = ndefDecodeHeader(&ndefRecord[len], ndefRecordLen - len, &NDEFHeader);
|
||||
if (res)
|
||||
return res;
|
||||
|
||||
if (firstRec) {
|
||||
if (!NDEFHeader.MessageBegin) {
|
||||
PrintAndLogEx(ERR, "NDEF first record have MessageBegin=false!");
|
||||
return 1;
|
||||
}
|
||||
firstRec = false;
|
||||
}
|
||||
|
||||
if (NDEFHeader.MessageEnd && len + NDEFHeader.RecLen != ndefRecordLen) {
|
||||
PrintAndLogEx(ERR, "NDEF records have wrong length. Must be %d, calculated %d", ndefRecordLen, len + NDEFHeader.RecLen);
|
||||
return 1;
|
||||
}
|
||||
|
||||
ndefRecordDecodeAndPrint(&ndefRecord[len], NDEFHeader.RecLen);
|
||||
|
||||
len += NDEFHeader.RecLen;
|
||||
|
||||
if (NDEFHeader.MessageEnd)
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int NDEFDecodeAndPrint(uint8_t *ndef, size_t ndefLen, bool verbose) {
|
||||
|
||||
size_t indx = 0;
|
||||
|
||||
PrintAndLogEx(INFO, "NDEF decoding:");
|
||||
while (indx < ndefLen) {
|
||||
switch (ndef[indx]) {
|
||||
case 0x00: {
|
||||
indx++;
|
||||
uint16_t len = ndefTLVGetLength(&ndef[indx], &indx);
|
||||
PrintAndLogEx(INFO, "-- NDEF NULL block.");
|
||||
if (len)
|
||||
PrintAndLogEx(WARNING, "NDEF NULL block size must be 0 instead of %d.", len);
|
||||
indx += len;
|
||||
break;
|
||||
}
|
||||
case 0x03: {
|
||||
indx++;
|
||||
uint16_t len = ndefTLVGetLength(&ndef[indx], &indx);
|
||||
PrintAndLogEx(INFO, "-- NDEF message. len: %d", len);
|
||||
|
||||
int res = ndefRecordsDecodeAndPrint(&ndef[indx], len);
|
||||
if (res)
|
||||
return res;
|
||||
|
||||
indx += len;
|
||||
break;
|
||||
}
|
||||
case 0xfd: {
|
||||
indx++;
|
||||
uint16_t len = ndefTLVGetLength(&ndef[indx], &indx);
|
||||
PrintAndLogEx(INFO, "-- NDEF proprietary info. Skipped %d bytes.", len);
|
||||
indx += len;
|
||||
break;
|
||||
}
|
||||
case 0xfe: {
|
||||
PrintAndLogEx(INFO, "-- NDEF Terminator. Done.");
|
||||
return 0;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
PrintAndLogEx(ERR, "unknown tag 0x%02x", ndef[indx]);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
62
client/mifare/ndef.h
Normal file
62
client/mifare/ndef.h
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (C) 2019 Merlok
|
||||
//
|
||||
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
|
||||
// at your option, any later version. See the LICENSE.txt file for the text of
|
||||
// the license.
|
||||
//-----------------------------------------------------------------------------
|
||||
// NFC Data Exchange Format (NDEF) functions
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef _NDEF_H_
|
||||
#define _NDEF_H_
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
|
||||
typedef enum {
|
||||
tnfEmptyRecord = 0x00,
|
||||
tnfWellKnownRecord = 0x01,
|
||||
tnfMIMEMediaRecord = 0x02,
|
||||
tnfAbsoluteURIRecord = 0x03,
|
||||
tnfExternalRecord = 0x04,
|
||||
tnfUnknownRecord = 0x05,
|
||||
tnfUnchangedRecord = 0x06
|
||||
} TypeNameFormat_t;
|
||||
|
||||
typedef enum {
|
||||
stNotPresent = 0x00,
|
||||
stRSASSA_PSS_SHA_1 = 0x01,
|
||||
stRSASSA_PKCS1_v1_5_WITH_SHA_1 = 0x02,
|
||||
stDSA = 0x03,
|
||||
stECDSA = 0x04,
|
||||
stNA = 0x05
|
||||
} ndefSigType_t;
|
||||
|
||||
typedef enum {
|
||||
sfX_509 = 0x00,
|
||||
sfX9_68 = 0x01,
|
||||
sfNA = 0x02
|
||||
} ndefCertificateFormat_t;
|
||||
|
||||
typedef struct {
|
||||
bool MessageBegin;
|
||||
bool MessageEnd;
|
||||
bool ChunkFlag;
|
||||
bool ShortRecordBit;
|
||||
bool IDLenPresent;
|
||||
TypeNameFormat_t TypeNameFormat;
|
||||
size_t TypeLen;
|
||||
size_t PayloadLen;
|
||||
size_t IDLen;
|
||||
size_t len;
|
||||
size_t RecLen;
|
||||
uint8_t *Type;
|
||||
uint8_t *Payload;
|
||||
uint8_t *ID;
|
||||
} NDEFHeader_t;
|
||||
|
||||
extern int NDEFDecodeAndPrint(uint8_t *ndef, size_t ndefLen, bool verbose);
|
||||
|
||||
#endif // _NDEF_H_
|
||||
Loading…
Add table
Add a link
Reference in a new issue