mirror of
https://github.com/Proxmark/proxmark3.git
synced 2025-08-20 05:13:22 -07:00
add mad and ndef
This commit is contained in:
merlokk
parent
bda1a01c86
commit
dad556d90c
4 changed files with 704 additions and 0 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_
|
||||
357
client/mifare/ndef.c
Normal file
357
client/mifare/ndef.c
Normal file
|
|
@ -0,0 +1,357 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// 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"
|
||||
|
||||
#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