feat(desfire): add DFC credential interoperability
Add bidirectional conversion between DFC v4 credentials and mfdes v1 JSON, with documentation and round-trip coverage. Include H10301 FC69 CN420 factory and field fixtures and an external HID reader test target. Co-Authored-By: GPT-Daybreak Blue <noreply@openai.com>
This commit is contained in:
1 parent
957896a926
commit
8ed285af90
7 files changed
+625
-3
No files matched your search
@@ -13,6 +13,7 @@ built on.
|
||||
- [MIFARE DESFire dump file format](#mifare-desfire-dump-file-format)
|
||||
- [Table of Contents](#table-of-contents)
|
||||
- [Commands](#commands)
|
||||
- [DFC compatibility](#dfc-compatibility)
|
||||
- [File identity](#file-identity)
|
||||
- [Card level](#card-level)
|
||||
- [Applications](#applications)
|
||||
@@ -53,6 +54,23 @@ With no `--aid` / `--isoid` / `--dfname` the command walks every application the
|
||||
PICC lists. The default filename is `hf-mfdes-<UID>-dump.json`; only json is
|
||||
written, there is no `.bin` companion.
|
||||
|
||||
## DFC compatibility
|
||||
^[Top](#top)
|
||||
|
||||
`tools/dfc_converter.py` converts between this JSON format and DFC v4 text
|
||||
credentials. DFC is used by the DESFire Compatible app for Flipper Zero and
|
||||
Chameleon Ultra, so the converter moves supported card images between those
|
||||
devices and Proxmark3.
|
||||
|
||||
```text
|
||||
python3 tools/dfc_converter.py credential.dfc credential.json
|
||||
python3 tools/dfc_converter.py credential.json credential.dfc
|
||||
```
|
||||
|
||||
The file extensions select the direction. The converter refuses features that
|
||||
the destination cannot represent instead of silently discarding them. DFC
|
||||
binary `.dfcb` files are not supported.
|
||||
|
||||
## File identity
|
||||
^[Top](#top)
|
||||
|
||||
|
||||
Executable
+459
@@ -0,0 +1,459 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Convert DESFire credentials between DFC v4 and Proxmark3 mfdes v1 JSON.
|
||||
|
||||
DFC is the interchange format used by the DESFire Compatible app for Flipper
|
||||
Zero and Chameleon Ultra. Proxmark3 loads the JSON result with `hf mfdes eload`.
|
||||
Only features represented by both formats are converted.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import pathlib
|
||||
import re
|
||||
import sys
|
||||
|
||||
|
||||
class ConversionError(ValueError):
|
||||
"""Input cannot be represented in the destination format."""
|
||||
|
||||
|
||||
FILE_TYPES = {
|
||||
"Standard Data": (0, "standard"),
|
||||
"Backup Data": (1, "backup"),
|
||||
"Value": (2, "value"),
|
||||
"Linear Record": (3, "linear_record"),
|
||||
"Cyclic Record": (4, "cyclic_record"),
|
||||
}
|
||||
FILE_TYPES_BY_RAW = {raw: (name, token) for name, (raw, token) in FILE_TYPES.items()}
|
||||
COMM_BY_RAW = {0: "plain", 1: "mac", 2: "plain_rfu", 3: "encrypt"}
|
||||
COMM_BY_TOKEN = {token: raw for raw, token in COMM_BY_RAW.items()}
|
||||
STORAGE_CODES = {2048: 0x16, 4096: 0x18, 8192: 0x1A}
|
||||
GENERATION_VERSION = {
|
||||
"EV1": (0x01, 0x00, 0x01, 0x04),
|
||||
"EV2": (0x12, 0x00, 0x02, 0x00),
|
||||
"EV3": (0x33, 0x00, 0x03, 0x00),
|
||||
}
|
||||
MAJOR_GENERATION = {0x01: "EV1", 0x12: "EV2", 0x42: "EV2", 0x22: "EV2", 0x33: "EV3"}
|
||||
KEY_LENGTHS = {"des": 8, "2tdea": 16, "3tdea": 24, "aes": 16}
|
||||
HEX_RE = re.compile(r"(?:[0-9A-F]{2})(?: [0-9A-F]{2})*")
|
||||
|
||||
|
||||
def compact_hex(value, field, lengths=None):
|
||||
if not isinstance(value, str):
|
||||
raise ConversionError(f"{field}: expected a hexadecimal string")
|
||||
compact = value.replace(" ", "").upper()
|
||||
if not compact or len(compact) % 2 or re.fullmatch(r"[0-9A-F]+", compact) is None:
|
||||
raise ConversionError(f"{field}: invalid hexadecimal octets")
|
||||
if lengths is not None and len(compact) // 2 not in lengths:
|
||||
expected = " or ".join(str(n) for n in lengths)
|
||||
raise ConversionError(f"{field}: expected {expected} octets")
|
||||
return compact
|
||||
|
||||
|
||||
def spaced_hex(value, field, lengths=None):
|
||||
compact = compact_hex(value, field, lengths)
|
||||
return " ".join(compact[i:i + 2] for i in range(0, len(compact), 2))
|
||||
|
||||
|
||||
def parse_integer(value, field, minimum=None, maximum=None):
|
||||
try:
|
||||
number = int(value) if isinstance(value, int) else int(value, 10)
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise ConversionError(f"{field}: expected a decimal integer") from exc
|
||||
if minimum is not None and number < minimum:
|
||||
raise ConversionError(f"{field}: value is below {minimum}")
|
||||
if maximum is not None and number > maximum:
|
||||
raise ConversionError(f"{field}: value is above {maximum}")
|
||||
return number
|
||||
|
||||
|
||||
def parse_dfc_fields(text):
|
||||
fields = {}
|
||||
order = []
|
||||
for line_number, raw in enumerate(text.splitlines(), 1):
|
||||
if not raw or raw.startswith("#"):
|
||||
continue
|
||||
if raw.endswith(" ") or ": " not in raw:
|
||||
raise ConversionError(f"line {line_number}: expected 'Key: Value'")
|
||||
key, value = raw.split(": ", 1)
|
||||
if not key or key.strip() != key or not value:
|
||||
raise ConversionError(f"line {line_number}: malformed field")
|
||||
if key in fields:
|
||||
raise ConversionError(f"line {line_number}: duplicate field {key!r}")
|
||||
fields[key] = value
|
||||
order.append(key)
|
||||
if order[:2] != ["Filetype", "Version"]:
|
||||
raise ConversionError("Filetype and Version must be the first two fields")
|
||||
return fields
|
||||
|
||||
|
||||
class DfcReader:
|
||||
def __init__(self, text):
|
||||
self.fields = parse_dfc_fields(text)
|
||||
|
||||
def take(self, name, required=True):
|
||||
value = self.fields.pop(name, None)
|
||||
if value is None and required:
|
||||
raise ConversionError(f"missing required field {name!r}")
|
||||
return value
|
||||
|
||||
def integer(self, name, minimum=None, maximum=None, required=True):
|
||||
value = self.take(name, required)
|
||||
if value is None:
|
||||
return None
|
||||
return parse_integer(value, name, minimum, maximum)
|
||||
|
||||
def hexa(self, name, lengths=None, required=True):
|
||||
value = self.take(name, required)
|
||||
if value is None:
|
||||
return None
|
||||
if HEX_RE.fullmatch(value) is None:
|
||||
raise ConversionError(f"{name}: expected uppercase hexadecimal octets")
|
||||
return compact_hex(value, name, lengths)
|
||||
|
||||
def token(self, name, allowed):
|
||||
value = self.take(name)
|
||||
if value not in allowed:
|
||||
raise ConversionError(f"{name}: unsupported value {value!r}")
|
||||
return value
|
||||
|
||||
def flag(self, name, required=True):
|
||||
value = self.take(name, required)
|
||||
if value is None:
|
||||
return None
|
||||
if value not in ("0", "1"):
|
||||
raise ConversionError(f"{name}: expected 0 or 1")
|
||||
return value == "1"
|
||||
|
||||
|
||||
def key_type(ks2, keys):
|
||||
keys = list(keys)
|
||||
selector = int(ks2, 16) & 0xC0
|
||||
if selector == 0x80:
|
||||
return "aes"
|
||||
if selector == 0x40:
|
||||
return "3tdea"
|
||||
if keys and len(keys[0]["Key"]) == 16:
|
||||
return "des"
|
||||
return "2tdea"
|
||||
|
||||
|
||||
def read_keys(reader, prefix, ks2):
|
||||
count = reader.integer(f"{prefix} Key Count", 0, 14)
|
||||
keys = {}
|
||||
expected_length = {0x40: 24, 0x80: 16}.get(int(ks2, 16) & 0xC0, 16)
|
||||
for index in range(count):
|
||||
name = f"{prefix} Key {index:02X}"
|
||||
keys[str(index)] = {
|
||||
"Key": reader.hexa(name, (expected_length,)),
|
||||
"Version": reader.hexa(f"{name} Version", (1,)),
|
||||
}
|
||||
return keys
|
||||
|
||||
|
||||
def read_files(reader, prefix):
|
||||
files = {}
|
||||
count = reader.integer(f"{prefix} File Count", 0, 32)
|
||||
for index in range(count):
|
||||
base = f"{prefix} File {index:02X}"
|
||||
number = reader.hexa(f"{base} Number", (1,))
|
||||
type_name = reader.token(f"{base} Type", set(FILE_TYPES))
|
||||
raw, token = FILE_TYPES[type_name]
|
||||
comm = reader.hexa(f"{base} Communication Settings", (1,))
|
||||
comm_value = int(comm, 16)
|
||||
if comm_value not in COMM_BY_RAW:
|
||||
raise ConversionError(f"{base} Communication Settings: unsupported value {comm}")
|
||||
item = {
|
||||
"Type": token,
|
||||
"TypeRaw": f"{raw:02X}",
|
||||
"CommMode": COMM_BY_RAW[comm_value],
|
||||
"AccessRights": reader.hexa(f"{base} Access Rights", (2,)),
|
||||
}
|
||||
iso_id = reader.hexa(f"{base} ISO File ID", (2,), required=False)
|
||||
if iso_id is not None:
|
||||
item["ISOFileID"] = iso_id
|
||||
if raw in (0, 1):
|
||||
item["FileSize"] = reader.integer(f"{base} Size", 1, 0xFFFFFF)
|
||||
data = reader.hexa(f"{base} Data", required=False)
|
||||
complete = reader.flag(f"{base} Data Complete")
|
||||
if complete and (data is None or len(data) // 2 != item["FileSize"]):
|
||||
raise ConversionError(f"{base}: complete data must match the file size")
|
||||
item["Read"] = data is not None
|
||||
if data is not None:
|
||||
if len(data) // 2 > item["FileSize"]:
|
||||
raise ConversionError(f"{base}: data is longer than the file")
|
||||
item["Data"] = data
|
||||
elif raw == 2:
|
||||
item["LowerLimit"] = reader.integer(f"{base} Value Lower Limit", -0x80000000, 0x7FFFFFFF)
|
||||
item["UpperLimit"] = reader.integer(f"{base} Value Upper Limit", -0x80000000, 0x7FFFFFFF)
|
||||
item["Value"] = reader.integer(f"{base} Value", item["LowerLimit"], item["UpperLimit"])
|
||||
item["LimitedCredit"] = reader.hexa(f"{base} Limited Credit", (1,))
|
||||
item["Read"] = True
|
||||
else:
|
||||
item["RecordSize"] = reader.integer(f"{base} Record Size", 1, 0xFFFFFF)
|
||||
item["MaxRecords"] = reader.integer(f"{base} Max Records", 1, 0xFFFFFF)
|
||||
item["CurRecords"] = reader.integer(f"{base} Record Count", 0, item["MaxRecords"])
|
||||
records = {}
|
||||
record_index = 0
|
||||
while f"{base} Record {record_index:02X}" in reader.fields:
|
||||
records[str(record_index)] = reader.hexa(
|
||||
f"{base} Record {record_index:02X}", (item["RecordSize"],)
|
||||
)
|
||||
record_index += 1
|
||||
complete = reader.flag(f"{base} Record Complete")
|
||||
if complete and len(records) != item["CurRecords"]:
|
||||
raise ConversionError(f"{base}: complete records must match Record Count")
|
||||
item["Read"] = complete
|
||||
item["Records"] = records
|
||||
files[number] = item
|
||||
return files
|
||||
|
||||
|
||||
def version_frames(generation, storage):
|
||||
if generation not in GENERATION_VERSION:
|
||||
raise ConversionError(f"Card Generation: {generation} is not representable")
|
||||
storage_code = STORAGE_CODES.get(storage)
|
||||
if storage_code is None:
|
||||
raise ConversionError(f"Card Storage: unsupported capacity {storage}")
|
||||
hw_major, hw_minor, sw_major, sw_minor = GENERATION_VERSION[generation]
|
||||
return (
|
||||
f"040101{hw_major:02X}{hw_minor:02X}{storage_code:02X}05",
|
||||
f"040101{sw_major:02X}{sw_minor:02X}{storage_code:02X}05",
|
||||
)
|
||||
|
||||
|
||||
def dfc_to_json(text):
|
||||
reader = DfcReader(text)
|
||||
if reader.take("Filetype") != "DFC Credential" or reader.take("Version") != "4":
|
||||
raise ConversionError("only DFC Credential version 4 is supported")
|
||||
generation = reader.token("Card Generation", set(GENERATION_VERSION))
|
||||
storage = reader.integer("Card Storage", 1)
|
||||
uid = reader.hexa("UID", (4, 7, 10))
|
||||
reader.token("UID Provenance", {"Real", "Random", "Unknown"})
|
||||
signature = reader.hexa("Card Static Signature", (56,), required=False)
|
||||
picc_ks1 = reader.hexa("PICC Key Settings 1", (1,))
|
||||
picc_ks2 = reader.hexa("PICC Key Settings 2", (1,))
|
||||
reader.token("PICC Authentication Mode", {"D40", "ISO", "AES"})
|
||||
picc_keys = read_keys(reader, "PICC", picc_ks2)
|
||||
|
||||
unsupported = (
|
||||
"PICC Random ID", "PICC Format Disabled", "PICC SM Disable",
|
||||
"PICC EV2 Card Capabilities", "PICC Proximity Key",
|
||||
"PICC Virtual Card Installation ID", "PICC DAM Authentication Key",
|
||||
)
|
||||
present = [name for name in unsupported if name in reader.fields]
|
||||
if present:
|
||||
raise ConversionError(f"{present[0]} has no mfdes v1 representation")
|
||||
ats = reader.hexa("PICC ATS", required=False) or "067577810280"
|
||||
sak = reader.hexa("PICC SAK", (1,), required=False) or "20"
|
||||
atqa = reader.hexa("PICC ATQA", (2,), required=False) or "4403"
|
||||
if reader.integer("PICC File Count", 0, 32) != 0:
|
||||
raise ConversionError("PICC-level files have no mfdes v1 representation")
|
||||
|
||||
applications = {
|
||||
"000000": {
|
||||
"KeySettings": picc_ks1,
|
||||
"NumKeysRaw": picc_ks2,
|
||||
"NumKeys": int(picc_ks2, 16) & 0x1F,
|
||||
"KeyType": key_type(picc_ks2, picc_keys.values()),
|
||||
"Authenticated": bool(picc_keys),
|
||||
"Keys": picc_keys,
|
||||
}
|
||||
}
|
||||
app_count = reader.integer("Application Count", 0, 255)
|
||||
for index in range(app_count):
|
||||
prefix = f"Application {index:02X}"
|
||||
aid = reader.hexa(f"{prefix} AID", (3,))
|
||||
iso_id = reader.hexa(f"{prefix} ISO File ID", (2,), required=False)
|
||||
df_name = reader.hexa(f"{prefix} DF Name", required=False)
|
||||
ks1 = reader.hexa(f"{prefix} Key Settings 1", (1,))
|
||||
ks2 = reader.hexa(f"{prefix} Key Settings 2", (1,))
|
||||
reader.token(f"{prefix} Authentication Mode", {"D40", "ISO", "AES"})
|
||||
if f"{prefix} Key Set Count" in reader.fields:
|
||||
raise ConversionError(f"{prefix}: key sets have no mfdes v1 representation")
|
||||
keys = read_keys(reader, prefix, ks2)
|
||||
app = {
|
||||
"KeySettings": ks1,
|
||||
"NumKeysRaw": ks2,
|
||||
"NumKeys": int(ks2, 16) & 0x1F,
|
||||
"KeyType": key_type(ks2, keys.values()),
|
||||
"Authenticated": bool(keys),
|
||||
"Keys": keys,
|
||||
"Files": read_files(reader, prefix),
|
||||
}
|
||||
if iso_id is not None:
|
||||
app["ISOFileID"] = iso_id
|
||||
if df_name is not None:
|
||||
app["DFName"] = df_name
|
||||
applications[aid] = app
|
||||
|
||||
if reader.fields:
|
||||
name = sorted(reader.fields)[0]
|
||||
raise ConversionError(f"{name}: unsupported DFC field")
|
||||
version_hw, version_sw = version_frames(generation, storage)
|
||||
card = {
|
||||
"UID": uid,
|
||||
"ATQA": atqa,
|
||||
"SAK": sak,
|
||||
"ATS": ats,
|
||||
"VersionHW": version_hw,
|
||||
"VersionSW": version_sw,
|
||||
"VersionProd": uid[:14].ljust(14, "0") + "00000000000124",
|
||||
}
|
||||
if signature is not None:
|
||||
card["Signature"] = signature
|
||||
return {
|
||||
"Created": "proxmark3 dfc_converter",
|
||||
"FileType": "mfdes v1",
|
||||
"Version": 1,
|
||||
"Card": card,
|
||||
"Applications": applications,
|
||||
}
|
||||
|
||||
|
||||
def append_keys(lines, prefix, app):
|
||||
keys = app.get("Keys", {})
|
||||
known = []
|
||||
for index in range(14):
|
||||
item = keys.get(str(index))
|
||||
if not item or "Key" not in item:
|
||||
break
|
||||
known.append(item)
|
||||
lines.append(f"{prefix} Key Count: {len(known)}")
|
||||
key_type_name = app.get("KeyType", "2tdea")
|
||||
if key_type_name not in KEY_LENGTHS:
|
||||
raise ConversionError(f"{prefix} KeyType: unsupported value {key_type_name!r}")
|
||||
for index, item in enumerate(known):
|
||||
name = f"{prefix} Key {index:02X}"
|
||||
lines.append(f"{name}: {spaced_hex(item['Key'], name, (KEY_LENGTHS[key_type_name],))}")
|
||||
version = item.get("Version", "00")
|
||||
lines.append(f"{name} Version: {spaced_hex(version, name + ' Version', (1,))}")
|
||||
|
||||
|
||||
def append_files(lines, prefix, app):
|
||||
files = app.get("Files", {})
|
||||
lines.append(f"{prefix} File Count: {len(files)}")
|
||||
for index, (number, item) in enumerate(sorted(files.items(), key=lambda pair: int(pair[0], 16))):
|
||||
base = f"{prefix} File {index:02X}"
|
||||
raw = int(compact_hex(item.get("TypeRaw", ""), base + " TypeRaw", (1,)), 16)
|
||||
if raw not in FILE_TYPES_BY_RAW:
|
||||
raise ConversionError(f"{base}: file type {raw:02X} has no DFC v4 representation")
|
||||
type_name, _ = FILE_TYPES_BY_RAW[raw]
|
||||
comm_token = item.get("CommMode")
|
||||
if comm_token not in COMM_BY_TOKEN:
|
||||
raise ConversionError(f"{base} CommMode: unsupported value {comm_token!r}")
|
||||
lines.extend([
|
||||
f"{base} Number: {spaced_hex(number, base + ' Number', (1,))}",
|
||||
f"{base} Type: {type_name}",
|
||||
f"{base} Communication Settings: {COMM_BY_TOKEN[comm_token]:02X}",
|
||||
f"{base} Access Rights: {spaced_hex(item['AccessRights'], base + ' Access Rights', (2,))}",
|
||||
])
|
||||
if "ISOFileID" in item:
|
||||
lines.append(f"{base} ISO File ID: {spaced_hex(item['ISOFileID'], base + ' ISO File ID', (2,))}")
|
||||
if raw in (0, 1):
|
||||
size = parse_integer(item.get("FileSize"), base + " FileSize", 1, 0xFFFFFF)
|
||||
lines.append(f"{base} Size: {size}")
|
||||
data = item.get("Data") if item.get("Read") else None
|
||||
if data is not None:
|
||||
lines.append(f"{base} Data: {spaced_hex(data, base + ' Data')}")
|
||||
complete = data is not None and len(compact_hex(data, base + " Data")) // 2 == size
|
||||
lines.append(f"{base} Data Complete: {int(complete)}")
|
||||
elif raw == 2:
|
||||
for field, label in (("LowerLimit", "Value Lower Limit"), ("UpperLimit", "Value Upper Limit"), ("Value", "Value")):
|
||||
lines.append(f"{base} {label}: {parse_integer(item.get(field), base + ' ' + field, -0x80000000, 0x7FFFFFFF)}")
|
||||
lines.append(f"{base} Limited Credit: {spaced_hex(item['LimitedCredit'], base + ' Limited Credit', (1,))}")
|
||||
else:
|
||||
record_size = parse_integer(item.get("RecordSize"), base + " RecordSize", 1, 0xFFFFFF)
|
||||
max_records = parse_integer(item.get("MaxRecords"), base + " MaxRecords", 1, 0xFFFFFF)
|
||||
cur_records = parse_integer(item.get("CurRecords"), base + " CurRecords", 0, max_records)
|
||||
lines.extend([f"{base} Record Size: {record_size}", f"{base} Max Records: {max_records}", f"{base} Record Count: {cur_records}"])
|
||||
records = item.get("Records", {})
|
||||
for record_index, record in sorted(records.items(), key=lambda pair: int(pair[0])):
|
||||
lines.append(f"{base} Record {int(record_index):02X}: {spaced_hex(record, base + ' Record', (record_size,))}")
|
||||
lines.append(f"{base} Record Complete: {int(bool(item.get('Read')) and len(records) == cur_records)}")
|
||||
|
||||
|
||||
def auth_mode(app):
|
||||
key_type_name = app.get("KeyType", "2tdea")
|
||||
if key_type_name == "aes":
|
||||
return "AES"
|
||||
ks2 = int(compact_hex(app.get("NumKeysRaw", "00"), "NumKeysRaw", (1,)), 16)
|
||||
return "ISO" if ks2 & 0x20 else "D40"
|
||||
|
||||
|
||||
def json_to_dfc(image):
|
||||
if image.get("FileType") != "mfdes v1" or image.get("Version") != 1:
|
||||
raise ConversionError("only Proxmark3 mfdes v1 JSON is supported")
|
||||
card = image.get("Card", {})
|
||||
uid = compact_hex(card.get("UID", ""), "Card.UID", (4, 7, 10))
|
||||
version_hw = compact_hex(card.get("VersionHW", ""), "Card.VersionHW", (7,))
|
||||
generation = MAJOR_GENERATION.get(int(version_hw[6:8], 16))
|
||||
if generation is None:
|
||||
raise ConversionError(f"Card.VersionHW: unsupported generation byte {version_hw[6:8]}")
|
||||
storage = 1 << (int(version_hw[10:12], 16) >> 1)
|
||||
applications = image.get("Applications", {})
|
||||
picc = applications.get("000000")
|
||||
if not isinstance(picc, dict):
|
||||
raise ConversionError("Applications.000000: PICC application is required")
|
||||
lines = [
|
||||
"Filetype: DFC Credential", "Version: 4", f"Card Generation: {generation}",
|
||||
f"Card Storage: {storage}", f"UID: {spaced_hex(uid, 'Card.UID')}", "UID Provenance: Real",
|
||||
]
|
||||
if "Signature" in card:
|
||||
lines.append(f"Card Static Signature: {spaced_hex(card['Signature'], 'Card.Signature', (56,))}")
|
||||
lines.extend([
|
||||
f"PICC Key Settings 1: {spaced_hex(picc['KeySettings'], 'PICC Key Settings 1', (1,))}",
|
||||
f"PICC Key Settings 2: {spaced_hex(picc['NumKeysRaw'], 'PICC Key Settings 2', (1,))}",
|
||||
f"PICC Authentication Mode: {auth_mode(picc)}",
|
||||
])
|
||||
append_keys(lines, "PICC", picc)
|
||||
for field, label, lengths in (("ATS", "PICC ATS", None), ("SAK", "PICC SAK", (1,)), ("ATQA", "PICC ATQA", (2,))):
|
||||
if field in card:
|
||||
lines.append(f"{label}: {spaced_hex(card[field], label, lengths)}")
|
||||
lines.append("PICC File Count: 0")
|
||||
app_items = [(aid, app) for aid, app in applications.items() if aid != "000000"]
|
||||
lines.append(f"Application Count: {len(app_items)}")
|
||||
for index, (aid, app) in enumerate(sorted(app_items)):
|
||||
prefix = f"Application {index:02X}"
|
||||
lines.append(f"{prefix} AID: {spaced_hex(aid, prefix + ' AID', (3,))}")
|
||||
if "ISOFileID" in app:
|
||||
lines.append(f"{prefix} ISO File ID: {spaced_hex(app['ISOFileID'], prefix + ' ISO File ID', (2,))}")
|
||||
if "DFName" in app:
|
||||
lines.append(f"{prefix} DF Name: {spaced_hex(app['DFName'], prefix + ' DF Name')}")
|
||||
lines.extend([
|
||||
f"{prefix} Key Settings 1: {spaced_hex(app['KeySettings'], prefix + ' Key Settings 1', (1,))}",
|
||||
f"{prefix} Key Settings 2: {spaced_hex(app['NumKeysRaw'], prefix + ' Key Settings 2', (1,))}",
|
||||
f"{prefix} Authentication Mode: {auth_mode(app)}",
|
||||
])
|
||||
append_keys(lines, prefix, app)
|
||||
append_files(lines, prefix, app)
|
||||
return "\n".join(lines) + "\n"
|
||||
|
||||
|
||||
def convert(source, destination):
|
||||
source_suffix = source.suffix.lower()
|
||||
destination_suffix = destination.suffix.lower()
|
||||
if source_suffix == ".dfc" and destination_suffix == ".json":
|
||||
image = dfc_to_json(source.read_text(encoding="ascii"))
|
||||
destination.write_text(json.dumps(image, indent=2) + "\n", encoding="utf-8")
|
||||
elif source_suffix == ".json" and destination_suffix == ".dfc":
|
||||
image = json.loads(source.read_text(encoding="utf-8"))
|
||||
destination.write_text(json_to_dfc(image), encoding="ascii")
|
||||
else:
|
||||
raise ConversionError("conversion must be .dfc to .json or .json to .dfc")
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("source", type=pathlib.Path, help="input .dfc or .json file")
|
||||
parser.add_argument("destination", type=pathlib.Path, help="output .json or .dfc file")
|
||||
args = parser.parse_args(argv)
|
||||
try:
|
||||
convert(args.source, args.destination)
|
||||
except (ConversionError, OSError, json.JSONDecodeError) as exc:
|
||||
parser.exit(1, f"dfc_converter: {exc}\n")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Executable
+40
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import json
|
||||
import pathlib
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
import dfc_converter
|
||||
|
||||
|
||||
ROOT = pathlib.Path(__file__).resolve().parent.parent
|
||||
FIXTURES = ROOT / "traces" / "desfire"
|
||||
|
||||
|
||||
class DfcConverterTest(unittest.TestCase):
|
||||
def test_credentials_round_trip(self):
|
||||
for name in ("H10301-FC69-CN420-factory", "H10301-FC69-CN420-field"):
|
||||
with self.subTest(name=name), tempfile.TemporaryDirectory() as directory:
|
||||
source = FIXTURES / f"{name}.dfc"
|
||||
first_json = pathlib.Path(directory) / "first.json"
|
||||
second_dfc = pathlib.Path(directory) / "second.dfc"
|
||||
second_json = pathlib.Path(directory) / "second.json"
|
||||
dfc_converter.convert(source, first_json)
|
||||
dfc_converter.convert(first_json, second_dfc)
|
||||
dfc_converter.convert(second_dfc, second_json)
|
||||
self.assertEqual(
|
||||
json.loads(first_json.read_text()),
|
||||
json.loads(second_json.read_text()),
|
||||
)
|
||||
|
||||
def test_rejects_direction_without_known_extensions(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
path = pathlib.Path(directory) / "credential.txt"
|
||||
path.write_text("not a credential")
|
||||
with self.assertRaisesRegex(dfc_converter.ConversionError, "must be"):
|
||||
dfc_converter.convert(path, path.with_suffix(".json"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -9,6 +9,7 @@ cd "$PM3PATH" || exit 1
|
||||
|
||||
TESTALL=false
|
||||
TESTDESFIREVALUE=false
|
||||
TESTDESFIREREADER=false
|
||||
TESTHIDWIEGAND=false
|
||||
TESTMFHIDENCODE=false
|
||||
TESTICLASSREADER=false
|
||||
@@ -24,11 +25,12 @@ while (( "$#" )); do
|
||||
case "$1" in
|
||||
-h|--help)
|
||||
echo """
|
||||
Usage: $0 [--pm3bin /path/to/pm3] [--pm3port /dev/tty...] [desfire_value|hid_wiegand|mf_hid_encode|iclass_emu|iclass_reader|hitag2]
|
||||
Usage: $0 [--pm3bin /path/to/pm3] [--pm3port /dev/tty...] [desfire_value|desfire_reader|hid_wiegand|mf_hid_encode|iclass_emu|iclass_reader|hitag2]
|
||||
--pm3bin ...: Specify path to pm3 binary to test
|
||||
--pm3port ...: Specify serial port for client/proxmark3
|
||||
--manual ...: Pause after successful online LF HID clone/read checks for external reader verification
|
||||
desfire_value: Test DESFire value operations with card
|
||||
desfire_reader: Load DESFire HID credentials for external reader verification
|
||||
hid_wiegand: Test LF HID T55xx clone and PM3 readback flows
|
||||
mf_hid_encode: Test MIFARE Classic HID encoding flows
|
||||
iclass_emu: Test iCLASS emulator memory load/write/read flows
|
||||
@@ -66,6 +68,11 @@ Usage: $0 [--pm3bin /path/to/pm3] [--pm3port /dev/tty...] [desfire_value|hid_wie
|
||||
TESTDESFIREVALUE=true
|
||||
shift
|
||||
;;
|
||||
desfire_reader)
|
||||
TESTALL=false
|
||||
TESTDESFIREREADER=true
|
||||
shift
|
||||
;;
|
||||
hid_wiegand)
|
||||
TESTALL=false
|
||||
TESTHIDWIEGAND=true
|
||||
@@ -257,6 +264,13 @@ function CleanupMfHidEncodeCard() {
|
||||
fi
|
||||
}
|
||||
|
||||
function CleanupOnlineTests() {
|
||||
CleanupMfHidEncodeCard
|
||||
if [ -n "${DFC_FACTORY_JSON:-}" ] || [ -n "${DFC_FIELD_JSON:-}" ]; then
|
||||
rm -f "${DFC_FACTORY_JSON:-/tmp/pm3-no-dfc-factory}" "${DFC_FIELD_JSON:-/tmp/pm3-no-dfc-field}"
|
||||
fi
|
||||
}
|
||||
|
||||
function CheckMfHidEncodeRoundTrip() {
|
||||
printf "%-40s" "$1 "
|
||||
|
||||
@@ -381,7 +395,7 @@ function WaitForEnter() {
|
||||
fi
|
||||
}
|
||||
|
||||
trap CleanupMfHidEncodeCard EXIT
|
||||
trap CleanupOnlineTests EXIT
|
||||
|
||||
echo -e "${C_BLUE}Iceman Proxmark3 online test tool${C_NC}"
|
||||
echo ""
|
||||
@@ -396,7 +410,7 @@ if command -v git >/dev/null && git rev-parse --is-inside-work-tree >/dev/null 2
|
||||
fi
|
||||
|
||||
# Check that user specified a test
|
||||
if [ "$TESTDESFIREVALUE" = false ] && [ "$TESTHIDWIEGAND" = false ] && [ "$TESTMFHIDENCODE" = false ] && [ "$TESTICLASSEMU" = false ] && [ "$TESTICLASSREADER" = false ] && [ "$TESTSMARTCARD" = false ] && [ "$TESTHITAG2" = false ]; then
|
||||
if [ "$TESTDESFIREVALUE" = false ] && [ "$TESTDESFIREREADER" = false ] && [ "$TESTHIDWIEGAND" = false ] && [ "$TESTMFHIDENCODE" = false ] && [ "$TESTICLASSEMU" = false ] && [ "$TESTICLASSREADER" = false ] && [ "$TESTSMARTCARD" = false ] && [ "$TESTHITAG2" = false ]; then
|
||||
echo "Error: You must specify a test target. Use -h for help."
|
||||
exit 1
|
||||
fi
|
||||
@@ -569,6 +583,27 @@ while true; do
|
||||
if ! CheckExecute "hf iclass sim preserves emu" "$PM3CMD -c 'hf iclass eview -s 80' 2>&1 | LC_ALL=C tr -cd '\11\12\15\40-\176' | tr '\n' ' '" "0/0x00.*BD 0C 60 10 F7 FF 12 E0.*6/0x06.*03 03 03 03 00 03 E0 17.*7/0x07.*10 A1 45 91 9E D1 6F 50"; then break; fi
|
||||
fi
|
||||
|
||||
if $TESTDESFIREREADER; then
|
||||
echo -e "\n${C_BLUE}Testing DESFire reader verification${C_NC} ${PM3BIN:=./pm3}"
|
||||
if ! CheckFileExist "pm3 exists" "$PM3BIN"; then break; fi
|
||||
PM3CMD="$PM3BIN"
|
||||
if [ -n "${PM3PORT:-}" ]; then
|
||||
echo "Using PM3 port: $PM3PORT"
|
||||
PM3CMD="$PM3CMD -p $PM3PORT"
|
||||
fi
|
||||
|
||||
DFC_FACTORY_JSON="/tmp/pm3-dfc-factory-$$.json"
|
||||
DFC_FIELD_JSON="/tmp/pm3-dfc-field-$$.json"
|
||||
if ! CheckExecute "convert factory DFC" "python3 tools/dfc_converter.py traces/desfire/H10301-FC69-CN420-factory.dfc $DFC_FACTORY_JSON && echo converted" "converted"; then break; fi
|
||||
if ! CheckExecute "convert field DFC" "python3 tools/dfc_converter.py traces/desfire/H10301-FC69-CN420-field.dfc $DFC_FIELD_JSON && echo converted" "converted"; then break; fi
|
||||
|
||||
WaitForEnter "PRESS ENTER TO START DESFIRE FACTORY SIM, PRESENT THE PM3 TO THE HID READER, CONFIRM: H10301 FC 69 CN 420, THEN PRESS THE PM3 BUTTON TO STOP SIM"
|
||||
if ! CheckExecute "hf mfdes factory to reader" "$PM3CMD -c 'hf mfdes eload -f $DFC_FACTORY_JSON; hf mfdes sim' 2>&1" "Done!"; then break; fi
|
||||
WaitForEnter "PRESS ENTER TO START DESFIRE FIELD SIM, PRESENT THE PM3 TO THE HID READER, CONFIRM: H10301 FC 69 CN 420, THEN PRESS THE PM3 BUTTON TO STOP SIM"
|
||||
if ! CheckExecute "hf mfdes field to reader" "$PM3CMD -c 'hf mfdes eload -f $DFC_FIELD_JSON; hf mfdes sim' 2>&1" "Done!"; then break; fi
|
||||
rm -f "$DFC_FACTORY_JSON" "$DFC_FIELD_JSON"
|
||||
fi
|
||||
|
||||
# SIM module / ISO 7816 contact card tests.
|
||||
#
|
||||
# Card agnostic: asserts that answers come back and are stable, never what
|
||||
|
||||
@@ -297,6 +297,7 @@ while true; do
|
||||
if ! CheckExecute "xorcheck test" "$PYTHON tools/xorcheck.py 04 00 80 64 ba" "final LRC XOR byte value: 5A"; then break; fi
|
||||
if ! CheckExecute "findbits test" "$PYTHON tools/findbits.py 73 0110010101110011" "Match at bit 9: 011001010"; then break; fi
|
||||
if ! CheckExecute "findbits_test test" "$PYTHON tools/findbits_test.py 2>&1" "OK"; then break; fi
|
||||
if ! CheckExecute "dfc_converter test" "$PYTHON tools/dfc_converter_test.py 2>&1" "OK"; then break; fi
|
||||
if ! CheckExecute "pm3_eml_mfd test" "$PYTHON tools/mfc/pm3_eml_mfd_test.py 2>&1" "OK"; then break; fi
|
||||
if ! CheckExecute "recover_pk test" "$PYTHON tools/recover_pk.py selftests 2>&1" "Tests:.*\(.*ok.*"; then break; fi
|
||||
if ! CheckExecute "mkversion create test" "tools/mkversion.sh --short" 'Iceman/'; then break; fi
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
Filetype: DFC Credential
|
||||
Version: 4
|
||||
Card Generation: EV1
|
||||
Card Storage: 4096
|
||||
UID: 04 E9 34 D9 3D 30 9F
|
||||
UID Provenance: Real
|
||||
PICC Key Settings 1: 0F
|
||||
PICC Key Settings 2: 01
|
||||
PICC Authentication Mode: D40
|
||||
PICC Key Count: 0
|
||||
PICC File Count: 0
|
||||
Application Count: 1
|
||||
Application 00 AID: 53 49 4F
|
||||
Application 00 Key Settings 1: 0B
|
||||
Application 00 Key Settings 2: 04
|
||||
Application 00 Authentication Mode: D40
|
||||
Application 00 Key Count: 4
|
||||
Application 00 Key 00: FE 2C 2A DA 64 0E EC 3C 7A 62 A4 48 44 80 AA B2
|
||||
Application 00 Key 00 Version: 00
|
||||
Application 00 Key 01: B8 B0 D2 EA B8 28 0A 90 0E B6 1A 7A 54 B4 C2 72
|
||||
Application 00 Key 01 Version: 00
|
||||
Application 00 Key 02: CE A8 EE 9E 50 76 58 26 0C F0 F0 F0 D2 F0 18 96
|
||||
Application 00 Key 02 Version: 00
|
||||
Application 00 Key 03: 2E E8 6A 56 7A 72 DE 14 34 5A F4 82 C8 E6 BA 48
|
||||
Application 00 Key 03 Version: 00
|
||||
Application 00 File Count: 1
|
||||
Application 00 File 00 Number: 0F
|
||||
Application 00 File 00 Type: Standard Data
|
||||
Application 00 File 00 Communication Settings: 01
|
||||
Application 00 File 00 Access Rights: 12 30
|
||||
Application 00 File 00 Size: 54
|
||||
Application 00 File 00 Data: 30 32 81 05 01 EB F9 ED 0A A5 02 05 00 A6 08 81 01 01 04 03 03 00 09 A7 17 85 15 DC 64 60 30 AA D9 D7 95 02 9B 15 DD FD 87 C3 A1 28 15 71 4F C4 A9 02 05 00 05 00
|
||||
Application 00 File 00 Data Complete: 1
|
||||
@@ -0,0 +1,36 @@
|
||||
Filetype: DFC Credential
|
||||
Version: 4
|
||||
Card Generation: EV1
|
||||
Card Storage: 4096
|
||||
UID: 04 A5 AB 54 92 61 76
|
||||
UID Provenance: Real
|
||||
PICC Key Settings 1: 0F
|
||||
PICC Key Settings 2: 01
|
||||
PICC Authentication Mode: D40
|
||||
PICC Key Count: 0
|
||||
PICC File Count: 0
|
||||
Application Count: 1
|
||||
Application 00 AID: D3 49 4F
|
||||
Application 00 ISO File ID: E1 10
|
||||
Application 00 DF Name: D2 76 00 00 85 01 00
|
||||
Application 00 Key Settings 1: 0B
|
||||
Application 00 Key Settings 2: 24
|
||||
Application 00 Authentication Mode: ISO
|
||||
Application 00 Key Count: 4
|
||||
Application 00 Key 00: 24 B8 9A 7E 0E 7E 32 E2 C2 46 80 10 F0 5E 42 C4
|
||||
Application 00 Key 00 Version: 00
|
||||
Application 00 Key 01: CA FC 2E 94 64 88 14 64 26 CE F0 FC 18 9C E6 86
|
||||
Application 00 Key 01 Version: 00
|
||||
Application 00 Key 02: B8 3C C2 D2 2C 66 F6 A8 0C 3C F2 12 02 A2 F4 90
|
||||
Application 00 Key 02 Version: 00
|
||||
Application 00 Key 03: C8 7E 76 D4 CC 98 70 1C A6 FA 52 F4 FC A6 EA C8
|
||||
Application 00 Key 03 Version: 00
|
||||
Application 00 File Count: 1
|
||||
Application 00 File 00 Number: 0F
|
||||
Application 00 File 00 Type: Standard Data
|
||||
Application 00 File 00 Communication Settings: 01
|
||||
Application 00 File 00 Access Rights: 12 30
|
||||
Application 00 File 00 ISO File ID: 00 0F
|
||||
Application 00 File 00 Size: 54
|
||||
Application 00 File 00 Data: 30 32 81 05 01 AD ED B0 6D A5 02 05 00 A6 08 81 01 01 04 03 03 00 09 A7 17 85 15 1E 74 05 5E 18 0E ED 17 A9 2D C4 D9 C7 6C C5 25 E1 9A F3 40 FF A9 02 05 00 05 00
|
||||
Application 00 File 00 Data Complete: 1
|
||||
Reference in new issue
Block a user