def __init__(self):
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO)
CWCoreAPI.instance = self
self.sigNewProject = util.Signal()
self.sigConnectStatus = util.Signal()
self.sigAttackChanged = util.Signal()
self.sigNewInputData = util.Signal()
self.sigNewTextResponse = util.Signal()
self.sigTraceDone = util.Signal()
self.sigCampaignStart = util.Signal()
self.sigCampaignDone = util.Signal()
self.executingScripts = util.Observable(False)
self.valid_scopes = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.scopes", True, True)
self.valid_targets = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.targets", True, True)
self.valid_traces = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.common.traces", True, True)
self.valid_aux = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.auxiliary", True, True)
self.valid_acqPatterns = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.acq_patterns", True, False)
self.settings = Settings()
# Initialize default values
self._project = self._scope = self._target = self._traceFormat = self._acqPattern = self._attack = None
self._acqPattern = self.valid_acqPatterns["Basic"]
self._auxList = AuxList()
self._numTraces = 50
self._numTraceSets = 1
# Storage for last key/plaintext/ciphertext
self._lastKey = None
self._lastTextin = None
self._lastTextout = None
self._lastExpected = None
self.params = Parameter(name='Generic Settings', type='group', addLoadSave=True).register()
self.params.addChildren([
{'name':'Scope Module', 'key':'scopeMod', 'type':'list', 'values':self.valid_scopes, 'get':self.getScope, 'set':self.setScope},
{'name':'Target Module', 'key':'targetMod', 'type':'list', 'values':self.valid_targets, 'get':self.getTarget, 'set':self.setTarget},
{'name':'Acquisition Settings', 'type':'group', 'children':[
{'name':'Number of Traces', 'type':'int', 'limits':(1, 1E9), 'get':self.getNumTraces, 'set':self.setNumTraces, 'linked':['Traces per Set']},
{'name':'Number of Sets', 'type':'int', 'limits':(1, 1E6), 'get':self.getNumTraceSets, 'set':self.setNumTraceSets, 'linked':['Traces per Set'], 'tip': 'Break acquisition into N sets, '
'which may cause data to be saved more frequently. The default capture driver requires that NTraces/NSets is small enough to avoid running out of system memory '
'as each segment is buffered into RAM before being written to disk.'},
{'name':'Traces per Set', 'type':'int', 'readonly':True, 'get':self.tracesPerSet},
{'name':'Key/Text Pattern', 'type':'list', 'values':self.valid_acqPatterns, 'get':self.getAcqPattern, 'set':self.setAcqPattern},
]},
])
self.scopeParam = Parameter(name="Scope Settings", type='group', addLoadSave=True).register()
self.params.getChild('Scope Module').stealDynamicParameters(self.scopeParam)
self.targetParam = Parameter(name="Target Settings", type='group', addLoadSave=True).register()
self.params.getChild('Target Module').stealDynamicParameters(self.targetParam)
# Aux settings
self.auxParam = self._auxList.getParams().register()
# Note: Project settings are set up in setProject()
self.newProject()
def __init__(self):
TargetTemplate.__init__(self)
readers = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.capture.targets.smartcard_readers", True, True)
protocols = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.capture.targets.smartcard_protocols", True, True)
self.driver = None
self.protocol = None
self.params.addChildren([{
'name': 'Reader Hardware',
'type': 'list',
'values': readers,
'get': self.getConnection,
'set': self.setConnection
}, {
'name': 'SmartCard Protocol',
'type': 'list',
'values': protocols,
'get': self.getProtocol,
'set': self.setProtocol
}, {
'name': 'SmartCard Explorer Dialog',
'type': 'action',
'action': lambda _: self.getScgui().show()
}])
def __init__(self):
TargetTemplate.__init__(self)
readers = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.targets.smartcard_readers", True, True)
protocols = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.targets.smartcard_protocols", True, True)
self.driver = None
self.protocol = None
self.params.addChildren([
{'name':'Reader Hardware', 'type':'list', 'values':readers, 'get':self.getConnection, 'set':self.setConnection},
{'name':'SmartCard Protocol', 'type':'list', 'values':protocols, 'get':self.getProtocol, 'set':self.setProtocol},
{'name':'SmartCard Explorer Dialog', 'type':'action', 'action':lambda _: self.getScgui().show()}
])
def __init__(self, api):
self._api = api
self.valid_preprocessingModules = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.analyzer.preprocessing", False, False)
self.params = Parameter(name="Preprocessing Settings", type='group')
self._moduleParams = [
Parameter(name='self.ppmod[%d]' % (i), type='group')
for i in range(self._num_modules)
]
self._initModules()
self.params.addChildren([
{
'name':
'Selected Modules',
'type':
'group',
'children': [{
'name': 'self.ppmod[%d]' % (step),
'type': 'list',
'values': self.valid_preprocessingModules,
'get': partial(self.getModule, step),
'set': partial(self.setModule, step)
} for step in range(0, len(self._modules))]
},
])
for m in self._moduleParams:
self.params.append(m)
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.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':[8, 16], 'default':16, 'get':self.textLen, 'set':self.setTextLen},
{'name':'Output Length (Bytes)', 'type':'list', 'values':[8, 16], 'default':16, 'get':self.outputLen, 'set':self.setOutputLen},
# {'name':'Plaintext Command', 'key':'ptcmd', 'type':'list', 'values':['p', 'h'], 'value':'p'},
{'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':'Data Format', 'key':'datafmt', 'type':'list', 'values':{'DEADBEEF':'',
# 'DE AD BE EF':' ',
# 'DE:AD:BE:EF':':',
# 'DE-AD-BE-EF':'-'}, 'value':''},
])
self.setConnection(self.ser, blockSignal=True)
def __init__(self):
AttackBaseClass.__init__(self)
self._project = None
self.attack = None
algos = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.analyzer.attacks.profiling_algorithms", False,
False, self)
self.getParams().addChildren([
{
'name': 'Algorithm',
'key': 'Prof_algo',
'type': 'list',
'values': algos,
'value': algos['Template Attack'],
'action': self.updateAlgorithm
}, #TODO: Should be called from the AES module to figure out # of bytes
])
AttackGenericParameters.__init__(self)
# Do not use absolute
self.useAbs = False
self.updateAlgorithm()
self.updateBytesVisible()
self.setAbsoluteMode(False)
def __init__(self):
ScopeTemplate.__init__(self)
scopes = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.capture.scopes.visascope_interface", True, False)
self.params.addChildren([
{
'name': 'Scope Type',
'key': 'type',
'type': 'list',
'values': scopes,
'value': scopes[VisaScopeInterface_MSO54831D._name],
'set': self.setCurrentScope,
'childmode': 'parent'
},
{
'name': 'Connect String',
'key': 'connStr',
'type': 'str',
'value': ''
},
{
'name': 'Example Strings',
'type': 'list',
'values': ['', 'TCPIP0::192.168.2.100::inst0::INSTR'],
'value': '',
'set': self.exampleString
},
])
self.params.init()
self.scopetype = None
self.setCurrentScope(self.findParam('type').getValue(type))
def __init__(self):
self._attack = None
self.valid_attacks = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.analyzer.attacks", True, True)
self.params = Parameter(name="Attack Settings", type="group")
self.params.addChildren([
{'name': 'Attack', 'type':'list', 'values':self.valid_attacks, 'get':self.getAttack, 'set':self.setAttack}
])
def __init__(self, api):
super(CWCaptureGUI, self).__init__(api, name=("ChipWhisperer" + u"\u2122" + " Capture " + CWCoreAPI.__version__), icon="cwiconC")
self.addExampleScripts(pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.scripts", False, False, self))
# Observers (callback methods)
self.api.sigNewInputData.connect(self.newTargetData)
self.api.sigConnectStatus.connect(self.connectStatusChanged)
self.api.sigTraceDone.connect(self.glitchMonitor.traceDone)
self.api.sigCampaignStart.connect(self.glitchMonitor.campaignStart)
self.api.sigCampaignDone.connect(self.glitchMonitor.campaignDone)
def __init__(self):
TargetTemplate.__init__(self)
spi_cons = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.capture.targets.spiflash_programmers", True, True)
self.spi = None
for c in spi_cons:
if c is not None:
self.spi = c
break
self.input = ""
self.textlength = 16
chip_names = []
for c in self.supported_chips:
chip_names.append(c['name'])
self._chip = self.supported_chips[0]
self.params.addChildren([
{
'name': 'Connection',
'type': 'list',
'key': 'con',
'values': spi_cons,
'get': self.getConnection,
'set': self.setConnection
},
{
'name': 'Input Length (Bytes)',
'type': 'int',
'range': (1, 512),
'default': 16,
'get': self.textLen,
'set': self.setTextLen
},
{
'name': 'Write Address (Hex)',
'key': 'addr',
'type': 'str',
'value': '0x1000'
},
{
'name': 'Flash Chip',
'type': 'list',
'values': chip_names,
'get': self.chipname,
'set': self.setChipname
},
])
if self.spi:
self.setConnection(self.spi, blockSignal=True)
def __init__(self, api):
super(CWAnalyzerGUI,
self).__init__(api,
name="ChipWhisperer" + u"\u2122" + " Analyzer " +
CWCoreAPI.__version__,
icon="cwiconA")
self.addExampleScripts(
pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.analyzer.scripts", False, False, self))
CWAnalyzerGUI.instance = self
self.attackScriptGen.reloadScripts()
def __init__(self):
super(PicoScopeInterface, self).__init__()
scopes = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.scopes.picoscope_interface", True, False)
self.getParams().addChildren([
{'name':'Scope Type', 'key':'type', 'type':'list', 'values':scopes, 'value':scopes["PS5000a"], 'action':self.setCurrentScope_act}
])
self.scopetype = None
self.advancedSettings = None
self.setCurrentScope(self.findParam('type').getValue())
def __init__(self):
AttackBaseClass.__init__(self)
self.attack = None
algos = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.analyzer.attacks.keeloq_dpa_algorithms", False,
False)
self.getParams().addChildren([
{'name':'Crypto Algorithm', 'key':'hw_algo', 'type':'list', 'values':{'Keeloq':models_keeloq}, 'value':models_keeloq, 'action':self.updateScript},
{'name':'Attack Algorithm', 'key':'attack_algo', 'type':'list', 'values':algos, 'value':algos[algos.keys()[0]], 'action':self.updateAlgorithm},
{'name':'Leakage Model', 'key':'hw_leak', 'type':'list', 'values':models_keeloq.leakagemodels, 'value':"LEAK_HW_CIPHERTEXT_BIT", 'action':self.updateScript},
{'name':'Trace Setup', 'key':'tracesetup', 'type':'group'}, # FIXME: "attack runs" makes no sense for our use
{'name':'Point Setup', 'key':'pointsetup', 'type':'group'}, # TODO: redundant when round timing is known
{'name':'Timing Setup (optional for some uses)', 'key':'keeloq_timing', 'type':'group', 'children':[
# {'name': '', 'type': 'label', 'value':"Position of rounds within traces", 'readonly': True},
{'name':'Round 528 (pos)', 'key':'round528', 'type':'int', 'value':301, 'default':301, 'action':self.updateScript},
{'name':'Round width (samples)', 'key':'roundwidth', 'type':'int', 'value':3, 'default':3, 'action':self.updateScript},
]},
{'name':'Analysis Options (for Partition modes)', 'key':'keeloq_analysis', 'type':'group', 'children':[
{'name':'Depth (rounds)', 'key':'depth', 'type':'int',
'help': "Analysis depth (rounds):\n"\
"------------------------\n\n"
"Specifies how many rounds deep to analyze. "\
"Used by certain partition modes in Trace Explorer.\n"\
"\n"\
"Analysis starts with the ciphertext and removes any known keystream. "\
"It will then go N rounds backwards, opening a window of N unknown keybits.\n"\
"\n"\
"**Usage in partition mode: FIXME**\n"\
"\n"\
"Show correlation for each of the 2^N possible keystreams. "\
"Trace number corresponds to the keystream used (ex. trace=5 keystream=0101).\n"\
"\n"\
"NOTE: The cipher applies the keystream over time, not instantly.\n"\
"\n",
'value':4, 'default':4, 'limits':(0, 8), 'action':self.updateScript},
{'name':'Known keystream', 'key':'keystream', 'type':'text', 'value':'', 'default':'', 'action':self.updateScript},
]},
])
self.findParam('hw_leak').hide()
AttackKeeloqParameters.__init__(self,
hasHardwareModel=False,
hasMultipleRuns=False)
self.setAnalysisAlgorithm(
self.findParam('attack_algo').getValue(), None, None)
# self.updateBytesVisible()
self.updateScript()
def __init__(self):
AttackBaseClass.__init__(self)
self.attack = None
algos = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.analyzer.attacks.cpa_algorithms", False, False)
self.getParams().addChildren([
{'name':'Algorithm', 'key':'CPA_algo', 'type':'list', 'values':algos, 'value':algos["Progressive"], 'action':self.updateAlgorithm}, #TODO: Should be called from the AES module to figure out # of bytes
])
AttackGenericParameters.__init__(self)
self.setAnalysisAlgorithm(self.findParam('CPA_algo').getValue(), None, None)
self.updateBytesVisible()
self.updateScript()
def __init__(self):
AttackBaseClass.__init__(self)
self.attack = None
algos = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.analyzer.attacks.cpa_algorithms", False, False)
self.getParams().addChildren([
{'name':'Algorithm', 'key':'CPA_algo', 'type':'list', 'values':algos, 'value':algos["Progressive"], 'action':self.updateAlgorithm}, #TODO: Should be called from the AES module to figure out # of bytes
])
AttackGenericParameters.__init__(self)
self.setAnalysisAlgorithm(self.findParam('CPA_algo').getValue(), None, None)
self.updateBytesVisible()
self.updateScript()
def __init__(self):
ScopeTemplate.__init__(self)
scopes = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.scopes.visascope_interface", True, False)
self.params.addChildren([
{'name':'Scope Type', 'key':'type', 'type':'list', 'values':scopes, 'value':scopes[VisaScopeInterface_MSO54831D._name], 'set':self.setCurrentScope, 'childmode':'parent'},
{'name':'Connect String', 'key':'connStr', 'type':'str', 'value':''},
{'name':'Example Strings', 'type':'list', 'values':['', 'TCPIP0::192.168.2.100::inst0::INSTR'], 'value':'', 'set':self.exampleString},
])
self.params.init()
self.scopetype = None
self.setCurrentScope(self.findParam('type').getValue(type))
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._active_ms = 10
self._delay_ms = 0
self.params.addChildren([
{'name':'Crash', 'type':'bool', 'key':'crash', 'default':True, 'get':self.getCrash, 'set':self.setCrash, 'psync': True}
])
self._crash = True
return
def __init__(self, api):
super(CWCaptureGUI,
self).__init__(api,
name=("ChipWhisperer" + u"\u2122" + " Capture " +
CWCoreAPI.__version__),
icon="cwiconC")
self.addExampleScripts(
pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.capture.scripts", False, False, self))
# Observers (callback methods)
self.api.sigNewInputData.connect(self.newTargetData)
self.api.sigConnectStatus.connect(self.connectStatusChanged)
self.api.sigTraceDone.connect(self.glitchMonitor.traceDone)
self.api.sigCampaignStart.connect(self.glitchMonitor.campaignStart)
self.api.sigCampaignDone.connect(self.glitchMonitor.campaignDone)
def __init__(self):
AttackBaseClass.__init__(self)
self._project = None
self.attack = None
algos = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.analyzer.attacks.profiling_algorithms", False, False, self)
self.getParams().addChildren([
{'name':'Algorithm', 'key':'Prof_algo', 'type':'list', 'values':algos, 'value':algos['Template Attack'], 'action':lambda p:self.updateAlgorithm(p.getValue())}, #TODO: Should be called from the AES module to figure out # of bytes
])
AttackGenericParameters.__init__(self)
# Do not use absolute
self.useAbs = False
self.updateAlgorithm(self.findParam('Prof_algo').getValue())
self.updateBytesVisible()
self.setAbsoluteMode(False)
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.protver = ''
# 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.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':[8, 16], 'default':16, 'get':self.textLen, 'set':self.setTextLen},
{'name':'Output Length (Bytes)', 'type':'list', 'values':[8, 16], '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':'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':'Data Format', 'key':'datafmt', 'type':'list', 'values':{'DEADBEEF':'',
# 'DE AD BE EF':' ',
# 'DE:AD:BE:EF':':',
# 'DE-AD-BE-EF':'-'}, 'value':''},
])
self.setConnection(self.ser, blockSignal=True)
def __init__(self):
super(PicoScopeInterface, self).__init__()
scopes = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.capture.scopes.picoscope_interface", True, False)
self.getParams().addChildren([{
'name': 'Scope Type',
'key': 'type',
'type': 'list',
'values': scopes,
'value': scopes["PS5000a"],
'action': self.setCurrentScope_act
}])
self.scopetype = None
self.advancedSettings = None
self.setCurrentScope(self.findParam('type').getValue())
def do_setup(scope, target):
# get serial console
ser_cons = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.capture.targets.simpleserial_readers", True, False)
ser = ser_cons[SimpleSerial_ChipWhispererLite._name]
ser.con(scope)
ser.setBaud(VITA_UART0_BAUD)
# setup trigger
scope.advancedSettings.cwEXTRA.setTargetGlitchOut('A', False)
scope.advancedSettings.cwEXTRA.setTargetGlitchOut('B', False)
scope.edgeTrigger.setPin(True, scope.edgeTrigger.PIN_PDIC)
scope.edgeTrigger.setEdgeStyle(scope.edgeTrigger.EDGE_RISING)
scope.advancedSettings.cwEXTRA.setTriggerModule(
CWExtraSettings.MODULE_EDGE)
# set glitch parameters
# trigger glitches with external trigger
scope.glitch.resetDcms()
scope.glitch.trigger_src = 'ext_single'
scope.glitch.output = 'enable_only' #'glitch_only'
scope.glitch.repeat = GLITCH_REPEAT
# set new clock
if USE_4X_CLOCK:
scope.io.hs2 = "disabled"
scope.clock.clkgen_freq = 4 * VITA_CLK_FREQ
scope.advancedSettings.cwEXTRA.setClkgenDivider(2)
scope.io.hs2 = 'clkgen_divided'
else:
scope.io.hs2 = 'clkgen'
# setup target
if KEY_LEN == 32:
target.findParam('cmdkey').setValue('K$KEY$\\n')
else:
target.findParam('cmdkey').setValue('k$KEY$\\n')
target.findParam('cmdgo').setValue('p$TEXT$\\n')
target.findParam('cmdout').setValue('r$RESPONSE$\\n')
target.key_len = KEY_LEN
target.init()
do_set_encrypt(target, ENCRYPT)
def __init__(self, parentParam=None):
ScopeTemplate.__init__(self, parentParam)
self.qtadc = openadc_qt.OpenADCQt()
self.qtadc.dataUpdated.connect(self.doDataUpdated)
# Bonus Modules for ChipWhisperer
self.advancedSettings = None
self.advancedSAD = None
self.digitalPattern = None
self.refreshTimer = timer.runTask(self.dcmTimeout, 1)
scopes = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.scopes.openadc_interface", True, False, self, self.qtadc)
self.scopetype = scopes[OpenADCInterface_NAEUSBChip._name]
self.params.addChildren([
{'name':'Connection', 'key':'con', 'type':'list', 'values':scopes, 'get':self.getCurrentScope, 'set':self.setCurrentScope, 'childmode':'parent'},
{'name':'Auto-Refresh DCM Status', 'type':'bool', 'value':True, 'action':self.setAutorefreshDCM}
])
self.params.init()
self.params.append(self.qtadc.getParams())
def __init__(self, prog_name="ChipWhisperer", prog_ver=""):
self.valid_traces = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.common.traces", True, True)
self._trace_format = None
self.params = Parameter(name="Project Settings", type="group")
self.params.addChildren([
{
'name': 'Trace Format',
'type': 'list',
'values': self.valid_traces,
'get': self.getTraceFormat,
'set': self.setTraceFormat
},
])
self.findParam("Trace Format").setValue(TraceContainerNative(),
addToList=True)
#self.traceParam = Parameter(name="Trace Settings", type='group', addLoadSave=True).register()
#self.params.getChild('Trace Format').stealDynamicParameters(self.traceParam)
self.sigFilenameChanged = util.Signal()
self.sigStatusChanged = util.Signal()
self.dirty = util.Observable(True)
self.settingsDict = {
'Project Name': "Untitled",
'Project File Version': "1.00",
'Project Author': "Unknown"
}
self.datadirectory = ""
self.config = ConfigObjProj(callback=self.configObjChanged)
self._traceManager = TraceManager().register()
self._traceManager.dirty.connect(self.__dirtyCallback)
self.setFilename(ProjectFormat.untitledFileName)
self.setProgramName(prog_name)
self.setProgramVersion(prog_ver)
if __debug__:
logging.debug('Created: ' + str(self))
def __init__(self):
ScopeTemplate.__init__(self)
self.qtadc = openadc_qt.OpenADCQt()
self.qtadc.dataUpdated.connect(self.newDataReceived)
# Bonus Modules for ChipWhisperer
self.advancedSettings = None
self.advancedSAD = None
self.digitalPattern = None
self._is_connected = False
scopes = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.capture.scopes.openadc_interface", True, False,
self.qtadc)
self.scopetype = scopes[OpenADCInterface_NAEUSBChip._name]
self.params.addChildren([{
'name': 'Connection',
'key': 'con',
'type': 'list',
'values': scopes,
'get': self.getCurrentScope,
'set': self.setCurrentScope,
'childmode': 'parent'
}, {
'name':
'Auto-Refresh DCM Status',
'type':
'bool',
'value':
True,
'action':
self.setAutorefreshDCM,
'help':
"Refresh status/info automatically every second."
}])
self.params.init()
self.params.append(self.qtadc.getParams())
self.refreshTimer = timer.runTask(self.dcmTimeout, 1)
self.refreshTimer.start()
def __init__(self):
AutoScript.__init__(self)
AnalysisSource.__init__(self)
PassiveTraceObserver.__init__(self)
self.getParams().getChild("Input").hide()
self._traceStart = 0
self._iterations = 1
self._tracePerAttack = 1
self._reportingInterval = 10
self._pointRange = (0,0)
self._targetSubkeys = []
self._project = None
self.useAbs = True
self.attack = None
self.getParams().addChildren([
{'name':'Attack Algorithm', 'type':'list', 'values':self._algos, 'get':self.getAlgorithm, 'set':self.setAlgorithm, 'action':self.updateScript, 'childmode': 'parent'}
])
models = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.analyzer.attacks.models", True, False)
self.getParams().addChildren([
{'name':'Crypto Algorithm', 'type':'list', 'values':models, 'value':models['AES 128'], 'action':self.refreshByteList, 'childmode':'child'},
{'name':'Points Range', 'key':'prange', 'type':'range', 'get':self.getPointRange, 'set':self.setPointRange, 'action':self.updateScript},
])
for m in models.itervalues():
m.sigParametersChanged.connect(self.updateScript)
self.getParams().addChildren([
{'name':'Starting Trace', 'key':'strace', 'type':'int', 'get':self.getTraceStart, 'set':self.setTraceStart, 'action':self.updateScript},
{'name':'Traces per Attack', 'key':'atraces', 'type':'int', 'limits':(1, 1E6), 'get':self.getTracesPerAttack, 'set':self.setTracesPerAttack, 'action':self.updateScript},
{'name':'Iterations', 'key':'runs', 'type':'int', 'limits':(1, 1E6), 'get':self.getIterations, 'set':self.setIterations, 'action':self.updateScript},
{'name':'Reporting Interval', 'key':'reportinterval', 'type':'int', 'get':self.getReportingInterval, 'set':self.setReportingInterval, 'action':self.updateScript},
])
self.getParams().init()
self.setAlgorithm(self._analysisAlgorithm)
self.refreshByteList()
self.updateScript()
if __debug__: logging.debug('Created: ' + str(self))
def __init__(self):
AutoScript.__init__(self)
AnalysisSource.__init__(self)
PassiveTraceObserver.__init__(self)
self.getParams().getChild("Input").hide()
self._traceStart = 0
self._iterations = 1
self._tracePerAttack = 1
self._reportingInterval = 10
self._pointRange = (0,0)
self._targetSubkeys = []
self._project = None
self.useAbs = True
self.attack = None
self.getParams().addChildren([
{'name':'Attack Algorithm', 'type':'list', 'values':self._algos, 'get':self.getAlgorithm, 'set':self.setAlgorithm, 'action':self.updateScript, 'childmode': 'parent'}
])
models = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.analyzer.attacks.models", True, False)
self.getParams().addChildren([
{'name':'Crypto Algorithm', 'type':'list', 'values':models, 'value':models['AES 128'], 'action':self.refreshByteList, 'childmode':'child'},
{'name':'Points Range', 'key':'prange', 'type':'range', 'get':self.getPointRange, 'set':self.setPointRange, 'action':self.updateScript},
])
for m in models.itervalues():
m.sigParametersChanged.connect(self.updateScript)
self.getParams().addChildren([
{'name':'Starting Trace', 'key':'strace', 'type':'int', 'get':self.getTraceStart, 'set':self.setTraceStart, 'action':self.updateScript},
{'name':'Traces per Attack', 'key':'atraces', 'type':'int', 'limits':(1, 1E6), 'get':self.getTracesPerAttack, 'set':self.setTracesPerAttack, 'action':self.updateScript},
{'name':'Iterations', 'key':'runs', 'type':'int', 'limits':(1, 1E6), 'get':self.getIterations, 'set':self.setIterations, 'action':self.updateScript},
{'name':'Reporting Interval', 'key':'reportinterval', 'type':'int', 'get':self.getReportingInterval, 'set':self.setReportingInterval, 'action':self.updateScript},
])
self.getParams().init()
self.setAlgorithm(self._analysisAlgorithm)
self.refreshByteList()
self.updateScript()
if __debug__: logging.debug('Created: ' + str(self))
def getClasses(cls):
if not cls.__classes:
cls.__classes = getPluginsInDictFromPackage("chipwhisperer.common.results", False, False)
return cls.__classes
def __init__(self):
self._algos = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.analyzer.attacks.cpa_algorithms", True, False)
self._analysisAlgorithm = self._algos["Progressive"]
AttackBaseClass.__init__(self)
self.updateScript()
def __init__(self):
self._algos = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.analyzer.attacks.profiling_algorithms", True, False)
self._analysisAlgorithm = self._algos["Template Attack"]
AttackBaseClass.__init__(self)
self.useAbs = False # Do not use absolute
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.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': [8, 16],
'default': 16,
'get': self.textLen,
'set': self.setTextLen
},
{
'name': 'Output Length (Bytes)',
'type': 'list',
'values': [8, 16],
'default': 16,
'get': self.outputLen,
'set': self.setOutputLen
},
# {'name':'Plaintext Command', 'key':'ptcmd', 'type':'list', 'values':['p', 'h'], 'value':'p'},
{
'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':'Data Format', 'key':'datafmt', 'type':'list', 'values':{'DEADBEEF':'',
# 'DE AD BE EF':' ',
# 'DE:AD:BE:EF':':',
# 'DE-AD-BE-EF':'-'}, 'value':''},
])
self.setConnection(self.ser, blockSignal=True)
def __init__(self):
CWCoreAPI.instance = self
self.sigNewProject = util.Signal()
self.sigNewScopeData = util.Signal()
self.sigConnectStatus = util.Signal()
self.sigAttackChanged = util.Signal()
self.sigNewInputData = util.Signal()
self.sigNewTextResponse = util.Signal()
self.sigTraceDone = util.Signal()
self.sigCampaignStart = util.Signal()
self.sigCampaignDone = util.Signal()
self.sigTracesChanged = util.Signal()
self.executingScripts = util.Observable(False)
self.valid_scopes = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.scopes", True, True)
self.valid_targets = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.targets", True, True)
self.valid_traces = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.common.traces", True, True)
self.valid_aux = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.auxiliary", True, True)
self.valid_acqPatterns = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.acq_patterns", True, False)
self.valid_attacks = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.analyzer.attacks", True, False)
self.valid_preprocessingModules = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.analyzer.preprocessing", False, True)
self.settings = Settings()
# Initialize default values
self._project = self._scope = self._target = self._attack = self._traceFormat = self._acqPattern = None
self._attack = self.valid_attacks.get("CPA", None)
self._acqPattern = self.valid_acqPatterns["Basic"]
self._auxList = [None] # TODO: implement it as a list in the whole class
self._numTraces = 50
self._numTraceSets = 1
self.params = Parameter(name='Generic Settings', type='group', addLoadSave=True).register()
self.params.addChildren([
{'name':'Scope Module', 'key':'scopeMod', 'type':'list', 'values':self.valid_scopes, 'get':self.getScope, 'set':self.setScope},
{'name':'Target Module', 'key':'targetMod', 'type':'list', 'values':self.valid_targets, 'get':self.getTarget, 'set':self.setTarget},
{'name':'Trace Format', 'type':'list', 'values':self.valid_traces, 'get':self.getTraceFormat, 'set':self.setTraceFormat},
{'name':'Auxiliary Module', 'type':'list', 'values':self.valid_aux, 'get':self.getAuxModule, 'set':self.setAux},
{'name':'Acquisition Settings', 'type':'group', 'children':[
{'name':'Number of Traces', 'type':'int', 'limits':(1, 1E9), 'get':self.getNumTraces, 'set':self.setNumTraces, 'linked':['Traces per Set']},
{'name':'Number of Sets', 'type':'int', 'limits':(1, 1E6), 'get':self.getNumTraceSets, 'set':self.setNumTraceSets, 'linked':['Traces per Set'], 'tip': 'Break acquisition into N sets, '
'which may cause data to be saved more frequently. The default capture driver requires that NTraces/NSets is small enough to avoid running out of system memory '
'as each segment is buffered into RAM before being written to disk.'},
{'name':'Traces per Set', 'type':'int', 'readonly':True, 'get':self.tracesPerSet},
{'name':'Key/Text Pattern', 'type':'list', 'values':self.valid_acqPatterns, 'get':self.getAcqPattern, 'set':self.setAcqPattern},
]},
])
self.scopeParam = Parameter(name="Scope Settings", type='group', addLoadSave=True).register()
self.params.getChild('Scope Module').stealDynamicParameters(self.scopeParam)
self.targetParam = Parameter(name="Target Settings", type='group', addLoadSave=True).register()
self.params.getChild('Target Module').stealDynamicParameters(self.targetParam)
self.traceParam = Parameter(name="Trace Settings", type='group', addLoadSave=True).register()
self.params.getChild('Trace Format').stealDynamicParameters(self.traceParam)
self.auxParam = Parameter(name="Aux Settings", type='group', addLoadSave=True).register()
self.params.getChild('Auxiliary Module').stealDynamicParameters(self.auxParam)
# self.attackParam = Parameter(name="Attack Settings", type='group')
# self.params.getChild('Attack Module').getDynamicParameters(self.attackParam)
self.newProject()
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()
def run_payload(scope, target, master_timeout=0, verbose=0):
if not hasattr(target, 'mmc'):
target = cwtarget()
target.con(scope)
# setup parameters needed for glitch the stm32f
scope.glitch.clk_src = 'clkgen'
scope.io.hs2 = "disabled"
scope.clock.clkgen_freq = VITA_CLK_FREQ
scope.io.hs2 = 'clkgen'
scope.io.tio1 = "serial_tx"
scope.io.tio2 = "serial_rx"
# setup MMC trigger to look for READ_SINGLE_BLOCK of 0x0 response
mmctrigger = scope.mmcTrigger
mmctrigger.setMatchCmd(True)
mmctrigger.setCmdIndex(MMCPacket.Cmd.READ_SINGLE_BLOCK.value)
mmctrigger.setDirection(2)
mmctrigger.setDataCompareOp(4)
mmctrigger.setTriggerData('0x800A')
mmctrigger.setTriggerNext(True)
# get MMC output
mmc = target.mmc
# get serial console
ser_cons = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.targets.simpleserial_readers", True, False)
ser = ser_cons[SimpleSerial_ChipWhispererLite._name]
ser.con(scope)
ser.setBaud(VITA_UART0_BAUD)
# format output table
headers = ['num packets', 'width', 'offset', 'success']
#glitch_display = GlitchResultsDisplay(headers)
# setup trigger
scope.advancedSettings.cwEXTRA.setTargetGlitchOut('A', False)
scope.advancedSettings.cwEXTRA.setTargetGlitchOut('B', False)
scope.advancedSettings.cwEXTRA.setTriggerModule(CWExtraSettings.MODULE_MMCTRIGGER)
# set glitch parameters
# trigger glitches with external trigger
scope.glitch.resetDcms()
scope.glitch.output = 'enable_only'
scope.glitch.trigger_src = 'ext_continuous'
# enable trigger
scope.advancedSettings.cwEXTRA.setTargetGlitchOut('A', True)
# init
target.init()
# power on and hold reset
if verbose:
print('Waiting for Vita to power on...')
scope.io.nrst = 'low'
scope.io.nrst = 'disabled'
scope.io.pdid = 'low'
while mmc.count() == 0:
pass
scope.io.pdid = 'disabled'
scope.io.nrst = 'low'
if verbose:
print('Starting glitch...')
success = False
tries = 0
while not success:
for offset in xrange(MIN_OFFSET, MAX_OFFSET+1, OFFSET_STEP):
# set offset from trigger
scope.glitch.ext_offset = offset
for width in xrange(MIN_WIDTH, MAX_WIDTH+1, WIDTH_STEP):
if verbose:
print('trying offset {}, width {}'.format(offset, width))
# reset device
scope.io.nrst = 'low'
scope.glitch.repeat = width
#scope.glitch.repeat = 1
# flush the buffer
time.sleep(TIME_RESET_HOLD)
timeout = GLITCH_FIND_TIMEOUT
# wait for target to finish
state = States.STARTUP
last_cnt = 0
while mmc.count() > 0:
pkt = mmc.read()
last_cnt = pkt.num
if verbose > 1:
print(str(pkt))
count = ser.inWaiting()
if count > 0:
print('WARNING: UART buffer non-empty')
ser.read(count)
scope.io.nrst = 'disabled'
timestamp = 0
reads = 0
while timeout > 0:
while mmc.count() > 0:
timeout = GLITCH_FIND_TIMEOUT
pkt = mmc.read()
if pkt.num < last_cnt:
timestamp = ((pkt.num + 0x10000 - last_cnt) * 0x100 * 1000.0) / CW_SYSCLK_FREQ
else:
timestamp = ((pkt.num - last_cnt) * 0x100 * 1000.0) / CW_SYSCLK_FREQ
last_cnt = pkt.num
if verbose > 1:
print('[{:10.5f}ms] {}'.format(timestamp, str(pkt)))
if pkt.is_req:
if pkt.cmd == MMCPacket.Cmd.READ_SINGLE_BLOCK:
reads += 1
if state == States.STARTUP:
if pkt.cmd == MMCPacket.Cmd.GO_IDLE_STATE:
state = States.IDLE
elif state == States.IDLE:
if pkt.cmd == MMCPacket.Cmd.READ_SINGLE_BLOCK and pkt.content > 0:
state = States.PAYLOAD_LOADING
elif pkt.cmd == MMCPacket.Cmd.GO_IDLE_STATE:
state = States.RESTARTED
elif state == States.PAYLOAD_LOADING:
if pkt.cmd == MMCPacket.Cmd.SEND_STATUS:
state = States.PAYLOAD_READ
elif pkt.cmd == MMCPacket.Cmd.GO_IDLE_STATE:
state = States.RESTARTED
elif state == States.PAYLOAD_READ:
if pkt.cmd == MMCPacket.Cmd.GO_IDLE_STATE:
state = States.RESTARTED
if state == States.RESTARTED:
timeout = -1
break
else:
time.sleep(0.1)
timeout -= 1
# for table display purposes
data = [offset, width, state, reads]
if verbose:
print(data)
#glitch_display.add_data(data)
if state == States.PAYLOAD_READ:
if verbose:
print('Waiting for UART data...')
timeout = WAIT_FOR_UART_TIMEOUT
count = 0
dat = ''
while timeout > 0:
count = ser.inWaiting()
if count > 0:
dat = ser.read(count)
if verbose:
print(dat)
break
time.sleep(0.1)
timeout -= 1
success = dat == 'HI\r\n'
if success:
break
if success:
break
tries += 1
if master_timeout > 0 and tries >= master_timeout:
return False
return success
# setup MMC trigger to look for READ_SINGLE_BLOCK of 0x0 response
mmctrigger = scope.mmcTrigger
mmctrigger.setMatchCmd(True)
mmctrigger.setCmdIndex(MMCPacket.Cmd.READ_SINGLE_BLOCK.value)
mmctrigger.setDirection(2)
mmctrigger.setDataCompareOp(1)
mmctrigger.setTriggerData('0x0')
mmctrigger.setTriggerNext(True)
# get MMC output
mmc = target.mmc
# get serial console
ser_cons = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.capture.targets.simpleserial_readers", True, False)
ser = ser_cons[SimpleSerial_ChipWhispererLite._name]
ser.con(scope)
ser.setBaud(VITA_UART0_BAUD)
# format output table
headers = ['num packets', 'width', 'offset', 'success']
#glitch_display = GlitchResultsDisplay(headers)
# set glitch parameters
# trigger glitches with external trigger
scope.glitch.trigger_src = 'ext_continuous'
scope.glitch.output = 'enable_only'
scope.io.hs2 = 'clkgen'
# enable trigger
def __init__(self):
self._algos = pluginmanager.getPluginsInDictFromPackage("chipwhisperer.analyzer.attacks.cpa_algorithms", True, False)
self._analysisAlgorithm = self._algos["Progressive"]
AttackBaseClass.__init__(self)
self.updateScript()
def getClasses(cls):
if not cls.__classes:
cls.__classes = getPluginsInDictFromPackage(
"chipwhisperer.common.results", False, False)
return cls.__classes
def __init__(self):
self._algos = pluginmanager.getPluginsInDictFromPackage(
"chipwhisperer.analyzer.attacks.profiling_algorithms", True, False)
self._analysisAlgorithm = self._algos["Template Attack"]
AttackBaseClass.__init__(self)
self.useAbs = False # Do not use absolute
def __init__(self, api):
super(CWAnalyzerGUI, self).__init__(api, name="ChipWhisperer" + u"\u2122" + " Analyzer " + CWCoreAPI.__version__, icon="cwiconA")
self.addExampleScripts(pluginmanager.getPluginsInDictFromPackage("chipwhisperer.analyzer.scripts", False, False, self))
CWAnalyzerGUI.instance = self
self.attackScriptGen.reloadScripts()
