def init(self, maxtraces):
"""Initialize key text pattern for a specific number of traces.
Args:
maxtraces (int): Number of traces to initialize for.
Raises:
ValueError: Invalid key length
"""
length = self.keyLen()
if length <= 32:
self._key = util.hexStrToByteArray(
"01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0 23 45 67 89 ab cd ef 01 34 56 78 9a bc de f0 12"
)[:length]
else:
raise ValueError("Invalid key length: %d bytes" % length)
self._textin1 = util.hexStrToByteArray(
"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00")
if length == 16:
self._interleavedPlaintext = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 90")
elif length == 24:
self._interleavedPlaintext = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 88")
elif length == 32:
self._interleavedPlaintext = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 95")
else:
raise ValueError("Invalid key length: %d bytes" % length)
self.num_group1 = int(maxtraces / 2)
self.num_group2 = int(maxtraces - self.num_group1)
def __init__(self, target=None):
AcqKeyTextPattern_Base.__init__(self)
self.initmask = 'FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00'
self.initkey = '2B 7E 15 16 28 AE D2 A6 AB F7 15 88 09 CF 4F 3C'
self._key = util.hexStrToByteArray(self.initkey)
self._mask = util.hexStrToByteArray(self.initmask)
self.setTarget(target)
def __init__(self, target=None):
AcqKeyTextPattern_Base.__init__(self)
self.initmask = 'FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00'
self.initkey = '2B 7E 15 16 28 AE D2 A6 AB F7 15 88 09 CF 4F 3C'
self._key = util.hexStrToByteArray(self.initkey)
self._mask = util.hexStrToByteArray(self.initmask)
self.getParams().addChildren([
{
'name': 'Fixed Encryption Key',
'key': 'initkey',
'type': 'str',
'get': self.getInitialKey,
'set': self.setInitialKey,
'visible': True
},
{
'name': 'Plaintext Mask',
'key': 'initmask',
'type': 'str',
'get': self.getInitialMask,
'set': self.setInitialMask,
'visible': True
},
])
self.setTarget(target)
def initPair(self, maxtraces):
length = self.keyLen()
if length <= 32:
self._key = util.hexStrToByteArray(
"01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0 23 45 67 89 ab cd ef 01 34 56 78 9a bc de f0 12"
)[:length]
else:
raise ValueError("Invalid key length: %d bytes" % length)
self.findParam("key").setValue(" ".join(
["%02X" % b for b in self._key]),
init=True)
self._textin1 = util.hexStrToByteArray(
"00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00")
if length == 16:
self._interleavedPlaintext = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 90")
elif length == 24:
self._interleavedPlaintext = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 88")
elif length == 32:
self._interleavedPlaintext = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 95")
else:
raise ValueError("Invalid key length: %d bytes" % length)
self.findParam("text").setValue(" ".join(
["%02X" % b for b in self._interleavedPlaintext]),
init=True)
self.num_group1 = int(maxtraces / 2)
self.num_group2 = int(maxtraces - self.num_group1)
def __init__(self):
AcqKeyTextPattern_Base.__init__(self)
self._fixedKey = True
self._fixedPlain = False
self.inittext = '00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F'
self.initkey = '2B 7E 15 16 28 AE D2 A6 AB F7 15 88 09 CF 4F 3C'
self._key = util.hexStrToByteArray(self.initkey)
self._textin = util.hexStrToByteArray(self.inittext)
self.types = {'Random': False, 'Fixed': True}
def trace_callback(self, textin, textout, trace, key):
interleavedPlaintext128 = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 90")
interleavedPlaintext192 = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 88")
interleavedPlaintext256 = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 95")
if (textin == interleavedPlaintext128).all() or \
(textin == interleavedPlaintext192).all() or \
(textin == interleavedPlaintext256).all():
raise StopIteration()
return (textin, textout, trace, key)
def __init__(self, target=None):
AcqKeyTextPattern_Base.__init__(self)
self._fixedKey = True
self._fixedPlain = False
self.inittext = "00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F"
self.initkey = "2B 7E 15 16 28 AE D2 A6 AB F7 15 88 09 CF 4F 3C"
self._key = util.hexStrToByteArray(self.initkey)
self._textin = util.hexStrToByteArray(self.inittext)
self.types = {"Random": False, "Fixed": True}
self.getParams().addChildren(
[
{
"name": "Key",
"type": "list",
"values": self.types,
"get": self.getKeyType,
"set": self.setKeyType,
"action": lambda p: self.findParam("initkey").show(p.getValue()),
"linked": ["initkey"],
},
# {'name':'Size', 'type':'int'},
{
"name": "Fixed Encryption Key",
"key": "initkey",
"type": "str",
"get": self.getInitialKey,
"set": self.setInitialKey,
"visible": self.getKeyType(),
},
{
"name": "Plaintext",
"type": "list",
"values": self.types,
"get": self.getPlainType,
"set": self.setPlainType,
"action": lambda p: self.findParam("inittext").show(p.getValue()),
"linked": ["inittext"],
},
{
"name": "Fixed Plaintext",
"key": "inittext",
"type": "str",
"get": self.getInitialText,
"set": self.setInitialText,
"visible": self.getPlainType(),
},
]
)
self.setTarget(target)
def __init__(self, target=None):
AcqKeyTextPattern_Base.__init__(self)
self._fixedKey = True
self._fixedPlain = False
self.inittext = '00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F'
self.initkey = '2B 7E 15 16 28 AE D2 A6 AB F7 15 88 09 CF 4F 3C'
self._key = util.hexStrToByteArray(self.initkey)
self._textin = util.hexStrToByteArray(self.inittext)
self.types = {'Random': False, 'Fixed': True}
self.getParams().addChildren([
{
'name': 'Key',
'type': 'list',
'values': self.types,
'get': self.getKeyType,
'set': self.setKeyType,
'action':
lambda p: self.findParam("initkey").show(p.getValue()),
'linked': ['initkey']
},
# {'name':'Size', 'type':'int'},
{
'name': 'Fixed Encryption Key',
'key': 'initkey',
'type': 'str',
'get': self.getInitialKey,
'set': self.setInitialKey,
'visible': self.getKeyType()
},
{
'name': 'Plaintext',
'type': 'list',
'values': self.types,
'get': self.getPlainType,
'set': self.setPlainType,
'action':
lambda p: self.findParam("inittext").show(p.getValue()),
'linked': ['inittext']
},
{
'name': 'Fixed Plaintext',
'key': 'inittext',
'type': 'str',
'get': self.getInitialText,
'set': self.setInitialText,
'visible': self.getPlainType()
},
])
self.setTarget(target)
def getPartitionNum(self, trace, tnum):
"""Checks if plaintext is the fixed TVLA plaintext for this key length or a random value.
Returns [1] if fixed and [0] if random.
"""
klen = len(trace.getKnownKey(tnum))
pt = trace.getTextin(tnum)
if klen == 16 and (pt == util.hexStrToByteArray("da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 90")).all():
return [1]
elif klen == 24 and (pt == util.hexStrToByteArray("da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 88")).all():
return [1]
elif klen == 32 and (pt == util.hexStrToByteArray("da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 95")).all():
return [1]
return [0]
def __init__(self, key_len=16):
self._key_len = key_len
self._I_0_fixed = bytearray([0xAA] * 16)
self._I_0_rand = bytearray([0xCC] * 16)
self._K_0 = util.hexStrToByteArray(
"53 53 53 53 53 53 53 53 53 53 53 53 53 53 53 53")
rounds = 10
if key_len == 16:
self._K_fixed = util.hexStrToByteArray(
"81 1E 37 31 B0 12 0A 78 42 78 1E 22 B2 5C DD F9")
self._K_gen = util.hexStrToByteArray(
"12 34 56 78 9a bc de f1 23 45 67 89 ab cd e0 f0")
elif key_len == 24:
rounds = 12
self._K_fixed = util.hexStrToByteArray(
"81 1E 37 31 B0 12 0A 78 42 78 1E 22 B2 5C DD F9 94 F4 D9 2C D2 FA E6 45"
)
self._K_gen = util.hexStrToByteArray(
"12 34 56 78 9a bc de f1 23 45 67 89 ab cd ef 02 34 56 78 9a bc de 0f 01"
)
elif key_len == 32:
rounds = 14
self._K_fixed = util.hexStrToByteArray(
"81 1E 37 31 B0 12 0A 78 42 78 1E 22 B2 5C DD F9 94 F4 D9 2C D2 FA E6 45 37 B9 40 EA 5E 1A F1 12"
)
self._K_gen = util.hexStrToByteArray(
"12 34 56 78 9a bc de f1 23 45 67 89 ab cd ef 02 34 56 78 9a bc de f0 13 45 67 89 ab cd e0 f0 12"
)
else:
raise ValueError(
"Invalid key length {}, must be 16, 24, or 32".format(key_len))
self._K_gen_exp = _expand_aes_key(self._K_gen)
self._cipher = AESCipher(self._K_gen_exp)
def __init__(self, target=None):
AcqKeyTextPattern_Base.__init__(self)
self._fixedKey = True
self._fixedPlain = False
self.inittext = '00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F'
self.initkey = '2B 7E 15 16 28 AE D2 A6 AB F7 15 88 09 CF 4F 3C'
self._key = util.hexStrToByteArray(self.initkey)
self._textin = util.hexStrToByteArray(self.inittext)
self.types = {'Random': False, 'Fixed': True}
self.getParams().addChildren([
{'name':'Key', 'type':'list', 'values':self.types , 'get':self.getKeyType, 'set':self.setKeyType, 'action':lambda p:self.findParam("initkey").show(p.getValue()), 'linked':['initkey']},
# {'name':'Size', 'type':'int'},
{'name':'Fixed Encryption Key', 'key':'initkey', 'type':'str', 'get':self.getInitialKey, 'set':self.setInitialKey, 'visible':self.getKeyType()},
{'name':'Plaintext', 'type':'list', 'values':self.types , 'get':self.getPlainType, 'set':self.setPlainType, 'action':lambda p:self.findParam("inittext").show(p.getValue()), 'linked':['inittext']},
{'name':'Fixed Plaintext', 'key':'inittext', 'type':'str', 'get':self.getInitialText, 'set':self.setInitialText, 'visible':self.getPlainType()},
])
self.setTarget(target)
def __init__(self):
TargetTemplate.__init__(self)
self.ser = SimpleSerial_ChipWhispererLite()
self.keylength = 16
self.textlength = 16
self.outputlength = 16
self.input = ""
self.key = ""
self._protver = 'auto'
self._read_timeout = 500
self.masklength = 18
self._fixedMask = True
self.initmask = '1F 70 D6 3C 23 EB 1A B8 6A D5 E2 0D 5F D9 58 A3 CA 9D'
self._mask = util.hexStrToByteArray(self.initmask)
self.protformat = 'hex'
self.last_key = bytearray(16)
# Preset lists are in the form
# {'Dropdown Name':['Init Command', 'Load Key Command', 'Load Input Command', 'Go Command', 'Output Format']}
# If a command is None, it's left unchanged and the text field is editable;
# Otherwise, it's loaded with the value and set to readonly
self.presets = {
'Custom': [None, None, None, None, None],
'SimpleSerial Encryption':
['', 'k$KEY$\\n', '', 'p$TEXT$\\n', 'r$RESPONSE$\\n'],
'SimpleSerial Authentication': [
'', 'k$KEY$\\n', 't$EXPECTED$\\n', 'p$TEXT$\\n',
'r$RESPONSE$\\n'
],
'Glitching': [None, None, None, None, '$GLITCH$\\n'],
}
self._preset = 'Custom'
self._linkedmaskgroup = (('maskgroup', 'cmdmask'),
('maskgroup', 'initmask'), ('maskgroup',
'masktype'),
('maskgroup', 'masklen'), ('maskgroup',
'newmask'))
self._proto_ver = "auto"
self._proto_timeoutms = 20
self._init_cmd = ''
self._key_cmd = 'k$KEY$\n'
self._input_cmd = ''
self._go_cmd = 'p$TEXT$\n'
self._output_cmd = 'r$RESPONSE$\n'
self._mask_enabled = False
self._mask_cmd = 'm$MASK$\n'
self.outstanding_ack = False
self.setConnection(self.ser)
self.disable_newattr()
def setInitialMask(self, initialMask, binaryMask=False):
if initialMask:
if binaryMask:
maskStr = ''
for s in initialMask:
maskStr += '%02x' % s
self._mask = bytearray(initialMask)
else:
maskStr = initialMask
self._mask = util.hexStrToByteArray(initialMask)
self.initmask = maskStr
def initPair(self):
length = self.keyLen()
if length <= 32:
self._key = util.hexStrToByteArray("01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0 23 45 67 89 ab cd ef 01 34 56 78 9a bc de f0 12")[:length]
else:
raise ValueError("Invalid key length: %d bytes" % length)
self.findParam("key").setValue(" ".join(["%02X"%b for b in self._key]), init=True)
self._textin1 = util.hexStrToByteArray("00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00")
if length == 16:
self._interleavedPlaintext = util.hexStrToByteArray("da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 90")
elif length == 24:
self._interleavedPlaintext = util.hexStrToByteArray("da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 88")
elif length == 32:
self._interleavedPlaintext = util.hexStrToByteArray("da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 95")
else:
raise ValueError("Invalid key length: %d bytes" % length)
self.findParam("text").setValue(" ".join(["%02X" % b for b in self._interleavedPlaintext]), init=True)
self.group1 = True
def setInitialKey(self, initialKey, binaryKey=False):
if initialKey:
if binaryKey:
keyStr = ""
for s in initialKey:
keyStr += "%02x " % s
self._key = bytearray(initialKey)
else:
keyStr = initialKey
self._key = util.hexStrToByteArray(initialKey)
self.initkey = keyStr
def setInitialText(self, initialText, binaryText=False):
if initialText:
if binaryText:
textStr = ''
for s in initialText:
textStr += '%02x ' % s
self._textin = bytearray(initialText)
else:
textStr = initialText
self._textin = util.hexStrToByteArray(initialText)
self.inittext = textStr
def setInitialKey(self, initialKey, binaryKey=False):
if initialKey:
if binaryKey:
keyStr = ''
for s in initialKey:
keyStr += '%02x ' % s
self._key = bytearray(initialKey)
else:
keyStr = initialKey
self._key = util.hexStrToByteArray(initialKey)
self.initkey = keyStr
def setInitialText(self, initialText, binaryText=False):
if initialText:
if binaryText:
textStr = ""
for s in initialText:
textStr += "%02x " % s
self._textin = bytearray(initialText)
else:
textStr = initialText
self._textin = util.hexStrToByteArray(initialText)
self.inittext = textStr
def get_reg(self, reg):
"""Reads a Cortex debug register
Args:
reg (string): Register to read. See self.regs for available registers.
"""
if reg in self.regs:
data = self.regs[reg] + '00000000'
self._ss.simpleserial_write('g', util.hexStrToByteArray(data))
time.sleep(0.1)
return self._ss.read().split('\n')[0][1:]
else:
logging.error('Register %s does not exist.', reg)
def set_reg(self, reg, data, printresult=False):
"""Set a Cortex debug register
Args:
reg (string): Register to write. See self.regs for available registers.
data (string): 8-character hex string, value to write to COMP0 (e.g. '1000F004')
"""
if reg in self.regs:
data = self.regs[reg] + data
self._ss.simpleserial_write('s', util.hexStrToByteArray(data))
time.sleep(0.1)
if printresult:
print(self._ss.read().split('\n')[0])
else:
logging.error('Register %s does not exist.', reg)
def __init__(self, key_len=16):
self._key_len = key_len
self._I_0 = bytearray([0x00] * 16)
self.rounds = 10
if key_len == 16:
self._I_fixed = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 90")
self._K_dev = util.hexStrToByteArray(
"01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0")
self._K_gen = util.hexStrToByteArray(
"12 34 56 78 9a bc de f1 23 45 67 89 ab cd e0 f0")
elif key_len == 24:
self.rounds = 12
self._I_fixed = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 88")
self._K_dev = util.hexStrToByteArray(
"01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0 23 45 67 89 ab cd ef 01"
)
self._K_gen = util.hexStrToByteArray(
"12 34 56 78 9a bc de f1 23 45 67 89 ab cd ef 02 34 56 78 9a bc de 0f 01"
)
elif key_len == 32:
self.rounds = 14
self._I_fixed = util.hexStrToByteArray(
"da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 95")
self._K_dev = util.hexStrToByteArray(
"01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0 23 45 67 89 ab cd ef 01 34 56 78 9a bc de f0 12"
)
self._K_gen = util.hexStrToByteArray(
"12 34 56 78 9a bc de f1 23 45 67 89 ab cd ef 02 34 56 78 9a bc de f0 13 45 67 89 ab cd e0 f0 12"
)
else:
raise ValueError(
"Invalid key length {}, must be 16, 24, or 32".format(key_len))
self._K_gen_exp = _expand_aes_key(self._K_gen)
self._K_dev_exp = _expand_aes_key(self._K_dev)
self._cipher = AESCipher(self._K_gen_exp)
self._dev_cipher = AESCipher(self._K_dev_exp)
def __init__(self, key_len=16, round=None):
self._key_len = key_len
self._I_0 = bytearray([0x00] * 16)
rounds = 10
random.seed()
self._round = round
self._I_semi_fixed = util.hexStrToByteArray(
"8B 8A 49 0B DF 7C 00 BD D7 E6 06 6C 61 00 24 12")
if key_len == 16:
if not round:
self._round = 5
self._K_dev = util.hexStrToByteArray(
"01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0")
self._K_gen = util.hexStrToByteArray(
"12 34 56 78 9a bc de f1 23 45 67 89 ab cd e0 f0")
elif key_len == 24:
rounds = 12
if not round:
self._round = 6
self._K_dev = util.hexStrToByteArray(
"01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0 23 45 67 89 ab cd ef 01"
)
self._K_gen = util.hexStrToByteArray(
"12 34 56 78 9a bc de f1 23 45 67 89 ab cd ef 02 34 56 78 9a bc de 0f 01"
)
elif key_len == 32:
if not round:
self._round = 7
rounds = 14
self._K_dev = util.hexStrToByteArray(
"01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0 23 45 67 89 ab cd ef 01 34 56 78 9a bc de f0 12"
)
self._K_gen = util.hexStrToByteArray(
"12 34 56 78 9a bc de f1 23 45 67 89 ab cd ef 02 34 56 78 9a bc de f0 13 45 67 89 ab cd e0 f0 12"
)
else:
raise ValueError(
"Invalid key length {}, must be 16, 24, or 32".format(key_len))
self._K_dev_exp = _expand_aes_key(self._K_dev)
self._K_gen_exp = _expand_aes_key(self._K_gen)
self._dev_cipher = AESCipher(self._K_dev_exp)
self._cipher = AESCipher(self._K_gen_exp)
self._state_start = np.uint32(
int.from_bytes(self._I_semi_fixed[:4], "big"))
def initPair(self):
if self.keyLen() == 16:
self._key = util.hexStrToByteArray("01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0")
elif self.keyLen() == 24:
self._key = util.hexStrToByteArray("01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0 23 45 67 89 ab cd ef 01")
elif self.keyLen() == 32:
self._key = util.hexStrToByteArray("01 23 45 67 89 ab cd ef 12 34 56 78 9a bc de f0 23 45 67 89 ab cd ef 01 34 56 78 9a bc de f0 12")
else:
raise ValueError("Invalid key length: %d bytes" % self.keyLen())
self._textin1 = util.hexStrToByteArray("00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00")
if self.keyLen() == 16:
self._textin2 = util.hexStrToByteArray("da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 90")
elif self.keyLen() == 24:
self._textin2 = util.hexStrToByteArray("da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 88")
elif self.keyLen() == 32:
self._textin2 = util.hexStrToByteArray("da 39 a3 ee 5e 6b 4b 0d 32 55 bf ef 95 60 18 95")
else:
raise ValueError("Invalid key length: %d bytes" % self.keyLen())
self.group1 = True
def __init__(self):
TargetTemplate.__init__(self)
ser_cons = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.capture.targets.simpleserial_readers", True, False)
self.ser = ser_cons[SimpleSerial_ChipWhispererLite._name]
self.keylength = 16
self.textlength = 16
self.outputlength = 16
self.input = ""
self.key = ""
self._protver = 'auto'
self._read_timeout = 500
self.maskEnabled = False
self.masklength = 18
self._fixedMask = True
self.initmask = '1F 70 D6 3C 23 EB 1A B8 6A D5 E2 0D 5F D9 58 A3 CA 9D'
self._mask = util.hexStrToByteArray(self.initmask)
self.protformat = 'hex'
# Preset lists are in the form
# {'Dropdown Name':['Init Command', 'Load Key Command', 'Load Input Command', 'Go Command', 'Output Format']}
# If a command is None, it's left unchanged and the text field is editable;
# Otherwise, it's loaded with the value and set to readonly
self.presets = {
'Custom': [None, None, None, None, None],
'SimpleSerial Encryption':
['', 'k$KEY$\\n', '', 'p$TEXT$\\n', 'r$RESPONSE$\\n'],
'SimpleSerial Authentication': [
'', 'k$KEY$\\n', 't$EXPECTED$\\n', 'p$TEXT$\\n',
'r$RESPONSE$\\n'
],
'Glitching': [None, None, None, None, '$GLITCH$\\n'],
}
self._preset = 'Custom'
self._linkedmaskgroup = (('maskgroup', 'cmdmask'),
('maskgroup', 'initmask'), ('maskgroup',
'masktype'),
('maskgroup', 'masklen'), ('maskgroup',
'newmask'))
self.params.addChildren([
{
'name': 'Connection',
'type': 'list',
'key': 'con',
'values': ser_cons,
'get': self.getConnection,
'set': self.setConnection
},
{
'name': 'Key Length (Bytes)',
'type': 'list',
'values': [8, 16, 32],
'get': self.keyLen,
'set': self.setKeyLen
},
{
'name': 'Input Length (Bytes)',
'type': 'list',
'values': [1, 2, 4, 8, 16, 32],
'default': 16,
'get': self.textLen,
'set': self.setTextLen
},
{
'name': 'Output Length (Bytes)',
'type': 'list',
'values': [8, 16, 32],
'default': 16,
'get': self.outputLen,
'set': self.setOutputLen
},
# {'name':'Plaintext Command', 'key':'ptcmd', 'type':'list', 'values':['p', 'h'], 'value':'p'},
{
'name':
'Protocol Version',
'key':
'proto',
'type':
'group',
'expanded':
True,
'children': [
{
'name': 'Version',
'key': 'ver',
'type': 'list',
'values': ['1.0', '1.1', 'auto'],
'value': 'auto'
},
{
'name': 'Timeout (ms)',
'key': 'timeout',
'type': 'int',
'value': 20,
'range': (0, 500),
'step': 1
},
]
},
{
'name': 'Read timeout (ms)',
'key': 'timeout',
'type': 'int',
'get': self.readTimeout,
'set': self.setReadTimeout,
'range': (0, 5000),
'step': 1
},
{
'name': 'Preset Mode',
'key': 'preset',
'type': 'list',
'values': self.presets,
'get': self.getPreset,
'set': self.setPreset
},
{
'name': 'Init Command',
'key': 'cmdinit',
'type': 'str',
'value': ''
},
{
'name': 'Load Key Command',
'key': 'cmdkey',
'type': 'str',
'value': 'k$KEY$\\n'
},
{
'name': 'Load Input Command',
'key': 'cmdinput',
'type': 'str',
'value': ''
},
{
'name': 'Go Command',
'key': 'cmdgo',
'type': 'str',
'value': 'p$TEXT$\\n'
},
{
'name': 'Output Format',
'key': 'cmdout',
'type': 'str',
'value': 'r$RESPONSE$\\n'
},
{
'name':
'Mask',
'key':
'maskgroup',
'type':
'group',
'expanded':
True,
'children': [
{
'name': 'Mask Supported',
'key': 'maskenabled',
'type': 'bool',
'get': self.getMaskEnabled,
'set': self.setMaskEnabled,
'linked': self._linkedmaskgroup,
'action': self.changeMaskEnabled
},
{
'name': 'Mask Length (Bytes)',
'key': 'masklen',
'type': 'list',
'values': [18],
'default': 18,
'get': self.maskLen,
'set': self.setMaskLen,
'visible': self.getMaskEnabled()
},
{
'name': 'Load Mask Command',
'key': 'cmdmask',
'type': 'str',
'value': 'm$MASK$\\n',
'visible': self.getMaskEnabled()
},
{
'name': 'Mask Type',
'key': 'masktype',
'type': 'list',
'values': {
'Random': False,
'Fixed': True
},
'get': self.getMaskType,
'set': self.setMaskType,
'visible': self.getMaskEnabled(),
'action': self.changeMaskType
},
{
'name': 'Fixed Mask',
'key': 'initmask',
'type': 'str',
'get': self.getInitialMask,
'set': self.setInitialMask,
'visible': self.getMaskEnabled()
and self.getMaskType()
},
{
'name': 'New Random Mask',
'key': 'newmask',
'type': 'action',
'action': self.newRandMask,
'visible': self.getMaskEnabled()
and self.getMaskType()
},
]
},
{
'name':
'Protocol format',
'type':
'list',
'values': ['bin', 'hex'],
'get':
self.protFormat,
'set':
self.setProtFormat,
'help':
"Assume the protocol to be in the given format. The original SimpleSerial module assumed that the keys where to be sent in hex format but in some situations it is needed to conver the contents to a binary string representation"
}
#{'name':'Data Format', 'key':'datafmt', 'type':'list', 'values':{'DEADBEEF':'',
# 'DE AD BE EF':' ',
# 'DE:AD:BE:EF':':',
# 'DE-AD-BE-EF':'-'}, 'value':''},
])
self.outstanding_ack = False
self.setConnection(self.ser, blockSignal=True)
self.disable_newattr()
