mirror of
https://github.com/RfidResearchGroup/ChameleonUltra.git
synced 2026-03-29 15:10:08 +00:00
651 lines
18 KiB
Python
651 lines
18 KiB
Python
import enum
|
|
|
|
|
|
@enum.unique
|
|
class Command(enum.IntEnum):
|
|
GET_APP_VERSION = 1000
|
|
CHANGE_DEVICE_MODE = 1001
|
|
GET_DEVICE_MODE = 1002
|
|
SET_ACTIVE_SLOT = 1003
|
|
SET_SLOT_TAG_TYPE = 1004
|
|
SET_SLOT_DATA_DEFAULT = 1005
|
|
SET_SLOT_ENABLE = 1006
|
|
|
|
SET_SLOT_TAG_NICK = 1007
|
|
GET_SLOT_TAG_NICK = 1008
|
|
GET_ALL_SLOT_NICKS = 1038
|
|
|
|
SLOT_DATA_CONFIG_SAVE = 1009
|
|
|
|
ENTER_BOOTLOADER = 1010
|
|
GET_DEVICE_CHIP_ID = 1011
|
|
GET_DEVICE_ADDRESS = 1012
|
|
|
|
SAVE_SETTINGS = 1013
|
|
RESET_SETTINGS = 1014
|
|
SET_ANIMATION_MODE = 1015
|
|
GET_ANIMATION_MODE = 1016
|
|
|
|
GET_GIT_VERSION = 1017
|
|
|
|
GET_ACTIVE_SLOT = 1018
|
|
GET_SLOT_INFO = 1019
|
|
|
|
WIPE_FDS = 1020
|
|
|
|
DELETE_SLOT_TAG_NICK = 1021
|
|
|
|
GET_ENABLED_SLOTS = 1023
|
|
DELETE_SLOT_SENSE_TYPE = 1024
|
|
|
|
GET_BATTERY_INFO = 1025
|
|
|
|
GET_BUTTON_PRESS_CONFIG = 1026
|
|
SET_BUTTON_PRESS_CONFIG = 1027
|
|
|
|
GET_LONG_BUTTON_PRESS_CONFIG = 1028
|
|
SET_LONG_BUTTON_PRESS_CONFIG = 1029
|
|
|
|
SET_BLE_PAIRING_KEY = 1030
|
|
GET_BLE_PAIRING_KEY = 1031
|
|
DELETE_ALL_BLE_BONDS = 1032
|
|
|
|
GET_DEVICE_MODEL = 1033
|
|
# FIXME: implemented but unused in CLI commands
|
|
GET_DEVICE_SETTINGS = 1034
|
|
GET_DEVICE_CAPABILITIES = 1035
|
|
GET_BLE_PAIRING_ENABLE = 1036
|
|
SET_BLE_PAIRING_ENABLE = 1037
|
|
|
|
HF14A_SCAN = 2000
|
|
MF1_DETECT_SUPPORT = 2001
|
|
MF1_DETECT_PRNG = 2002
|
|
MF1_STATIC_NESTED_ACQUIRE = 2003
|
|
MF1_DARKSIDE_ACQUIRE = 2004
|
|
MF1_DETECT_NT_DIST = 2005
|
|
MF1_NESTED_ACQUIRE = 2006
|
|
MF1_AUTH_ONE_KEY_BLOCK = 2007
|
|
MF1_READ_ONE_BLOCK = 2008
|
|
MF1_WRITE_ONE_BLOCK = 2009
|
|
HF14A_RAW = 2010
|
|
MF1_MANIPULATE_VALUE_BLOCK = 2011
|
|
MF1_CHECK_KEYS_OF_SECTORS = 2012
|
|
MF1_HARDNESTED_ACQUIRE = 2013
|
|
MF1_ENC_NESTED_ACQUIRE = 2014
|
|
MF1_CHECK_KEYS_ON_BLOCK = 2015
|
|
HF14A_GET_CONFIG = 2200
|
|
HF14A_SET_CONFIG = 2201
|
|
|
|
EM410X_SCAN = 3000
|
|
EM410X_WRITE_TO_T55XX = 3001
|
|
EM410X_ELECTRA_WRITE_TO_T55XX = 3006
|
|
HIDPROX_SCAN = 3002
|
|
HIDPROX_WRITE_TO_T55XX = 3003
|
|
VIKING_SCAN = 3004
|
|
VIKING_WRITE_TO_T55XX = 3005
|
|
ADC_GENERIC_READ = 3009
|
|
IOPROX_SCAN = 3010
|
|
IOPROX_WRITE_TO_T55XX = 3011
|
|
IOPROX_DECODE_RAW = 3012
|
|
IOPROX_COMPOSE_ID = 3013
|
|
|
|
MF1_WRITE_EMU_BLOCK_DATA = 4000
|
|
HF14A_SET_ANTI_COLL_DATA = 4001
|
|
MF1_SET_DETECTION_ENABLE = 4004
|
|
MF1_GET_DETECTION_COUNT = 4005
|
|
MF1_GET_DETECTION_LOG = 4006
|
|
# FIXME: not implemented
|
|
MF1_GET_DETECTION_ENABLE = 4007
|
|
MF1_READ_EMU_BLOCK_DATA = 4008
|
|
MF1_GET_EMULATOR_CONFIG = 4009
|
|
# FIXME: not implemented
|
|
MF1_GET_GEN1A_MODE = 4010
|
|
MF1_SET_GEN1A_MODE = 4011
|
|
# FIXME: not implemented
|
|
MF1_GET_GEN2_MODE = 4012
|
|
MF1_SET_GEN2_MODE = 4013
|
|
# FIXME: not implemented
|
|
MF1_GET_BLOCK_ANTI_COLL_MODE = 4014
|
|
MF1_SET_BLOCK_ANTI_COLL_MODE = 4015
|
|
# FIXME: not implemented
|
|
MF1_GET_WRITE_MODE = 4016
|
|
MF1_SET_WRITE_MODE = 4017
|
|
HF14A_GET_ANTI_COLL_DATA = 4018
|
|
MF0_NTAG_GET_UID_MAGIC_MODE = 4019
|
|
MF0_NTAG_SET_UID_MAGIC_MODE = 4020
|
|
MF0_NTAG_READ_EMU_PAGE_DATA = 4021
|
|
MF0_NTAG_WRITE_EMU_PAGE_DATA = 4022
|
|
MF0_NTAG_GET_VERSION_DATA = 4023
|
|
MF0_NTAG_SET_VERSION_DATA = 4024
|
|
MF0_NTAG_GET_SIGNATURE_DATA = 4025
|
|
MF0_NTAG_SET_SIGNATURE_DATA = 4026
|
|
MF0_NTAG_GET_COUNTER_DATA = 4027
|
|
MF0_NTAG_SET_COUNTER_DATA = 4028
|
|
MF0_NTAG_RESET_AUTH_CNT = 4029
|
|
MF0_NTAG_GET_PAGE_COUNT = 4030
|
|
MF0_NTAG_GET_WRITE_MODE = 4031
|
|
MF0_NTAG_SET_WRITE_MODE = 4032
|
|
MF0_NTAG_SET_DETECTION_ENABLE = 4033
|
|
MF0_NTAG_GET_DETECTION_COUNT = 4034
|
|
MF0_NTAG_GET_DETECTION_LOG = 4035
|
|
MF0_NTAG_GET_DETECTION_ENABLE = 4036
|
|
# FIXME: not implemented
|
|
MF0_NTAG_GET_EMULATOR_CONFIG = 4037
|
|
|
|
MF1_SET_FIELD_OFF_DO_RESET = 4038
|
|
MF1_GET_FIELD_OFF_DO_RESET = 4039
|
|
|
|
EM410X_SET_EMU_ID = 5000
|
|
EM410X_GET_EMU_ID = 5001
|
|
HIDPROX_SET_EMU_ID = 5002
|
|
HIDPROX_GET_EMU_ID = 5003
|
|
VIKING_SET_EMU_ID = 5004
|
|
VIKING_GET_EMU_ID = 5005
|
|
IOPROX_SET_EMU_ID = 5008
|
|
IOPROX_GET_EMU_ID = 5009
|
|
|
|
|
|
@enum.unique
|
|
class Status(enum.IntEnum):
|
|
HF_TAG_OK = 0x00 # IC card operation is successful
|
|
HF_TAG_NO = 0x01 # IC card not found
|
|
HF_ERR_STAT = 0x02 # Abnormal IC card communication
|
|
HF_ERR_CRC = 0x03 # IC card communication verification abnormal
|
|
HF_COLLISION = 0x04 # IC card conflict
|
|
HF_ERR_BCC = 0x05 # IC card BCC error
|
|
MF_ERR_AUTH = 0x06 # MF card verification failed
|
|
HF_ERR_PARITY = 0x07 # IC card parity error
|
|
HF_ERR_ATS = 0x08 # ATS should be present but card NAKed, or ATS too large
|
|
|
|
# Some operations with low frequency cards succeeded!
|
|
LF_TAG_OK = 0x40
|
|
# Unable to search for a valid EM410X tag
|
|
LF_TAG_NO_FOUND = 0x41
|
|
|
|
# The parameters passed by the BLE instruction are wrong, or the parameters passed
|
|
# by calling some functions are wrong
|
|
PAR_ERR = 0x60
|
|
# The mode of the current device is wrong, and the corresponding API cannot be called
|
|
DEVICE_MODE_ERROR = 0x66
|
|
INVALID_CMD = 0x67
|
|
SUCCESS = 0x68
|
|
NOT_IMPLEMENTED = 0x69
|
|
FLASH_WRITE_FAIL = 0x70
|
|
FLASH_READ_FAIL = 0x71
|
|
INVALID_SLOT_TYPE = 0x72
|
|
|
|
def __str__(self):
|
|
if self == Status.HF_TAG_OK:
|
|
return "HF tag operation succeeded"
|
|
elif self == Status.HF_TAG_NO:
|
|
return "HF tag no found or lost"
|
|
elif self == Status.HF_ERR_STAT:
|
|
return "HF tag status error"
|
|
elif self == Status.HF_ERR_CRC:
|
|
return "HF tag data crc error"
|
|
elif self == Status.HF_COLLISION:
|
|
return "HF tag collision"
|
|
elif self == Status.HF_ERR_BCC:
|
|
return "HF tag uid bcc error"
|
|
elif self == Status.MF_ERR_AUTH:
|
|
return "HF tag auth fail"
|
|
elif self == Status.HF_ERR_PARITY:
|
|
return "HF tag data parity error"
|
|
elif self == Status.HF_ERR_ATS:
|
|
return "HF tag was supposed to send ATS but didn't"
|
|
elif self == Status.LF_TAG_OK:
|
|
return "LF tag operation succeeded"
|
|
elif self == Status.LF_TAG_NO_FOUND:
|
|
return "LF tag not found"
|
|
elif self == Status.PAR_ERR:
|
|
return "API request fail, param error"
|
|
elif self == Status.DEVICE_MODE_ERROR:
|
|
return "API request fail, device mode error"
|
|
elif self == Status.INVALID_CMD:
|
|
return "API request fail, cmd invalid"
|
|
elif self == Status.SUCCESS:
|
|
return "Device operation succeeded"
|
|
elif self == Status.NOT_IMPLEMENTED:
|
|
return "Some api not implemented"
|
|
elif self == Status.FLASH_WRITE_FAIL:
|
|
return "Flash write failed"
|
|
elif self == Status.FLASH_READ_FAIL:
|
|
return "Flash read failed"
|
|
elif self == Status.INVALID_SLOT_TYPE:
|
|
return "Invalid card type in slot"
|
|
return "Invalid status"
|
|
|
|
|
|
@enum.unique
|
|
class SlotNumber(enum.IntEnum):
|
|
SLOT_1 = 1
|
|
SLOT_2 = 2
|
|
SLOT_3 = 3
|
|
SLOT_4 = 4
|
|
SLOT_5 = 5
|
|
SLOT_6 = 6
|
|
SLOT_7 = 7
|
|
SLOT_8 = 8
|
|
|
|
@staticmethod
|
|
def to_fw(index: int): # can be int or SlotNumber
|
|
# SlotNumber() will raise error for us if index not in slot range
|
|
return SlotNumber(index).value - 1
|
|
|
|
@staticmethod
|
|
def from_fw(index: int):
|
|
# SlotNumber() will raise error for us if index not in fw range
|
|
return SlotNumber(index + 1)
|
|
|
|
|
|
@enum.unique
|
|
class TagSenseType(enum.IntEnum):
|
|
# Unknown
|
|
UNDEFINED = 0
|
|
# 125 kHz
|
|
LF = 1
|
|
# 13.56 MHz
|
|
HF = 2
|
|
|
|
|
|
@enum.unique
|
|
class TagSpecificType(enum.IntEnum):
|
|
UNDEFINED = 0
|
|
|
|
# old HL/LF common types, slots using these ones need to be migrated first
|
|
OLD_EM410X = 1
|
|
OLD_MIFARE_Mini = 2
|
|
OLD_MIFARE_1024 = 3
|
|
OLD_MIFARE_2048 = 4
|
|
OLD_MIFARE_4096 = 5
|
|
OLD_NTAG_213 = 6
|
|
OLD_NTAG_215 = 7
|
|
OLD_NTAG_216 = 8
|
|
OLD_TAG_TYPES_END = 9
|
|
|
|
# LF
|
|
|
|
# ASK Tag-Talk-First 100
|
|
# EM410x
|
|
EM410X = 100
|
|
EM410X_16 = 101
|
|
EM410X_32 = 102
|
|
EM410X_64 = 103
|
|
EM410X_ELECTRA = 104
|
|
# FDX-B
|
|
# securakey
|
|
# gallagher
|
|
# PAC/Stanley
|
|
# Presco
|
|
# Visa2000
|
|
Viking = 170
|
|
# Noralsy
|
|
# Jablotron
|
|
|
|
# FSK Tag-Talk-First 200
|
|
HIDProx = 200
|
|
ioProx = 201
|
|
# AWID
|
|
# Paradox
|
|
|
|
# PSK Tag-Talk-First 300
|
|
# Indala
|
|
# Keri
|
|
# NexWatch
|
|
|
|
# Reader-Talk-First 400
|
|
# T5577
|
|
# EM4x05/4x69
|
|
# EM4x50/4x70
|
|
# Hitag series
|
|
|
|
TAG_TYPES_LF_END = 999
|
|
|
|
# HF
|
|
|
|
# MIFARE Classic series 1000
|
|
MIFARE_Mini = 1000
|
|
MIFARE_1024 = 1001
|
|
MIFARE_2048 = 1002
|
|
MIFARE_4096 = 1003
|
|
|
|
# MFUL / NTAG series 1100
|
|
NTAG_213 = 1100
|
|
NTAG_215 = 1101
|
|
NTAG_216 = 1102
|
|
MF0ICU1 = 1103
|
|
MF0ICU2 = 1104
|
|
MF0UL11 = 1105
|
|
MF0UL21 = 1106
|
|
NTAG_210 = 1107
|
|
NTAG_212 = 1108
|
|
# MIFARE Plus series 1200
|
|
# DESFire series 1300
|
|
|
|
# ST25TA series 2000
|
|
|
|
# HF14A-4 series 3000
|
|
|
|
@staticmethod
|
|
def list(exclude_meta=True):
|
|
return [
|
|
t
|
|
for t in TagSpecificType
|
|
if (
|
|
t > TagSpecificType.OLD_TAG_TYPES_END
|
|
and t != TagSpecificType.TAG_TYPES_LF_END
|
|
)
|
|
or not exclude_meta
|
|
]
|
|
|
|
@staticmethod
|
|
def list_hf():
|
|
return [
|
|
t for t in TagSpecificType.list() if (t > TagSpecificType.TAG_TYPES_LF_END)
|
|
]
|
|
|
|
@staticmethod
|
|
def list_lf():
|
|
return [
|
|
t
|
|
for t in TagSpecificType.list()
|
|
if (TagSpecificType.UNDEFINED < t < TagSpecificType.TAG_TYPES_LF_END)
|
|
]
|
|
|
|
def __str__(self):
|
|
if self == TagSpecificType.UNDEFINED:
|
|
return "Undefined"
|
|
elif self == TagSpecificType.EM410X:
|
|
return "EM410X"
|
|
elif self == TagSpecificType.EM410X_16:
|
|
return "EM410X/16"
|
|
elif self == TagSpecificType.EM410X_32:
|
|
return "EM410X/32"
|
|
elif self == TagSpecificType.EM410X_64:
|
|
return "EM410X/64"
|
|
elif self == TagSpecificType.EM410X_ELECTRA:
|
|
return "EM410X Electra"
|
|
elif self == TagSpecificType.HIDProx:
|
|
return "HIDProx"
|
|
elif self == TagSpecificType.ioProx:
|
|
return "ioProx"
|
|
elif self == TagSpecificType.Viking:
|
|
return "Viking"
|
|
elif self == TagSpecificType.MIFARE_Mini:
|
|
return "Mifare Mini"
|
|
elif self == TagSpecificType.MIFARE_1024:
|
|
return "Mifare Classic 1k"
|
|
elif self == TagSpecificType.MIFARE_2048:
|
|
return "Mifare Classic 2k"
|
|
elif self == TagSpecificType.MIFARE_4096:
|
|
return "Mifare Classic 4k"
|
|
elif self == TagSpecificType.NTAG_213:
|
|
return "NTAG 213"
|
|
elif self == TagSpecificType.NTAG_215:
|
|
return "NTAG 215"
|
|
elif self == TagSpecificType.NTAG_216:
|
|
return "NTAG 216"
|
|
elif self == TagSpecificType.MF0ICU1:
|
|
return "Mifare Ultralight"
|
|
elif self == TagSpecificType.MF0ICU2:
|
|
return "Mifare Ultralight C"
|
|
elif self == TagSpecificType.MF0UL11:
|
|
return "Mifare Ultralight EV1 (640 bit)"
|
|
elif self == TagSpecificType.MF0UL21:
|
|
return "Mifare Ultralight EV1 (1312 bit)"
|
|
elif self == TagSpecificType.NTAG_210:
|
|
return "NTAG 210"
|
|
elif self == TagSpecificType.NTAG_212:
|
|
return "NTAG 212"
|
|
elif self < TagSpecificType.OLD_TAG_TYPES_END:
|
|
return "Old tag type, must be migrated! Upgrade fw!"
|
|
return "Invalid"
|
|
|
|
|
|
@enum.unique
|
|
class MifareClassicWriteMode(enum.IntEnum):
|
|
# Normal write
|
|
NORMAL = 0
|
|
# Send NACK to write attempts
|
|
DENIED = 1
|
|
# Acknowledge writes, but don't remember contents
|
|
DECEIVE = 2
|
|
# Store data to RAM, but not to ROM
|
|
SHADOW = 3
|
|
# Shadow requested, will be changed to SHADOW and stored to ROM
|
|
SHADOW_REQ = 4
|
|
|
|
@staticmethod
|
|
def list(exclude_meta=True):
|
|
return [
|
|
m
|
|
for m in MifareClassicWriteMode
|
|
if m != MifareClassicWriteMode.SHADOW_REQ or not exclude_meta
|
|
]
|
|
|
|
def __str__(self):
|
|
if self == MifareClassicWriteMode.NORMAL:
|
|
return "Normal"
|
|
elif self == MifareClassicWriteMode.DENIED:
|
|
return "Denied"
|
|
elif self == MifareClassicWriteMode.DECEIVE:
|
|
return "Deceive"
|
|
elif self == MifareClassicWriteMode.SHADOW:
|
|
return "Shadow"
|
|
elif self == MifareClassicWriteMode.SHADOW_REQ:
|
|
return "Shadow requested"
|
|
return "None"
|
|
|
|
|
|
@enum.unique
|
|
class MifareUltralightWriteMode(enum.IntEnum):
|
|
# Normal write
|
|
NORMAL = 0
|
|
# Send NACK to write attempts
|
|
DENIED = 1
|
|
# Acknowledge writes, but don't remember contents
|
|
DECEIVE = 2
|
|
# Store data to RAM, but not to ROM
|
|
SHADOW = 3
|
|
# Shadow requested, will be changed to SHADOW and stored to ROM
|
|
SHADOW_REQ = 4
|
|
|
|
@staticmethod
|
|
def list(exclude_meta=True):
|
|
return [
|
|
m
|
|
for m in MifareUltralightWriteMode
|
|
if m != MifareUltralightWriteMode.SHADOW_REQ or not exclude_meta
|
|
]
|
|
|
|
def __str__(self):
|
|
if self == MifareUltralightWriteMode.NORMAL:
|
|
return "Normal"
|
|
elif self == MifareUltralightWriteMode.DENIED:
|
|
return "Denied"
|
|
elif self == MifareUltralightWriteMode.DECEIVE:
|
|
return "Deceive"
|
|
elif self == MifareUltralightWriteMode.SHADOW:
|
|
return "Shadow"
|
|
elif self == MifareUltralightWriteMode.SHADOW_REQ:
|
|
return "Shadow requested"
|
|
return "None"
|
|
|
|
|
|
@enum.unique
|
|
class MifareClassicPrngType(enum.IntEnum):
|
|
# the random number of the card response is fixed
|
|
STATIC = 0
|
|
# the random number of the card response is weak
|
|
WEAK = 1
|
|
# the random number of the card response is unpredictable
|
|
HARD = 2
|
|
|
|
def __str__(self):
|
|
if self == MifareClassicPrngType.STATIC:
|
|
return "Static"
|
|
elif self == MifareClassicPrngType.WEAK:
|
|
return "Weak"
|
|
elif self == MifareClassicPrngType.HARD:
|
|
return "Hard"
|
|
return "None"
|
|
|
|
|
|
@enum.unique
|
|
class MifareClassicDarksideStatus(enum.IntEnum):
|
|
OK = 0
|
|
# Darkside can't fix NT (PRNG is unpredictable)
|
|
CANT_FIX_NT = 1
|
|
# Darkside try to recover a default key
|
|
LUCKY_AUTH_OK = 2
|
|
# Darkside can't get tag response enc(nak)
|
|
NO_NAK_SENT = 3
|
|
# Darkside running, can't change tag
|
|
TAG_CHANGED = 4
|
|
|
|
def __str__(self):
|
|
if self == MifareClassicDarksideStatus.OK:
|
|
return "Success"
|
|
elif self == MifareClassicDarksideStatus.CANT_FIX_NT:
|
|
return "Cannot fix NT (unpredictable PRNG)"
|
|
elif self == MifareClassicDarksideStatus.LUCKY_AUTH_OK:
|
|
return "Try to recover a default key"
|
|
elif self == MifareClassicDarksideStatus.NO_NAK_SENT:
|
|
return "Cannot get tag response enc(nak)"
|
|
elif self == MifareClassicDarksideStatus.TAG_CHANGED:
|
|
return "Tag changed during attack"
|
|
return "None"
|
|
|
|
|
|
@enum.unique
|
|
class AnimationMode(enum.IntEnum):
|
|
FULL = 0
|
|
MINIMAL = 1
|
|
SYMMETRIC = 3
|
|
NONE = 2
|
|
|
|
def __str__(self):
|
|
if self == AnimationMode.FULL:
|
|
return "Full animation"
|
|
elif self == AnimationMode.MINIMAL:
|
|
return "Minimal animation"
|
|
elif self == AnimationMode.SYMMETRIC:
|
|
return "Symmetric animation"
|
|
elif self == AnimationMode.NONE:
|
|
return "No animation"
|
|
|
|
|
|
@enum.unique
|
|
class ButtonType(enum.IntEnum):
|
|
A = ord("A")
|
|
B = ord("B")
|
|
|
|
|
|
@enum.unique
|
|
class MfcKeyType(enum.IntEnum):
|
|
A = 0x60
|
|
B = 0x61
|
|
|
|
|
|
@enum.unique
|
|
class ButtonPressFunction(enum.IntEnum):
|
|
NONE = 0
|
|
NEXTSLOT = 1
|
|
PREVSLOT = 2
|
|
CLONE = 3
|
|
BATTERY = 4
|
|
FIELDGEN = 5
|
|
|
|
def __str__(self):
|
|
if self == ButtonPressFunction.NONE:
|
|
return "No Function"
|
|
elif self == ButtonPressFunction.NEXTSLOT:
|
|
return "Select next slot"
|
|
elif self == ButtonPressFunction.PREVSLOT:
|
|
return "Select previous slot"
|
|
elif self == ButtonPressFunction.CLONE:
|
|
return "Read then simulate the ID/UID card number"
|
|
elif self == ButtonPressFunction.BATTERY:
|
|
return "Show Battery Level"
|
|
elif self == ButtonPressFunction.FIELDGEN:
|
|
return "Toggle NFC Field Generator"
|
|
return "None"
|
|
|
|
@enum.unique
|
|
class MfcValueBlockOperator(enum.IntEnum):
|
|
DECREMENT = 0xC0
|
|
INCREMENT = 0xC1
|
|
RESTORE = 0xC2
|
|
|
|
@enum.unique
|
|
class HIDFormat(enum.IntEnum):
|
|
H10301 = 1
|
|
IND26 = 2
|
|
IND27 = 3
|
|
INDASC27 = 4
|
|
TECOM27 = 5
|
|
W2804 = 6
|
|
IND29 = 7
|
|
ATSW30 = 8
|
|
ADT31 = 9
|
|
HCP32 = 10
|
|
HPP32 = 11
|
|
KASTLE = 12
|
|
KANTECH = 13
|
|
WIE32 = 14
|
|
D10202 = 15
|
|
H10306 = 16
|
|
N10002 = 17
|
|
OPTUS34 = 18
|
|
SMP34 = 19
|
|
BQT34 = 20
|
|
C1K35S = 21
|
|
C15001 = 22
|
|
S12906 = 23
|
|
ACTPHID = 42
|
|
SIE36 = 24
|
|
H10320 = 25
|
|
H10302 = 26
|
|
H10304 = 27
|
|
P10004 = 28
|
|
HGEN37 = 29
|
|
MDI37 = 30
|
|
|
|
def __str__(self):
|
|
descriptions = {
|
|
HIDFormat.H10301: "HID H10301 26-bit",
|
|
HIDFormat.IND26: "Indala 26-bit",
|
|
HIDFormat.IND27: "Indala 27-bit",
|
|
HIDFormat.INDASC27: "Indala ASC 27-bit",
|
|
HIDFormat.TECOM27: "Tecom 27-bit",
|
|
HIDFormat.W2804: "2804 Wiegand 28-bit",
|
|
HIDFormat.IND29: "Indala 29-bit",
|
|
HIDFormat.ATSW30: "ATS Wiegand 30-bit",
|
|
HIDFormat.ADT31: "HID ADT 31-bit",
|
|
HIDFormat.HCP32: "HID Check Point 32-bit",
|
|
HIDFormat.HPP32: "HID Hewlett-Packard 32-bit",
|
|
HIDFormat.KASTLE: "Kastle 32-bit",
|
|
HIDFormat.KANTECH: "Indala/Kantech KFS 32-bit",
|
|
HIDFormat.WIE32: "Wiegand 32-bit",
|
|
HIDFormat.D10202: "HID D10202 33-bit",
|
|
HIDFormat.H10306: "HID H10306 34-bit",
|
|
HIDFormat.N10002: "Honeywell/Northern N10002 34-bit",
|
|
HIDFormat.OPTUS34: "Indala Optus 34-bit",
|
|
HIDFormat.SMP34: "Cardkey Smartpass 34-bit",
|
|
HIDFormat.BQT34: "BQT 34-bit",
|
|
HIDFormat.C1K35S: "HID Corporate 1000 35-bit Std",
|
|
HIDFormat.C15001: "HID KeyScan 36-bit",
|
|
HIDFormat.S12906: "HID Simplex 36-bit",
|
|
HIDFormat.ACTPHID: "HID ACTProx 36-bit",
|
|
HIDFormat.SIE36: "HID 36-bit Siemens",
|
|
HIDFormat.H10320: "HID H10320 37-bit BCD",
|
|
HIDFormat.H10302: "HID H10302 37-bit huge ID",
|
|
HIDFormat.H10304: "HID H10304 37-bit",
|
|
HIDFormat.P10004: "HID P10004 37-bit PCSC",
|
|
HIDFormat.HGEN37: "HID Generic 37-bit",
|
|
HIDFormat.MDI37: "PointGuard MDI 37-bit",
|
|
}
|
|
if self in descriptions:
|
|
return descriptions[self]
|
|
return "Invalid"
|