def _loader(self, data):
"""
INTERNAL: Acts a middleman for loading values into the technique
object from a dict representation
:param data: A dict describing the technique
:raises UnknownTechniqueProperty: An error indicating that an
unexpected property was found on the technique
"""
for entry in data.keys():
if entry == 'techniqueID':
pass
elif entry == 'tactic':
self.tactic = data[entry]
elif entry == 'comment':
self.comment = data[entry]
elif entry == 'enabled':
self.enabled = data[entry]
elif entry == 'score':
self.score = data[entry]
elif entry == 'color':
self.color = data[entry]
elif entry == 'metadata':
self.metadata = data[entry]
elif entry == 'showSubtechniques':
self.showSubtechniques = data[entry]
else:
handler(
type(self).__name__,
"Unknown technique property: {}".format(entry))
raise UnknownTechniqueProperty
def gradient(self, gradient):
try:
loadChecker(type(self).__name__, gradient, ['colors', 'minValue', 'maxValue'], "gradient")
self.__gradient = Gradient(gradient['colors'], gradient['minValue'], gradient['maxValue'])
except MissingParameters as e:
handler(type(self).__name__, 'Gradient {} is missing parameters: '
'{}. Skipping.'
.format(gradient, e))
def techniqueID(self, techniqueID):
typeChecker(type(self).__name__, techniqueID, str, "techniqueID")
if not techniqueID.startswith('T'):
handler(type(self).__name__, '{} not a valid value for techniqueID'
.format(techniqueID))
raise BadInput
else:
self.__techniqueID = techniqueID
def gradient(self, gradient):
try:
self.__gradient = Gradient(gradient['colors'],
gradient['minValue'],
gradient['maxValue'])
except KeyError as e:
handler(
type(self).__name__, 'Gradient is missing parameters: {}. '
'Unable to load.'.format(e))
def filters(self, filters):
try:
temp = Filter(self.domain)
temp.stages = filters['stages']
temp.platforms = filters['platforms']
self.__filters = temp
except KeyError as e:
handler(
type(self).__name__, "Unable to properly extract "
"information from filter: {}.".format(e))
raise BadInput
def metadata(self, metadata):
typeChecker(type(self).__name__, metadata, list, "metadata")
self.__metadata = []
entry = ""
try:
for entry in metadata:
self.__metadata.append(Metadata(entry['name'], entry['value']))
except KeyError as e:
handler(
type(self).__name__, 'Metadata {} is missing parameters: '
'{}. Unable to load.'.format(entry, e))
def metadata(self, metadata):
typeChecker(type(self).__name__, metadata, list, "metadata")
self.__metadata = []
for entry in metadata:
try:
loadChecker(type(self).__name__, entry, ['name', 'value'], "metadata")
self.__metadata.append(Metadata(entry['name'], entry['value']))
except MissingParameters as e:
handler(type(self).__name__, 'Metadata {} is missing parameters: '
'{}. Skipping.'
.format(entry, e))
def legendItems(self, legendItems):
typeChecker(type(self).__name__, legendItems, list, "legendItems")
self.__legendItems = []
entry = ""
try:
for entry in legendItems:
temp = LegendItem(entry['label'], entry['color'])
self.__legendItems.append(temp)
except KeyError as e:
handler(
type(self).__name__, 'LegendItem {} is missing parameters:'
' {}. Unable to load.'.format(entry, e))
def versions(self, versions):
typeChecker(type(self).__name__, versions, dict, "version")
attack = UNSETVALUE
if 'attack' in versions:
attack = versions['attack']
try:
loadChecker(type(self).__name__, versions, ['layer', 'navigator'], "versions")
self.__versions = Versions(versions['layer'], attack, versions['navigator'])
except MissingParameters as e:
handler(type(self).__name__, 'versions {} is missing parameters: '
'{}. Skipping.'
.format(versions, e))
def legendItems(self, legendItems):
typeChecker(type(self).__name__, legendItems, list, "legendItems")
self.__legendItems = []
for entry in legendItems:
try:
loadChecker(type(self).__name__, entry, ['label', 'color'], "legendItem")
temp = LegendItem(entry['label'], entry['color'])
self.__legendItems.append(temp)
except MissingParameters as e:
handler(type(self).__name__, 'Legend Item {} is missing parameters: '
'{}. Skipping.'
.format(entry, e))
def filters(self, filters):
temp = Filter(self.domain)
try:
loadChecker(type(self).__name__, filters, ['platforms'], "filters")
# force upgrade to v4
if 'stages' in filters:
print('[Filters] - V3 Field "stages" detected. Upgrading Filters object to V4.')
temp.platforms = filters['platforms']
self.__filters = temp
except MissingParameters as e:
handler(type(self).__name__, 'Filters {} is missing parameters: '
'{}. Skipping.'
.format(filters, e))
def techniques(self, techniques):
typeChecker(type(self).__name__, techniques, list, "techniques")
self.__techniques = []
entry = ""
try:
for entry in techniques:
temp = Technique(entry['techniqueID'])
temp._loader(entry)
self.__techniques.append(temp)
except KeyError as e:
handler(
type(self).__name__, "Unable to properly extract "
"information from technique {}: {}.".format(entry, e))
raise BadInput
def techniques(self, techniques):
typeChecker(type(self).__name__, techniques, list, "techniques")
self.__techniques = []
for entry in techniques:
try:
loadChecker(type(self).__name__, entry, ['techniqueID'], "technique")
temp = Technique(entry['techniqueID'])
temp._loader(entry)
self.__techniques.append(temp)
except MissingParameters as e:
handler(type(self).__name__, 'Technique {} is missing parameters: '
'{}. Skipping.'
.format(entry, e))
def _linker(self, field, data):
"""
INTERNAL: Acts as a middleman routing the settings of values
within the layer
:param field: The value field being set
:param data: The corresponding data to set that field to
:raises UnknownLayerProperty: An error indicating that an
unexpected property was identified
"""
if field == 'description':
self.description = data
elif field.startswith('version'):
if not field.endswith('s'):
# force upgrade
print(
'[Version] - V3 version field detected. Upgrading to V4 Versions object.'
)
ver_obj = dict(layer="4.0", navigator="4.0")
self.versions = ver_obj
else:
self.versions = data
elif field == 'filters':
self.filters = data
elif field == 'sorting':
self.sorting = data
elif field == 'layout':
self.layout = data
elif field == 'hideDisabled':
self.hideDisabled = data
elif field == 'techniques':
self.techniques = data
elif field == 'gradient':
self.gradient = data
elif field == 'legendItems':
self.legendItems = data
elif field == 'showTacticRowBackground':
self.showTacticRowBackground = data
elif field == 'tacticRowBackground':
self.tacticRowBackground = data
elif field == 'selectTechniquesAcrossTactics':
self.selectTechniquesAcrossTactics = data
elif field == 'selectSubtechniquesWithParent':
self.selectSubtechniquesWithParent = data
elif field == 'metadata':
self.metadata = data
else:
handler(
type(self).__name__,
"Unknown layer property: {}".format(field))
raise UnknownLayerProperty
def _linker(self, field, data):
"""
INTERNAL: Acts as a middleman routing the settings of values
within the layer
:param field: The value field being set
:param data: The corresponding data to set that field to
:raises UnknownLayerProperty: An error indicating that an
unexpected property was identified
"""
if field == 'description':
self.description = data
elif field == 'filters':
self.filters = data
elif field == 'sorting':
self.sorting = data
elif field == 'layout':
self.layout = data
elif field == 'hideDisabled':
self.hideDisabled = data
elif field == 'techniques':
self.techniques = data
elif field == 'gradient':
self.gradient = data
elif field == 'legendItems':
self.legendItems = data
elif field == 'showTacticRowBackground':
self.showTacticRowBackground = data
elif field == 'tacticRowBackground':
self.tacticRowBackground = data
elif field == 'selectTechniquesAcrossTactics':
self.selectTechniquesAcrossTactics = data
elif field == 'selectSubtechniquesWithParent':
self.selectSubtechniquesWithParent = data
elif field == 'metadata':
self.metadata = data
else:
handler(
type(self).__name__,
"Unknown layer property: {}".format(field))
raise UnknownLayerProperty
def _build(self):
"""
Loads the data stored in self.data into a LayerObj (self.layer)
"""
try:
self.__layer = _LayerObj(self._data['name'], self._data['domain'])
except BadType or BadInput as e:
handler(
type(self).__name__, 'Layer is malformed: {}. '
'Unable to load.'.format(e))
self.__layer = None
return
except KeyError as e:
handler(
type(self).__name__, 'Layer is missing parameters: {}. '
'Unable to load.'.format(e))
self.__layer = None
return
for key in self._data:
if key not in ['name', 'domain']:
try:
self.__layer._linker(key, self._data[key])
except Exception as e:
if self.strict:
handler(
type(self).__name__, "{} error. "
"Unable to load.".format(str(
e.__class__.__name__)))
self.__layer = None
return
