1# Copyright (c) 2017, The MITRE Corporation. All rights reserved. 2# See LICENSE.txt for complete terms. 3 4#!/usr/bin/env python 5# -*- coding: utf-8 -*- 6 7# 8# Generated Thu Apr 11 15:06:24 2013 by generateDS.py version 2.9a. 9# 10import sys 11 12import cybox.bindings.cybox_core as cybox_core_binding 13import cybox.bindings.cybox_common as cybox_common_binding 14from mixbox.binding_utils import * 15 16from stix.bindings import lookup_extension, register_extension 17import stix.bindings.stix_common as stix_common_binding 18import stix.bindings.data_marking as data_marking_binding 19 20XML_NS = "http://stix.mitre.org/Incident-1" 21 22# 23# Data representation classes. 24# 25 26class PropertyAffectedType(GeneratedsSuper): 27 subclass = None 28 superclass = None 29 def __init__(self, Property=None, Description_Of_Effect=None, Type_Of_Availability_Loss=None, Duration_Of_Availability_Loss=None, Non_Public_Data_Compromised=None): 30 self.Property = Property 31 if Description_Of_Effect is None: 32 self.Description_Of_Effect = [] 33 else: 34 self.Description_Of_Effect = Description_Of_Effect 35 self.Type_Of_Availability_Loss = Type_Of_Availability_Loss 36 self.Duration_Of_Availability_Loss = Duration_Of_Availability_Loss 37 self.Non_Public_Data_Compromised = Non_Public_Data_Compromised 38 def factory(*args_, **kwargs_): 39 if PropertyAffectedType.subclass: 40 return PropertyAffectedType.subclass(*args_, **kwargs_) 41 else: 42 return PropertyAffectedType(*args_, **kwargs_) 43 factory = staticmethod(factory) 44 def get_Property(self): return self.Property 45 def set_Property(self, Property): self.Property = Property 46 def insert_Description_Of_Effect(self, index, value): self.Description_Of_Effect[index] = value 47 def add_Description_Of_Effect(self, value): self.Description_Of_Effect.append(value) 48 def get_Description_Of_Effect(self): return self.Description_Of_Effect 49 def set_Description_Of_Effect(self, Description_Of_Effect): self.Description_Of_Effect = Description_Of_Effect 50 def get_Type_Of_Availability_Loss(self): return self.Type_Of_Availability_Loss 51 def set_Type_Of_Availability_Loss(self, Type_Of_Availability_Loss): self.Type_Of_Availability_Loss = Type_Of_Availability_Loss 52 def get_Duration_Of_Availability_Loss(self): return self.Duration_Of_Availability_Loss 53 def set_Duration_Of_Availability_Loss(self, Duration_Of_Availability_Loss): self.Duration_Of_Availability_Loss = Duration_Of_Availability_Loss 54 def get_Non_Public_Data_Compromised(self): return self.Non_Public_Data_Compromised 55 def set_Non_Public_Data_Compromised(self, Non_Public_Data_Compromised): self.Non_Public_Data_Compromised = Non_Public_Data_Compromised 56 def hasContent_(self): 57 if ( 58 self.Property is not None or 59 self.Description_Of_Effect or 60 self.Type_Of_Availability_Loss is not None or 61 self.Duration_Of_Availability_Loss is not None or 62 self.Non_Public_Data_Compromised is not None 63 ): 64 return True 65 else: 66 return False 67 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='PropertyAffectedType', namespacedef_='', pretty_print=True): 68 if pretty_print: 69 eol_ = '\n' 70 else: 71 eol_ = '' 72 showIndent(lwrite, level, pretty_print) 73 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 74 already_processed = set() 75 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='PropertyAffectedType') 76 if self.hasContent_(): 77 lwrite('>%s' % (eol_, )) 78 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 79 showIndent(lwrite, level, pretty_print) 80 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 81 else: 82 lwrite('/>%s' % (eol_, )) 83 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='PropertyAffectedType'): 84 pass 85 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='PropertyAffectedType', fromsubclass_=False, pretty_print=True): 86 if pretty_print: 87 eol_ = '\n' 88 else: 89 eol_ = '' 90 if self.Property is not None: 91 self.Property.export(lwrite, level, nsmap, namespace_, name_='Property', pretty_print=pretty_print) 92 for doe in self.Description_Of_Effect: 93 doe.export(lwrite, level, nsmap, namespace_, name_='Description_Of_Effect', pretty_print=pretty_print) 94 if self.Type_Of_Availability_Loss is not None: 95 self.Type_Of_Availability_Loss.export(lwrite, level, nsmap, namespace_, name_='Type_Of_Availability_Loss', pretty_print=pretty_print) 96 if self.Duration_Of_Availability_Loss is not None: 97 self.Duration_Of_Availability_Loss.export(lwrite, level, nsmap, namespace_, name_='Duration_Of_Availability_Loss', pretty_print=pretty_print) 98 if self.Non_Public_Data_Compromised is not None: 99 self.Non_Public_Data_Compromised.export(lwrite, level, nsmap, namespace_, name_='Non_Public_Data_Compromised', pretty_print=pretty_print) 100 def build(self, node): 101 self.__sourcenode__ = node 102 already_processed = set() 103 self.buildAttributes(node, node.attrib, already_processed) 104 for child in node: 105 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 106 self.buildChildren(child, node, nodeName_) 107 def buildAttributes(self, node, attrs, already_processed): 108 pass 109 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 110 if nodeName_ == 'Property': 111 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 112 obj_.build(child_) 113 self.set_Property(obj_) 114 elif nodeName_ == 'Description_Of_Effect': 115 obj_ = stix_common_binding.StructuredTextType.factory() 116 obj_.build(child_) 117 self.add_Description_Of_Effect(obj_) 118 elif nodeName_ == 'Type_Of_Availability_Loss': 119 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 120 obj_.build(child_) 121 self.set_Type_Of_Availability_Loss(obj_) 122 elif nodeName_ == 'Duration_Of_Availability_Loss': 123 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 124 obj_.build(child_) 125 self.set_Duration_Of_Availability_Loss(obj_) 126 elif nodeName_ == 'Non_Public_Data_Compromised': 127 obj_ = NonPublicDataCompromisedType.factory() 128 obj_.build(child_) 129 self.set_Non_Public_Data_Compromised(obj_) 130# end class PropertyAffectedType 131 132class AffectedAssetType(GeneratedsSuper): 133 subclass = None 134 superclass = None 135 def __init__(self, Type=None, Description=None, Business_Function_Or_Role=None, Ownership_Class=None, Management_Class=None, Location_Class=None, Location=None, Nature_Of_Security_Effect=None, Structured_Description=None): 136 self.Type = Type 137 if Description is None: 138 self.Description = [] 139 else: 140 self.Description = Description 141 142 if Business_Function_Or_Role is None: 143 self.Business_Function_Or_Role = [] 144 else: 145 self.Business_Function_Or_Role = Business_Function_Or_Role 146 147 self.Ownership_Class = Ownership_Class 148 self.Management_Class = Management_Class 149 self.Location_Class = Location_Class 150 self.Location = Location 151 self.Nature_Of_Security_Effect = Nature_Of_Security_Effect 152 self.Structured_Description = Structured_Description 153 def factory(*args_, **kwargs_): 154 if AffectedAssetType.subclass: 155 return AffectedAssetType.subclass(*args_, **kwargs_) 156 else: 157 return AffectedAssetType(*args_, **kwargs_) 158 factory = staticmethod(factory) 159 def get_Type(self): return self.Type 160 def set_Type(self, Type): self.Type = Type 161 def insert_Description(self, index, value): self.Description[index] = value 162 def add_Description(self, Description): self.Description.append(Description) 163 def get_Description(self): return self.Description 164 def set_Description(self, Description): self.Description = Description 165 def insert_Business_Function_Or_Role(self, index, value): self.Business_Function_Or_Role[index] = value 166 def add_Business_Function_Or_Role(self, Business_Function_Or_Role): self.Business_Function_Or_Role.append(Business_Function_Or_Role) 167 def get_Business_Function_Or_Role(self): return self.Business_Function_Or_Role 168 def set_Business_Function_Or_Role(self, Business_Function_Or_Role): self.Business_Function_Or_Role = Business_Function_Or_Role 169 def get_Ownership_Class(self): return self.Ownership_Class 170 def set_Ownership_Class(self, Ownership_Class): self.Ownership_Class = Ownership_Class 171 def get_Management_Class(self): return self.Management_Class 172 def set_Management_Class(self, Management_Class): self.Management_Class = Management_Class 173 def get_Location_Class(self): return self.Location_Class 174 def set_Location_Class(self, Location_Class): self.Location_Class = Location_Class 175 def get_Location(self): return self.Location 176 def set_Location(self, Location): self.Location = Location 177 def get_Nature_Of_Security_Effect(self): return self.Nature_Of_Security_Effect 178 def set_Nature_Of_Security_Effect(self, Nature_Of_Security_Effect): self.Nature_Of_Security_Effect = Nature_Of_Security_Effect 179 def get_Structured_Description(self): return self.Structured_Description 180 def set_Structured_Description(self, Structured_Description): self.Structured_Description = Structured_Description 181 def hasContent_(self): 182 if ( 183 self.Type is not None or 184 self.Description or 185 self.Business_Function_Or_Role or 186 self.Ownership_Class is not None or 187 self.Management_Class is not None or 188 self.Location_Class is not None or 189 self.Location is not None or 190 self.Nature_Of_Security_Effect is not None or 191 self.Structured_Description is not None 192 ): 193 return True 194 else: 195 return False 196 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='AffectedAssetType', namespacedef_='', pretty_print=True): 197 if pretty_print: 198 eol_ = '\n' 199 else: 200 eol_ = '' 201 showIndent(lwrite, level, pretty_print) 202 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 203 already_processed = set() 204 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='AffectedAssetType') 205 if self.hasContent_(): 206 lwrite('>%s' % (eol_, )) 207 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 208 showIndent(lwrite, level, pretty_print) 209 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 210 else: 211 lwrite('/>%s' % (eol_, )) 212 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='AffectedAssetType'): 213 pass 214 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='AffectedAssetType', fromsubclass_=False, pretty_print=True): 215 if pretty_print: 216 eol_ = '\n' 217 else: 218 eol_ = '' 219 if self.Type is not None: 220 self.Type.export(lwrite, level, nsmap, namespace_, name_='Type', pretty_print=pretty_print) 221 for Description in self.Description: 222 Description.export(lwrite, level, nsmap, namespace_, name_='Description', pretty_print=pretty_print) 223 for Business_Function_Or_Role in self.Business_Function_Or_Role: 224 Business_Function_Or_Role.export(lwrite, level, nsmap, namespace_, name_='Business_Function_Or_Role', pretty_print=pretty_print) 225 if self.Ownership_Class is not None: 226 self.Ownership_Class.export(lwrite, level, nsmap, namespace_, name_='Ownership_Class', pretty_print=pretty_print) 227 if self.Management_Class is not None: 228 self.Management_Class.export(lwrite, level, nsmap, namespace_, name_='Management_Class', pretty_print=pretty_print) 229 if self.Location_Class is not None: 230 self.Location_Class.export(lwrite, level, nsmap, namespace_, name_='Location_Class', pretty_print=pretty_print) 231 if self.Location is not None: 232 self.Location.export(lwrite, level, nsmap, namespace_, name_='Location', pretty_print=pretty_print) 233 if self.Nature_Of_Security_Effect is not None: 234 self.Nature_Of_Security_Effect.export(lwrite, level, nsmap, namespace_, name_='Nature_Of_Security_Effect', pretty_print=pretty_print) 235 if self.Structured_Description is not None: 236 self.Structured_Description.export(lwrite, level, "%s:" % (nsmap[namespace_]), name_='Structured_Description', pretty_print=pretty_print) 237 def build(self, node): 238 self.__sourcenode__ = node 239 already_processed = set() 240 self.buildAttributes(node, node.attrib, already_processed) 241 for child in node: 242 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 243 self.buildChildren(child, node, nodeName_) 244 def buildAttributes(self, node, attrs, already_processed): 245 pass 246 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 247 if nodeName_ == 'Type': 248 obj_ = AssetTypeType.factory() 249 obj_.build(child_) 250 self.set_Type(obj_) 251 elif nodeName_ == 'Description': 252 obj_ = stix_common_binding.StructuredTextType.factory() 253 obj_.build(child_) 254 self.add_Description(obj_) 255 elif nodeName_ == 'Business_Function_Or_Role': 256 obj_ = stix_common_binding.StructuredTextType.factory() 257 obj_.build(child_) 258 self.add_Business_Function_Or_Role(obj_) 259 elif nodeName_ == 'Ownership_Class': 260 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 261 obj_.build(child_) 262 self.set_Ownership_Class(obj_) 263 elif nodeName_ == 'Management_Class': 264 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 265 obj_.build(child_) 266 self.set_Management_Class(obj_) 267 elif nodeName_ == 'Location_Class': 268 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 269 obj_.build(child_) 270 self.set_Location_Class(obj_) 271 elif nodeName_ == 'Location': 272 from .extensions.address import ciq_address_3_0 273 obj_ = lookup_extension(child_).factory() 274 obj_.build(child_) 275 self.set_Location(obj_) 276 elif nodeName_ == 'Nature_Of_Security_Effect': 277 obj_ = NatureOfSecurityEffectType.factory() 278 obj_.build(child_) 279 self.set_Nature_Of_Security_Effect(obj_) 280 elif nodeName_ == 'Structured_Description': 281 obj_ = cybox_core_binding.ObservablesType.factory() 282 obj_.build(child_) 283 self.set_Structured_Description(obj_) 284# end class AffectedAssetType 285 286class ImpactAssessmentType(GeneratedsSuper): 287 """The ImpactAssessmentType specifies a summary assessment of impact 288 for this cyber threat Incident.""" 289 subclass = None 290 superclass = None 291 def __init__(self, Direct_Impact_Summary=None, Indirect_Impact_Summary=None, Total_Loss_Estimation=None, Impact_Qualification=None, Effects=None, External_Impact_Assessment_Model=None): 292 self.Direct_Impact_Summary = Direct_Impact_Summary 293 self.Indirect_Impact_Summary = Indirect_Impact_Summary 294 self.Total_Loss_Estimation = Total_Loss_Estimation 295 self.Impact_Qualification = Impact_Qualification 296 self.Effects = Effects 297 self.External_Impact_Assessment_Model = External_Impact_Assessment_Model 298 def factory(*args_, **kwargs_): 299 if ImpactAssessmentType.subclass: 300 return ImpactAssessmentType.subclass(*args_, **kwargs_) 301 else: 302 return ImpactAssessmentType(*args_, **kwargs_) 303 factory = staticmethod(factory) 304 def get_Direct_Impact_Summary(self): return self.Direct_Impact_Summary 305 def set_Direct_Impact_Summary(self, Direct_Impact_Summary): self.Direct_Impact_Summary = Direct_Impact_Summary 306 def get_Indirect_Impact_Summary(self): return self.Indirect_Impact_Summary 307 def set_Indirect_Impact_Summary(self, Indirect_Impact_Summary): self.Indirect_Impact_Summary = Indirect_Impact_Summary 308 def get_Total_Loss_Estimation(self): return self.Total_Loss_Estimation 309 def set_Total_Loss_Estimation(self, Total_Loss_Estimation): self.Total_Loss_Estimation = Total_Loss_Estimation 310 def get_Impact_Qualification(self): return self.Impact_Qualification 311 def set_Impact_Qualification(self, Impact_Qualification): self.Impact_Qualification = Impact_Qualification 312 def get_Effects(self): return self.Effects 313 def set_Effects(self, Effects): self.Effects = Effects 314 def get_External_Impact_Assessment_Model(self): return self.External_Impact_Assessment_Model 315 def set_External_Impact_Assessment_Model(self, External_Impact_Assessment_Model): self.External_Impact_Assessment_Model = External_Impact_Assessment_Model 316 def hasContent_(self): 317 if ( 318 self.Direct_Impact_Summary is not None or 319 self.Indirect_Impact_Summary is not None or 320 self.Total_Loss_Estimation is not None or 321 self.Impact_Qualification is not None or 322 self.Effects is not None or 323 self.External_Impact_Assessment_Model is not None 324 ): 325 return True 326 else: 327 return False 328 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ImpactAssessmentType', namespacedef_='', pretty_print=True): 329 if pretty_print: 330 eol_ = '\n' 331 else: 332 eol_ = '' 333 showIndent(lwrite, level, pretty_print) 334 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 335 already_processed = set() 336 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ImpactAssessmentType') 337 if self.hasContent_(): 338 lwrite('>%s' % (eol_, )) 339 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 340 showIndent(lwrite, level, pretty_print) 341 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 342 else: 343 lwrite('/>%s' % (eol_, )) 344 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='ImpactAssessmentType'): 345 pass 346 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ImpactAssessmentType', fromsubclass_=False, pretty_print=True): 347 if pretty_print: 348 eol_ = '\n' 349 else: 350 eol_ = '' 351 if self.Direct_Impact_Summary is not None: 352 self.Direct_Impact_Summary.export(lwrite, level, nsmap, namespace_, name_='Direct_Impact_Summary', pretty_print=pretty_print) 353 if self.Indirect_Impact_Summary is not None: 354 self.Indirect_Impact_Summary.export(lwrite, level, nsmap, namespace_, name_='Indirect_Impact_Summary', pretty_print=pretty_print) 355 if self.Total_Loss_Estimation is not None: 356 self.Total_Loss_Estimation.export(lwrite, level, nsmap, namespace_, name_='Total_Loss_Estimation', pretty_print=pretty_print) 357 if self.Impact_Qualification is not None: 358 self.Impact_Qualification.export(lwrite, level, nsmap, namespace_, name_='Impact_Qualification', pretty_print=pretty_print) 359 if self.Effects is not None: 360 self.Effects.export(lwrite, level, nsmap, namespace_, name_='Effects', pretty_print=pretty_print) 361 if self.External_Impact_Assessment_Model is not None: 362 self.External_Impact_Assessment_Model.export(lwrite, level, nsmap, namespace_, name_='External_Impact_Assessment_Model', pretty_print=pretty_print) 363 def build(self, node): 364 self.__sourcenode__ = node 365 already_processed = set() 366 self.buildAttributes(node, node.attrib, already_processed) 367 for child in node: 368 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 369 self.buildChildren(child, node, nodeName_) 370 def buildAttributes(self, node, attrs, already_processed): 371 pass 372 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 373 if nodeName_ == 'Direct_Impact_Summary': 374 obj_ = DirectImpactSummaryType.factory() 375 obj_.build(child_) 376 self.set_Direct_Impact_Summary(obj_) 377 elif nodeName_ == 'Indirect_Impact_Summary': 378 obj_ = IndirectImpactSummaryType.factory() 379 obj_.build(child_) 380 self.set_Indirect_Impact_Summary(obj_) 381 elif nodeName_ == 'Total_Loss_Estimation': 382 obj_ = TotalLossEstimationType.factory() 383 obj_.build(child_) 384 self.set_Total_Loss_Estimation(obj_) 385 elif nodeName_ == 'Impact_Qualification': 386 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 387 obj_.build(child_) 388 self.set_Impact_Qualification(obj_) 389 elif nodeName_ == 'Effects': 390 obj_ = EffectsType.factory() 391 obj_.build(child_) 392 self.set_Effects(obj_) 393 elif nodeName_ == 'External_Impact_Assessment_Model': 394 type_name_ = child_.attrib.get( 395 '{http://www.w3.org/2001/XMLSchema-instance}type') 396 if type_name_ is None: 397 type_name_ = child_.attrib.get('type') 398 if type_name_ is not None: 399 type_names_ = type_name_.split(':') 400 if len(type_names_) == 1: 401 type_name_ = type_names_[0] 402 else: 403 type_name_ = type_names_[1] 404 class_ = globals()[type_name_] 405 obj_ = class_.factory() 406 obj_.build(child_) 407 else: 408 raise NotImplementedError( 409 'Class not implemented for <External_Impact_Assessment_Model> element') 410 self.set_External_Impact_Assessment_Model(obj_) 411# end class ImpactAssessmentType 412 413class ExternalImpactAssessmentModelType(GeneratedsSuper): 414 """The ExternalImpactAssessmentModelType is an abstract type enabling 415 the definition through extension of incident impact assessment 416 models external to STIX.Specifies the name of the externally 417 defined impact assessment model.Specifies a URL reference for 418 the externally defined impact assessment model.""" 419 subclass = None 420 superclass = None 421 def __init__(self, model_name=None, model_reference=None): 422 self.model_name = _cast(None, model_name) 423 self.model_reference = _cast(None, model_reference) 424 pass 425 def factory(*args_, **kwargs_): 426 if ExternalImpactAssessmentModelType.subclass: 427 return ExternalImpactAssessmentModelType.subclass(*args_, **kwargs_) 428 else: 429 return ExternalImpactAssessmentModelType(*args_, **kwargs_) 430 factory = staticmethod(factory) 431 def get_model_name(self): return self.model_name 432 def set_model_name(self, model_name): self.model_name = model_name 433 def get_model_reference(self): return self.model_reference 434 def set_model_reference(self, model_reference): self.model_reference = model_reference 435 def hasContent_(self): 436 if ( 437 438 ): 439 return True 440 else: 441 return False 442 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ExternalImpactAssessmentModelType', namespacedef_='', pretty_print=True): 443 if pretty_print: 444 eol_ = '\n' 445 else: 446 eol_ = '' 447 showIndent(lwrite, level, pretty_print) 448 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 449 already_processed = set() 450 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ExternalImpactAssessmentModelType') 451 if self.hasContent_(): 452 lwrite('>%s' % (eol_, )) 453 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 454 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 455 else: 456 lwrite('/>%s' % (eol_, )) 457 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='ExternalImpactAssessmentModelType'): 458 if self.model_name is not None and 'model_name' not in already_processed: 459 already_processed.add('model_name') 460 lwrite(' model_name=%s' % (quote_attrib(self.model_name), )) 461 if self.model_reference is not None and 'model_reference' not in already_processed: 462 already_processed.add('model_reference') 463 lwrite(' model_reference=%s' % (quote_attrib(self.model_reference), )) 464 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ExternalImpactAssessmentModelType', fromsubclass_=False, pretty_print=True): 465 pass 466 def build(self, node): 467 self.__sourcenode__ = node 468 already_processed = set() 469 self.buildAttributes(node, node.attrib, already_processed) 470 for child in node: 471 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 472 self.buildChildren(child, node, nodeName_) 473 def buildAttributes(self, node, attrs, already_processed): 474 value = find_attr_value_('model_name', node) 475 if value is not None and 'model_name' not in already_processed: 476 already_processed.add('model_name') 477 self.model_name = value 478 value = find_attr_value_('model_reference', node) 479 if value is not None and 'model_reference' not in already_processed: 480 already_processed.add('model_reference') 481 self.model_reference = value 482 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 483 pass 484# end class ExternalImpactAssessmentModelType 485 486class COATakenType(GeneratedsSuper): 487 subclass = None 488 superclass = None 489 def __init__(self, Time=None, Contributors=None, Course_Of_Action=None, extensiontype_=None): 490 self.Time = Time 491 self.Contributors = Contributors 492 self.Course_Of_Action = Course_Of_Action 493 self.extensiontype_ = extensiontype_ 494 def factory(*args_, **kwargs_): 495 if COATakenType.subclass: 496 return COATakenType.subclass(*args_, **kwargs_) 497 else: 498 return COATakenType(*args_, **kwargs_) 499 factory = staticmethod(factory) 500 def get_Time(self): return self.Time 501 def set_Time(self, Time): self.Time = Time 502 def get_Contributors(self): return self.Contributors 503 def set_Contributors(self, Contributors): self.Contributors = Contributors 504 def get_Course_Of_Action(self): return self.Course_Of_Action 505 def set_Course_Of_Action(self, Course_Of_Action): self.Course_Of_Action = Course_Of_Action 506 def get_extensiontype_(self): return self.extensiontype_ 507 def set_extensiontype_(self, extensiontype_): self.extensiontype_ = extensiontype_ 508 def hasContent_(self): 509 if ( 510 self.Time is not None or 511 self.Contributors is not None or 512 self.Course_Of_Action is not None 513 ): 514 return True 515 else: 516 return False 517 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='COATakenType', namespacedef_='', pretty_print=True): 518 if pretty_print: 519 eol_ = '\n' 520 else: 521 eol_ = '' 522 showIndent(lwrite, level, pretty_print) 523 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 524 already_processed = set() 525 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='COATakenType') 526 if self.hasContent_(): 527 lwrite('>%s' % (eol_, )) 528 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 529 showIndent(lwrite, level, pretty_print) 530 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 531 else: 532 lwrite('/>%s' % (eol_, )) 533 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='COATakenType'): 534 if self.extensiontype_ is not None and 'xsi:type' not in already_processed: 535 already_processed.add('xsi:type') 536 lwrite(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') 537 lwrite(' xsi:type="%s"' % self.extensiontype_) 538 pass 539 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='COATakenType', fromsubclass_=False, pretty_print=True): 540 if pretty_print: 541 eol_ = '\n' 542 else: 543 eol_ = '' 544 if self.Time is not None: 545 self.Time.export(lwrite, level, nsmap, namespace_, name_='Time', pretty_print=pretty_print) 546 if self.Contributors is not None: 547 self.Contributors.export(lwrite, level, nsmap, namespace_, name_='Contributors', pretty_print=pretty_print) 548 if self.Course_Of_Action is not None: 549 self.Course_Of_Action.export(lwrite, level, nsmap, namespace_, name_='Course_Of_Action', pretty_print=pretty_print) 550 def build(self, node): 551 self.__sourcenode__ = node 552 already_processed = set() 553 self.buildAttributes(node, node.attrib, already_processed) 554 for child in node: 555 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 556 self.buildChildren(child, node, nodeName_) 557 def buildAttributes(self, node, attrs, already_processed): 558 value = find_attr_value_('xsi:type', node) 559 if value is not None and 'xsi:type' not in already_processed: 560 already_processed.add('xsi:type') 561 self.extensiontype_ = value 562 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 563 if nodeName_ == 'Time': 564 obj_ = COATimeType.factory() 565 obj_.build(child_) 566 self.set_Time(obj_) 567 elif nodeName_ == 'Contributors': 568 obj_ = ContributorsType.factory() 569 obj_.build(child_) 570 self.set_Contributors(obj_) 571 elif nodeName_ == 'Course_Of_Action': 572 from . import course_of_action 573 obj_ = lookup_extension(child_, stix_common_binding.CourseOfActionBaseType).factory() 574 obj_.build(child_) 575 self.set_Course_Of_Action(obj_) 576# end class COATakenType 577 578class JournalEntryType(GeneratedsSuper): 579 """The JournalEntryType is optional and provides journal notes for 580 information discovered during the handling of the 581 Incident.Specifies the author of the JournalEntry note.Specifies 582 the date and time that the JournalEntry note was written.In 583 order to avoid ambiguity, it is strongly suggest that all 584 timestamps include a specification of the timezone if it is 585 known.Represents the precision of the associated time value. If 586 omitted, the default is "second", meaning the timestamp is 587 precise to the full field value. Digits in the timestamp that 588 are required by the xs:dateTime datatype but are beyond the 589 specified precision should be zeroed out.""" 590 subclass = None 591 superclass = None 592 def __init__(self, time=None, time_precision='second', author=None, valueOf_=None): 593 self.time = _cast(None, time) 594 self.time_precision = _cast(None, time_precision) 595 self.author = _cast(None, author) 596 self.valueOf_ = valueOf_ 597 def factory(*args_, **kwargs_): 598 if JournalEntryType.subclass: 599 return JournalEntryType.subclass(*args_, **kwargs_) 600 else: 601 return JournalEntryType(*args_, **kwargs_) 602 factory = staticmethod(factory) 603 def get_time(self): return self.time 604 def set_time(self, time): self.time = time 605 def get_time_precision(self): return self.time_precision 606 def set_time_precision(self, time_precision): self.time_precision = time_precision 607 def get_author(self): return self.author 608 def set_author(self, author): self.author = author 609 def get_valueOf_(self): return self.valueOf_ 610 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 611 def hasContent_(self): 612 if ( 613 self.valueOf_ 614 ): 615 return True 616 else: 617 return False 618 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='JournalEntryType', namespacedef_='', pretty_print=True): 619 if pretty_print: 620 eol_ = '\n' 621 else: 622 eol_ = '' 623 showIndent(lwrite, level, pretty_print) 624 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 625 already_processed = set() 626 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='JournalEntryType') 627 if self.hasContent_(): 628 lwrite('>') 629 lwrite(quote_xml(self.valueOf_)) 630 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 631 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 632 else: 633 lwrite('/>%s' % (eol_, )) 634 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='JournalEntryType'): 635 if self.time is not None and 'time' not in already_processed: 636 already_processed.add('time') 637 lwrite(' time="%s"' % self.gds_format_datetime(self.time, input_name='time')) 638 if self.time_precision is not None and 'time_precision' not in already_processed: 639 already_processed.add('time_precision') 640 lwrite(' time_precision=%s' % (quote_attrib(self.time_precision), )) 641 if self.author is not None and 'author' not in already_processed: 642 already_processed.add('author') 643 lwrite(' author=%s' % (quote_attrib(self.author), )) 644 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='JournalEntryType', fromsubclass_=False, pretty_print=True): 645 pass 646 def build(self, node): 647 self.__sourcenode__ = node 648 already_processed = set() 649 self.buildAttributes(node, node.attrib, already_processed) 650 self.valueOf_ = get_all_text_(node) 651 for child in node: 652 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 653 self.buildChildren(child, node, nodeName_) 654 def buildAttributes(self, node, attrs, already_processed): 655 value = find_attr_value_('time', node) 656 if value is not None and 'time' not in already_processed: 657 already_processed.add('time') 658 try: 659 self.time = self.gds_parse_datetime(value, node, 'time') 660 except ValueError as exp: 661 raise ValueError('Bad date-time attribute (time): %s' % exp) 662 value = find_attr_value_('time_precision', node) 663 if value is not None and 'time_precision' not in already_processed: 664 already_processed.add('time_precision') 665 self.time_precision = value 666 value = find_attr_value_('author', node) 667 if value is not None and 'author' not in already_processed: 668 already_processed.add('author') 669 self.author = value 670 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 671 pass 672# end class JournalEntryType 673 674 675class COARequestedType(COATakenType): 676 """Specifies a suggested level of priority to be applied to this 677 requested COA.""" 678 subclass = None 679 superclass = COATakenType 680 def __init__(self, Time=None, Contributors=None, Course_Of_Action=None, priority=None): 681 super(COARequestedType, self).__init__(Time=Time, Contributors=Contributors, Course_Of_Action=Course_Of_Action) 682 self.priority = _cast(None, priority) 683 pass 684 def factory(*args_, **kwargs_): 685 if COARequestedType.subclass: 686 return COARequestedType.subclass(*args_, **kwargs_) 687 else: 688 return COARequestedType(*args_, **kwargs_) 689 factory = staticmethod(factory) 690 def get_priority(self): return self.priority 691 def set_priority(self, priority): self.priority = priority 692 def hasContent_(self): 693 if ( 694 super(COARequestedType, self).hasContent_() 695 ): 696 return True 697 else: 698 return False 699 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='COARequestedType', namespacedef_='', pretty_print=True): 700 if pretty_print: 701 eol_ = '\n' 702 else: 703 eol_ = '' 704 showIndent(lwrite, level, pretty_print) 705 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 706 already_processed = set() 707 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='COARequestedType') 708 if self.hasContent_(): 709 lwrite('>%s' % (eol_, )) 710 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 711 showIndent(lwrite, level, pretty_print) 712 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 713 else: 714 lwrite('/>%s' % (eol_, )) 715 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='COARequestedType'): 716 super(COARequestedType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='COARequestedType') 717 if self.priority is not None and 'priority' not in already_processed: 718 already_processed.add('priority') 719 lwrite(' priority=%s' % (quote_attrib(self.priority), )) 720 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='COARequestedType', fromsubclass_=False, pretty_print=True): 721 super(COARequestedType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, True, pretty_print=pretty_print) 722 def build(self, node): 723 self.__sourcenode__ = node 724 already_processed = set() 725 self.buildAttributes(node, node.attrib, already_processed) 726 for child in node: 727 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 728 self.buildChildren(child, node, nodeName_) 729 def buildAttributes(self, node, attrs, already_processed): 730 value = find_attr_value_('priority', node) 731 if value is not None and 'priority' not in already_processed: 732 already_processed.add('priority') 733 self.priority = value 734 super(COARequestedType, self).buildAttributes(node, attrs, already_processed) 735 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 736 super(COARequestedType, self).buildChildren(child_, node, nodeName_, True) 737 pass 738# end class COARequestedType 739 740class ContributorsType(GeneratedsSuper): 741 subclass = None 742 superclass = None 743 def __init__(self, Contributor=None): 744 if Contributor is None: 745 self.Contributor = [] 746 else: 747 self.Contributor = Contributor 748 def factory(*args_, **kwargs_): 749 if ContributorsType.subclass: 750 return ContributorsType.subclass(*args_, **kwargs_) 751 else: 752 return ContributorsType(*args_, **kwargs_) 753 factory = staticmethod(factory) 754 def get_Contributor(self): return self.Contributor 755 def set_Contributor(self, Contributor): self.Contributor = Contributor 756 def add_Contributor(self, value): self.Contributor.append(value) 757 def insert_Contributor(self, index, value): self.Contributor[index] = value 758 def hasContent_(self): 759 if ( 760 self.Contributor 761 ): 762 return True 763 else: 764 return False 765 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ContributorsType', namespacedef_='', pretty_print=True): 766 if pretty_print: 767 eol_ = '\n' 768 else: 769 eol_ = '' 770 showIndent(lwrite, level, pretty_print) 771 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 772 already_processed = set() 773 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ContributorsType') 774 if self.hasContent_(): 775 lwrite('>%s' % (eol_, )) 776 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 777 showIndent(lwrite, level, pretty_print) 778 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 779 else: 780 lwrite('/>%s' % (eol_, )) 781 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='ContributorsType'): 782 pass 783 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ContributorsType', fromsubclass_=False, pretty_print=True): 784 if pretty_print: 785 eol_ = '\n' 786 else: 787 eol_ = '' 788 for Contributor_ in self.Contributor: 789 Contributor_.export(lwrite, level, "%s:" % (nsmap[namespace_]), name_='Contributor', pretty_print=pretty_print) 790 def build(self, node): 791 self.__sourcenode__ = node 792 already_processed = set() 793 self.buildAttributes(node, node.attrib, already_processed) 794 for child in node: 795 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 796 self.buildChildren(child, node, nodeName_) 797 def buildAttributes(self, node, attrs, already_processed): 798 pass 799 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 800 if nodeName_ == 'Contributor': 801 obj_ = cybox_common_binding.ContributorType.factory() 802 obj_.build(child_) 803 self.Contributor.append(obj_) 804# end class ContributorsType 805 806class COATimeType(GeneratedsSuper): 807 subclass = None 808 superclass = None 809 def __init__(self, Start=None, End=None): 810 self.Start = Start 811 self.End = End 812 def factory(*args_, **kwargs_): 813 if COATimeType.subclass: 814 return COATimeType.subclass(*args_, **kwargs_) 815 else: 816 return COATimeType(*args_, **kwargs_) 817 factory = staticmethod(factory) 818 def get_Start(self): return self.Start 819 def set_Start(self, Start): self.Start = Start 820 def get_End(self): return self.End 821 def set_End(self, End): self.End = End 822 def hasContent_(self): 823 if ( 824 self.Start is not None or 825 self.End is not None 826 ): 827 return True 828 else: 829 return False 830 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='COATimeType', namespacedef_='', pretty_print=True): 831 if pretty_print: 832 eol_ = '\n' 833 else: 834 eol_ = '' 835 showIndent(lwrite, level, pretty_print) 836 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 837 already_processed = set() 838 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='COATimeType') 839 if self.hasContent_(): 840 lwrite('>%s' % (eol_, )) 841 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 842 showIndent(lwrite, level, pretty_print) 843 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 844 else: 845 lwrite('/>%s' % (eol_, )) 846 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='COATimeType'): 847 pass 848 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='COATimeType', fromsubclass_=False, pretty_print=True): 849 if pretty_print: 850 eol_ = '\n' 851 else: 852 eol_ = '' 853 if self.Start is not None: 854 self.Start.export(lwrite, level, nsmap, namespace_, name_='Start', pretty_print=pretty_print) 855 if self.End is not None: 856 self.End.export(lwrite, level, nsmap, namespace_, name_='End', pretty_print=pretty_print) 857 def build(self, node): 858 self.__sourcenode__ = node 859 already_processed = set() 860 self.buildAttributes(node, node.attrib, already_processed) 861 for child in node: 862 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 863 self.buildChildren(child, node, nodeName_) 864 def buildAttributes(self, node, attrs, already_processed): 865 pass 866 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 867 if nodeName_ == 'Start': 868 obj_ = stix_common_binding.DateTimeWithPrecisionType.factory() 869 obj_.build(child_) 870 self.set_Start(obj_) 871 elif nodeName_ == 'End': 872 obj_ = stix_common_binding.DateTimeWithPrecisionType.factory() 873 obj_.build(child_) 874 self.set_End(obj_) 875# end class COATimeType 876 877class LossEstimationType(GeneratedsSuper): 878 """Specifies the estimated financial loss for the Incident.Specifies 879 the ISO 4217 currency code if other than USD""" 880 subclass = None 881 superclass = None 882 def __init__(self, iso_currency_code=None, amount=None): 883 self.iso_currency_code = _cast(None, iso_currency_code) 884 self.amount = _cast(None, amount) 885 pass 886 def factory(*args_, **kwargs_): 887 if LossEstimationType.subclass: 888 return LossEstimationType.subclass(*args_, **kwargs_) 889 else: 890 return LossEstimationType(*args_, **kwargs_) 891 factory = staticmethod(factory) 892 def get_iso_currency_code(self): return self.iso_currency_code 893 def set_iso_currency_code(self, iso_currency_code): self.iso_currency_code = iso_currency_code 894 def get_amount(self): return self.amount 895 def set_amount(self, amount): self.amount = amount 896 def hasContent_(self): 897 if ( 898 899 ): 900 return True 901 else: 902 return False 903 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='LossEstimationType', namespacedef_='', pretty_print=True): 904 if pretty_print: 905 eol_ = '\n' 906 else: 907 eol_ = '' 908 showIndent(lwrite, level, pretty_print) 909 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 910 already_processed = set() 911 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='LossEstimationType') 912 if self.hasContent_(): 913 lwrite('>%s' % (eol_, )) 914 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 915 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 916 else: 917 lwrite('/>%s' % (eol_, )) 918 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='LossEstimationType'): 919 if self.iso_currency_code is not None and 'iso_currency_code' not in already_processed: 920 already_processed.add('iso_currency_code') 921 lwrite(' iso_currency_code=%s' % (quote_attrib(self.iso_currency_code), )) 922 if self.amount is not None and 'amount' not in already_processed: 923 already_processed.add('amount') 924 lwrite(' amount=%s' % (quote_attrib(self.amount), )) 925 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='LossEstimationType', fromsubclass_=False, pretty_print=True): 926 pass 927 def build(self, node): 928 self.__sourcenode__ = node 929 already_processed = set() 930 self.buildAttributes(node, node.attrib, already_processed) 931 for child in node: 932 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 933 self.buildChildren(child, node, nodeName_) 934 def buildAttributes(self, node, attrs, already_processed): 935 value = find_attr_value_('iso_currency_code', node) 936 if value is not None and 'iso_currency_code' not in already_processed: 937 already_processed.add('iso_currency_code') 938 self.iso_currency_code = value 939 value = find_attr_value_('amount', node) 940 if value is not None and 'amount' not in already_processed: 941 already_processed.add('amount') 942 self.amount = value 943 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 944 pass 945# end class LossEstimationType 946 947class TotalLossEstimationType(GeneratedsSuper): 948 subclass = None 949 superclass = None 950 def __init__(self, Initial_Reported_Total_Loss_Estimation=None, Actual_Total_Loss_Estimation=None): 951 self.Initial_Reported_Total_Loss_Estimation = Initial_Reported_Total_Loss_Estimation 952 self.Actual_Total_Loss_Estimation = Actual_Total_Loss_Estimation 953 def factory(*args_, **kwargs_): 954 if TotalLossEstimationType.subclass: 955 return TotalLossEstimationType.subclass(*args_, **kwargs_) 956 else: 957 return TotalLossEstimationType(*args_, **kwargs_) 958 factory = staticmethod(factory) 959 def get_Initial_Reported_Total_Loss_Estimation(self): return self.Initial_Reported_Total_Loss_Estimation 960 def set_Initial_Reported_Total_Loss_Estimation(self, Initial_Reported_Total_Loss_Estimation): self.Initial_Reported_Total_Loss_Estimation = Initial_Reported_Total_Loss_Estimation 961 def get_Actual_Total_Loss_Estimation(self): return self.Actual_Total_Loss_Estimation 962 def set_Actual_Total_Loss_Estimation(self, Actual_Total_Loss_Estimation): self.Actual_Total_Loss_Estimation = Actual_Total_Loss_Estimation 963 def hasContent_(self): 964 if ( 965 self.Initial_Reported_Total_Loss_Estimation is not None or 966 self.Actual_Total_Loss_Estimation is not None 967 ): 968 return True 969 else: 970 return False 971 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='TotalLossEstimationType', namespacedef_='', pretty_print=True): 972 if pretty_print: 973 eol_ = '\n' 974 else: 975 eol_ = '' 976 showIndent(lwrite, level, pretty_print) 977 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 978 already_processed = set() 979 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='TotalLossEstimationType') 980 if self.hasContent_(): 981 lwrite('>%s' % (eol_, )) 982 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 983 showIndent(lwrite, level, pretty_print) 984 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 985 else: 986 lwrite('/>%s' % (eol_, )) 987 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='TotalLossEstimationType'): 988 pass 989 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='TotalLossEstimationType', fromsubclass_=False, pretty_print=True): 990 if pretty_print: 991 eol_ = '\n' 992 else: 993 eol_ = '' 994 if self.Initial_Reported_Total_Loss_Estimation is not None: 995 self.Initial_Reported_Total_Loss_Estimation.export(lwrite, level, nsmap, namespace_, name_='Initial_Reported_Total_Loss_Estimation', pretty_print=pretty_print) 996 if self.Actual_Total_Loss_Estimation is not None: 997 self.Actual_Total_Loss_Estimation.export(lwrite, level, nsmap, namespace_, name_='Actual_Total_Loss_Estimation', pretty_print=pretty_print) 998 def build(self, node): 999 self.__sourcenode__ = node 1000 already_processed = set() 1001 self.buildAttributes(node, node.attrib, already_processed) 1002 for child in node: 1003 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1004 self.buildChildren(child, node, nodeName_) 1005 def buildAttributes(self, node, attrs, already_processed): 1006 pass 1007 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1008 if nodeName_ == 'Initial_Reported_Total_Loss_Estimation': 1009 obj_ = LossEstimationType.factory() 1010 obj_.build(child_) 1011 self.set_Initial_Reported_Total_Loss_Estimation(obj_) 1012 elif nodeName_ == 'Actual_Total_Loss_Estimation': 1013 obj_ = LossEstimationType.factory() 1014 obj_.build(child_) 1015 self.set_Actual_Total_Loss_Estimation(obj_) 1016# end class TotalLossEstimationType 1017 1018class IndirectImpactSummaryType(GeneratedsSuper): 1019 subclass = None 1020 superclass = None 1021 def __init__(self, Loss_Of_Competitive_Advantage=None, Brand_And_Market_Damage=None, Increased_Operating_Costs=None, Legal_And_Regulatory_Costs=None): 1022 self.Loss_Of_Competitive_Advantage = Loss_Of_Competitive_Advantage 1023 self.Brand_And_Market_Damage = Brand_And_Market_Damage 1024 self.Increased_Operating_Costs = Increased_Operating_Costs 1025 self.Legal_And_Regulatory_Costs = Legal_And_Regulatory_Costs 1026 def factory(*args_, **kwargs_): 1027 if IndirectImpactSummaryType.subclass: 1028 return IndirectImpactSummaryType.subclass(*args_, **kwargs_) 1029 else: 1030 return IndirectImpactSummaryType(*args_, **kwargs_) 1031 factory = staticmethod(factory) 1032 def get_Loss_Of_Competitive_Advantage(self): return self.Loss_Of_Competitive_Advantage 1033 def set_Loss_Of_Competitive_Advantage(self, Loss_Of_Competitive_Advantage): self.Loss_Of_Competitive_Advantage = Loss_Of_Competitive_Advantage 1034 def get_Brand_And_Market_Damage(self): return self.Brand_And_Market_Damage 1035 def set_Brand_And_Market_Damage(self, Brand_And_Market_Damage): self.Brand_And_Market_Damage = Brand_And_Market_Damage 1036 def get_Increased_Operating_Costs(self): return self.Increased_Operating_Costs 1037 def set_Increased_Operating_Costs(self, Increased_Operating_Costs): self.Increased_Operating_Costs = Increased_Operating_Costs 1038 def get_Legal_And_Regulatory_Costs(self): return self.Legal_And_Regulatory_Costs 1039 def set_Legal_And_Regulatory_Costs(self, Legal_And_Regulatory_Costs): self.Legal_And_Regulatory_Costs = Legal_And_Regulatory_Costs 1040 def hasContent_(self): 1041 if ( 1042 self.Loss_Of_Competitive_Advantage is not None or 1043 self.Brand_And_Market_Damage is not None or 1044 self.Increased_Operating_Costs is not None or 1045 self.Legal_And_Regulatory_Costs is not None 1046 ): 1047 return True 1048 else: 1049 return False 1050 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='IndirectImpactSummaryType', namespacedef_='', pretty_print=True): 1051 if pretty_print: 1052 eol_ = '\n' 1053 else: 1054 eol_ = '' 1055 showIndent(lwrite, level, pretty_print) 1056 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1057 already_processed = set() 1058 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='IndirectImpactSummaryType') 1059 if self.hasContent_(): 1060 lwrite('>%s' % (eol_, )) 1061 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1062 showIndent(lwrite, level, pretty_print) 1063 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1064 else: 1065 lwrite('/>%s' % (eol_, )) 1066 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='IndirectImpactSummaryType'): 1067 pass 1068 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='IndirectImpactSummaryType', fromsubclass_=False, pretty_print=True): 1069 if pretty_print: 1070 eol_ = '\n' 1071 else: 1072 eol_ = '' 1073 if self.Loss_Of_Competitive_Advantage is not None: 1074 self.Loss_Of_Competitive_Advantage.export(lwrite, level, nsmap, namespace_, name_='Loss_Of_Competitive_Advantage', pretty_print=pretty_print) 1075 if self.Brand_And_Market_Damage is not None: 1076 self.Brand_And_Market_Damage.export(lwrite, level, nsmap, namespace_, name_='Brand_And_Market_Damage', pretty_print=pretty_print) 1077 if self.Increased_Operating_Costs is not None: 1078 self.Increased_Operating_Costs.export(lwrite, level, nsmap, namespace_, name_='Increased_Operating_Costs', pretty_print=pretty_print) 1079 if self.Legal_And_Regulatory_Costs is not None: 1080 self.Legal_And_Regulatory_Costs.export(lwrite, level, nsmap, namespace_, name_='Legal_And_Regulatory_Costs', pretty_print=pretty_print) 1081 def build(self, node): 1082 self.__sourcenode__ = node 1083 already_processed = set() 1084 self.buildAttributes(node, node.attrib, already_processed) 1085 for child in node: 1086 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1087 self.buildChildren(child, node, nodeName_) 1088 def buildAttributes(self, node, attrs, already_processed): 1089 pass 1090 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1091 if nodeName_ == 'Loss_Of_Competitive_Advantage': 1092 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 1093 obj_.build(child_) 1094 self.set_Loss_Of_Competitive_Advantage(obj_) 1095 elif nodeName_ == 'Brand_And_Market_Damage': 1096 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 1097 obj_.build(child_) 1098 self.set_Brand_And_Market_Damage(obj_) 1099 elif nodeName_ == 'Increased_Operating_Costs': 1100 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 1101 obj_.build(child_) 1102 self.set_Increased_Operating_Costs(obj_) 1103 elif nodeName_ == 'Legal_And_Regulatory_Costs': 1104 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 1105 obj_.build(child_) 1106 self.set_Legal_And_Regulatory_Costs(obj_) 1107# end class IndirectImpactSummaryType 1108 1109class DirectImpactSummaryType(GeneratedsSuper): 1110 subclass = None 1111 superclass = None 1112 def __init__(self, Asset_Losses=None, Business_Mission_Disruption=None, Response_And_Recovery_Costs=None): 1113 self.Asset_Losses = Asset_Losses 1114 self.Business_Mission_Disruption = Business_Mission_Disruption 1115 self.Response_And_Recovery_Costs = Response_And_Recovery_Costs 1116 def factory(*args_, **kwargs_): 1117 if DirectImpactSummaryType.subclass: 1118 return DirectImpactSummaryType.subclass(*args_, **kwargs_) 1119 else: 1120 return DirectImpactSummaryType(*args_, **kwargs_) 1121 factory = staticmethod(factory) 1122 def get_Asset_Losses(self): return self.Asset_Losses 1123 def set_Asset_Losses(self, Asset_Losses): self.Asset_Losses = Asset_Losses 1124 def get_Business_Mission_Disruption(self): return self.Business_Mission_Disruption 1125 def set_Business_Mission_Disruption(self, Business_Mission_Disruption): self.Business_Mission_Disruption = Business_Mission_Disruption 1126 def get_Response_And_Recovery_Costs(self): return self.Response_And_Recovery_Costs 1127 def set_Response_And_Recovery_Costs(self, Response_And_Recovery_Costs): self.Response_And_Recovery_Costs = Response_And_Recovery_Costs 1128 def hasContent_(self): 1129 if ( 1130 self.Asset_Losses is not None or 1131 self.Business_Mission_Disruption is not None or 1132 self.Response_And_Recovery_Costs is not None 1133 ): 1134 return True 1135 else: 1136 return False 1137 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='DirectImpactSummaryType', namespacedef_='', pretty_print=True): 1138 if pretty_print: 1139 eol_ = '\n' 1140 else: 1141 eol_ = '' 1142 showIndent(lwrite, level, pretty_print) 1143 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1144 already_processed = set() 1145 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='DirectImpactSummaryType') 1146 if self.hasContent_(): 1147 lwrite('>%s' % (eol_, )) 1148 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1149 showIndent(lwrite, level, pretty_print) 1150 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1151 else: 1152 lwrite('/>%s' % (eol_, )) 1153 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='DirectImpactSummaryType'): 1154 pass 1155 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='DirectImpactSummaryType', fromsubclass_=False, pretty_print=True): 1156 if pretty_print: 1157 eol_ = '\n' 1158 else: 1159 eol_ = '' 1160 if self.Asset_Losses is not None: 1161 self.Asset_Losses.export(lwrite, level, nsmap, namespace_, name_='Asset_Losses', pretty_print=pretty_print) 1162 if self.Business_Mission_Disruption is not None: 1163 self.Business_Mission_Disruption.export(lwrite, level, nsmap, namespace_, name_='Business-Mission_Disruption', pretty_print=pretty_print) 1164 if self.Response_And_Recovery_Costs is not None: 1165 self.Response_And_Recovery_Costs.export(lwrite, level, nsmap, namespace_, name_='Response_And_Recovery_Costs', pretty_print=pretty_print) 1166 def build(self, node): 1167 self.__sourcenode__ = node 1168 already_processed = set() 1169 self.buildAttributes(node, node.attrib, already_processed) 1170 for child in node: 1171 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1172 self.buildChildren(child, node, nodeName_) 1173 def buildAttributes(self, node, attrs, already_processed): 1174 pass 1175 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1176 if nodeName_ == 'Asset_Losses': 1177 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 1178 obj_.build(child_) 1179 self.set_Asset_Losses(obj_) 1180 elif nodeName_ == 'Business-Mission_Disruption': 1181 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 1182 obj_.build(child_) 1183 self.set_Business_Mission_Disruption(obj_) 1184 elif nodeName_ == 'Response_And_Recovery_Costs': 1185 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 1186 obj_.build(child_) 1187 self.set_Response_And_Recovery_Costs(obj_) 1188# end class DirectImpactSummaryType 1189 1190class NatureOfSecurityEffectType(GeneratedsSuper): 1191 subclass = None 1192 superclass = None 1193 def __init__(self, Property_Affected=None): 1194 if Property_Affected is None: 1195 self.Property_Affected = [] 1196 else: 1197 self.Property_Affected = Property_Affected 1198 def factory(*args_, **kwargs_): 1199 if NatureOfSecurityEffectType.subclass: 1200 return NatureOfSecurityEffectType.subclass(*args_, **kwargs_) 1201 else: 1202 return NatureOfSecurityEffectType(*args_, **kwargs_) 1203 factory = staticmethod(factory) 1204 def get_Property_Affected(self): return self.Property_Affected 1205 def set_Property_Affected(self, Property_Affected): self.Property_Affected = Property_Affected 1206 def add_Property_Affected(self, value): self.Property_Affected.append(value) 1207 def insert_Property_Affected(self, index, value): self.Property_Affected[index] = value 1208 def hasContent_(self): 1209 if ( 1210 self.Property_Affected 1211 ): 1212 return True 1213 else: 1214 return False 1215 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='NatureOfSecurityEffectType', namespacedef_='', pretty_print=True): 1216 if pretty_print: 1217 eol_ = '\n' 1218 else: 1219 eol_ = '' 1220 showIndent(lwrite, level, pretty_print) 1221 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1222 already_processed = set() 1223 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='NatureOfSecurityEffectType') 1224 if self.hasContent_(): 1225 lwrite('>%s' % (eol_, )) 1226 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1227 showIndent(lwrite, level, pretty_print) 1228 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1229 else: 1230 lwrite('/>%s' % (eol_, )) 1231 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='NatureOfSecurityEffectType'): 1232 pass 1233 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='NatureOfSecurityEffectType', fromsubclass_=False, pretty_print=True): 1234 if pretty_print: 1235 eol_ = '\n' 1236 else: 1237 eol_ = '' 1238 for Property_Affected_ in self.Property_Affected: 1239 Property_Affected_.export(lwrite, level, nsmap, namespace_, name_='Property_Affected', pretty_print=pretty_print) 1240 def build(self, node): 1241 self.__sourcenode__ = node 1242 already_processed = set() 1243 self.buildAttributes(node, node.attrib, already_processed) 1244 for child in node: 1245 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1246 self.buildChildren(child, node, nodeName_) 1247 def buildAttributes(self, node, attrs, already_processed): 1248 pass 1249 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1250 if nodeName_ == 'Property_Affected': 1251 obj_ = PropertyAffectedType.factory() 1252 obj_.build(child_) 1253 self.Property_Affected.append(obj_) 1254# end class NatureOfSecurityEffectType 1255 1256class HistoryItemType(GeneratedsSuper): 1257 subclass = None 1258 superclass = None 1259 def __init__(self, Action_Entry=None, Journal_Entry=None): 1260 self.Action_Entry = Action_Entry 1261 self.Journal_Entry = Journal_Entry 1262 def factory(*args_, **kwargs_): 1263 if HistoryItemType.subclass: 1264 return HistoryItemType.subclass(*args_, **kwargs_) 1265 else: 1266 return HistoryItemType(*args_, **kwargs_) 1267 factory = staticmethod(factory) 1268 def get_Action_Entry(self): return self.Action_Entry 1269 def set_Action_Entry(self, Action_Entry): self.Action_Entry = Action_Entry 1270 def get_Journal_Entry(self): return self.Journal_Entry 1271 def set_Journal_Entry(self, Journal_Entry): self.Journal_Entry = Journal_Entry 1272 def hasContent_(self): 1273 if ( 1274 self.Action_Entry is not None or 1275 self.Journal_Entry is not None 1276 ): 1277 return True 1278 else: 1279 return False 1280 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='HistoryItemType', namespacedef_='', pretty_print=True): 1281 if pretty_print: 1282 eol_ = '\n' 1283 else: 1284 eol_ = '' 1285 showIndent(lwrite, level, pretty_print) 1286 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1287 already_processed = set() 1288 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='HistoryItemType') 1289 if self.hasContent_(): 1290 lwrite('>%s' % (eol_, )) 1291 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1292 showIndent(lwrite, level, pretty_print) 1293 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1294 else: 1295 lwrite('/>%s' % (eol_, )) 1296 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='HistoryItemType'): 1297 pass 1298 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='HistoryItemType', fromsubclass_=False, pretty_print=True): 1299 if pretty_print: 1300 eol_ = '\n' 1301 else: 1302 eol_ = '' 1303 if self.Action_Entry is not None: 1304 self.Action_Entry.export(lwrite, level, nsmap, namespace_, name_='Action_Entry', pretty_print=pretty_print) 1305 if self.Journal_Entry is not None: 1306 self.Journal_Entry.export(lwrite, level, nsmap, namespace_, name_='Journal_Entry', pretty_print=pretty_print) 1307 def build(self, node): 1308 self.__sourcenode__ = node 1309 already_processed = set() 1310 self.buildAttributes(node, node.attrib, already_processed) 1311 for child in node: 1312 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1313 self.buildChildren(child, node, nodeName_) 1314 def buildAttributes(self, node, attrs, already_processed): 1315 pass 1316 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1317 if nodeName_ == 'Action_Entry': 1318 obj_ = COATakenType.factory() 1319 obj_.build(child_) 1320 self.set_Action_Entry(obj_) 1321 elif nodeName_ == 'Journal_Entry': 1322 obj_ = JournalEntryType.factory() 1323 obj_.build(child_) 1324 self.set_Journal_Entry(obj_) 1325# end class HistoryItemType 1326 1327class HistoryType(GeneratedsSuper): 1328 subclass = None 1329 superclass = None 1330 def __init__(self, History_Item=None): 1331 if History_Item is None: 1332 self.History_Item = [] 1333 else: 1334 self.History_Item = History_Item 1335 def factory(*args_, **kwargs_): 1336 if HistoryType.subclass: 1337 return HistoryType.subclass(*args_, **kwargs_) 1338 else: 1339 return HistoryType(*args_, **kwargs_) 1340 factory = staticmethod(factory) 1341 def get_History_Item(self): return self.History_Item 1342 def set_History_Item(self, History_Item): self.History_Item = History_Item 1343 def add_History_Item(self, value): self.History_Item.append(value) 1344 def insert_History_Item(self, index, value): self.History_Item[index] = value 1345 def hasContent_(self): 1346 if ( 1347 self.History_Item 1348 ): 1349 return True 1350 else: 1351 return False 1352 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='HistoryType', namespacedef_='', pretty_print=True): 1353 if pretty_print: 1354 eol_ = '\n' 1355 else: 1356 eol_ = '' 1357 showIndent(lwrite, level, pretty_print) 1358 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1359 already_processed = set() 1360 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='HistoryType') 1361 if self.hasContent_(): 1362 lwrite('>%s' % (eol_, )) 1363 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1364 showIndent(lwrite, level, pretty_print) 1365 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1366 else: 1367 lwrite('/>%s' % (eol_, )) 1368 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='HistoryType'): 1369 pass 1370 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='HistoryType', fromsubclass_=False, pretty_print=True): 1371 if pretty_print: 1372 eol_ = '\n' 1373 else: 1374 eol_ = '' 1375 for History_Item_ in self.History_Item: 1376 History_Item_.export(lwrite, level, nsmap, namespace_, name_='History_Item', pretty_print=pretty_print) 1377 def build(self, node): 1378 self.__sourcenode__ = node 1379 already_processed = set() 1380 self.buildAttributes(node, node.attrib, already_processed) 1381 for child in node: 1382 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1383 self.buildChildren(child, node, nodeName_) 1384 def buildAttributes(self, node, attrs, already_processed): 1385 pass 1386 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1387 if nodeName_ == 'History_Item': 1388 obj_ = HistoryItemType.factory() 1389 obj_.build(child_) 1390 self.History_Item.append(obj_) 1391# end class HistoryType 1392 1393class AffectedAssetsType(GeneratedsSuper): 1394 subclass = None 1395 superclass = None 1396 def __init__(self, Affected_Asset=None): 1397 if Affected_Asset is None: 1398 self.Affected_Asset = [] 1399 else: 1400 self.Affected_Asset = Affected_Asset 1401 def factory(*args_, **kwargs_): 1402 if AffectedAssetsType.subclass: 1403 return AffectedAssetsType.subclass(*args_, **kwargs_) 1404 else: 1405 return AffectedAssetsType(*args_, **kwargs_) 1406 factory = staticmethod(factory) 1407 def get_Affected_Asset(self): return self.Affected_Asset 1408 def set_Affected_Asset(self, Affected_Asset): self.Affected_Asset = Affected_Asset 1409 def add_Affected_Asset(self, value): self.Affected_Asset.append(value) 1410 def insert_Affected_Asset(self, index, value): self.Affected_Asset[index] = value 1411 def hasContent_(self): 1412 if ( 1413 self.Affected_Asset 1414 ): 1415 return True 1416 else: 1417 return False 1418 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='AffectedAssetsType', namespacedef_='', pretty_print=True): 1419 if pretty_print: 1420 eol_ = '\n' 1421 else: 1422 eol_ = '' 1423 showIndent(lwrite, level, pretty_print) 1424 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1425 already_processed = set() 1426 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='AffectedAssetsType') 1427 if self.hasContent_(): 1428 lwrite('>%s' % (eol_, )) 1429 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1430 showIndent(lwrite, level, pretty_print) 1431 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1432 else: 1433 lwrite('/>%s' % (eol_, )) 1434 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='AffectedAssetsType'): 1435 pass 1436 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='AffectedAssetsType', fromsubclass_=False, pretty_print=True): 1437 if pretty_print: 1438 eol_ = '\n' 1439 else: 1440 eol_ = '' 1441 for Affected_Asset_ in self.Affected_Asset: 1442 Affected_Asset_.export(lwrite, level, nsmap, namespace_, name_='Affected_Asset', pretty_print=pretty_print) 1443 def build(self, node): 1444 self.__sourcenode__ = node 1445 already_processed = set() 1446 self.buildAttributes(node, node.attrib, already_processed) 1447 for child in node: 1448 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1449 self.buildChildren(child, node, nodeName_) 1450 def buildAttributes(self, node, attrs, already_processed): 1451 pass 1452 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1453 if nodeName_ == 'Affected_Asset': 1454 obj_ = AffectedAssetType.factory() 1455 obj_.build(child_) 1456 self.Affected_Asset.append(obj_) 1457# end class AffectedAssetsType 1458 1459class TimeType(GeneratedsSuper): 1460 subclass = None 1461 superclass = None 1462 def __init__(self, First_Malicious_Action=None, Initial_Compromise=None, First_Data_Exfiltration=None, Incident_Discovery=None, Incident_Opened=None, Containment_Achieved=None, Restoration_Achieved=None, Incident_Reported=None, Incident_Closed=None): 1463 self.First_Malicious_Action = First_Malicious_Action 1464 self.Initial_Compromise = Initial_Compromise 1465 self.First_Data_Exfiltration = First_Data_Exfiltration 1466 self.Incident_Discovery = Incident_Discovery 1467 self.Incident_Opened = Incident_Opened 1468 self.Containment_Achieved = Containment_Achieved 1469 self.Restoration_Achieved = Restoration_Achieved 1470 self.Incident_Reported = Incident_Reported 1471 self.Incident_Closed = Incident_Closed 1472 def factory(*args_, **kwargs_): 1473 if TimeType.subclass: 1474 return TimeType.subclass(*args_, **kwargs_) 1475 else: 1476 return TimeType(*args_, **kwargs_) 1477 factory = staticmethod(factory) 1478 def get_First_Malicious_Action(self): return self.First_Malicious_Action 1479 def set_First_Malicious_Action(self, First_Malicious_Action): self.First_Malicious_Action = First_Malicious_Action 1480 def get_Initial_Compromise(self): return self.Initial_Compromise 1481 def set_Initial_Compromise(self, Initial_Compromise): self.Initial_Compromise = Initial_Compromise 1482 def get_First_Data_Exfiltration(self): return self.First_Data_Exfiltration 1483 def set_First_Data_Exfiltration(self, First_Data_Exfiltration): self.First_Data_Exfiltration = First_Data_Exfiltration 1484 def get_Incident_Discovery(self): return self.Incident_Discovery 1485 def set_Incident_Discovery(self, Incident_Discovery): self.Incident_Discovery = Incident_Discovery 1486 def get_Incident_Opened(self): return self.Incident_Opened 1487 def set_Incident_Opened(self, Incident_Opened): self.Incident_Opened = Incident_Opened 1488 def get_Containment_Achieved(self): return self.Containment_Achieved 1489 def set_Containment_Achieved(self, Containment_Achieved): self.Containment_Achieved = Containment_Achieved 1490 def get_Restoration_Achieved(self): return self.Restoration_Achieved 1491 def set_Restoration_Achieved(self, Restoration_Achieved): self.Restoration_Achieved = Restoration_Achieved 1492 def get_Incident_Reported(self): return self.Incident_Reported 1493 def set_Incident_Reported(self, Incident_Reported): self.Incident_Reported = Incident_Reported 1494 def get_Incident_Closed(self): return self.Incident_Closed 1495 def set_Incident_Closed(self, Incident_Closed): self.Incident_Closed = Incident_Closed 1496 def hasContent_(self): 1497 if ( 1498 self.First_Malicious_Action is not None or 1499 self.Initial_Compromise is not None or 1500 self.First_Data_Exfiltration is not None or 1501 self.Incident_Discovery is not None or 1502 self.Incident_Opened is not None or 1503 self.Containment_Achieved is not None or 1504 self.Restoration_Achieved is not None or 1505 self.Incident_Reported is not None or 1506 self.Incident_Closed is not None 1507 ): 1508 return True 1509 else: 1510 return False 1511 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='TimeType', namespacedef_='', pretty_print=True): 1512 if pretty_print: 1513 eol_ = '\n' 1514 else: 1515 eol_ = '' 1516 showIndent(lwrite, level, pretty_print) 1517 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1518 already_processed = set() 1519 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='TimeType') 1520 if self.hasContent_(): 1521 lwrite('>%s' % (eol_, )) 1522 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1523 showIndent(lwrite, level, pretty_print) 1524 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1525 else: 1526 lwrite('/>%s' % (eol_, )) 1527 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='TimeType'): 1528 pass 1529 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='TimeType', fromsubclass_=False, pretty_print=True): 1530 if pretty_print: 1531 eol_ = '\n' 1532 else: 1533 eol_ = '' 1534 if self.First_Malicious_Action is not None: 1535 self.First_Malicious_Action.export(lwrite, level, nsmap, namespace_, name_='First_Malicious_Action', pretty_print=pretty_print) 1536 if self.Initial_Compromise is not None: 1537 self.Initial_Compromise.export(lwrite, level, nsmap, namespace_, name_='Initial_Compromise', pretty_print=pretty_print) 1538 if self.First_Data_Exfiltration is not None: 1539 self.First_Data_Exfiltration.export(lwrite, level, nsmap, namespace_, name_='First_Data_Exfiltration', pretty_print=pretty_print) 1540 if self.Incident_Discovery is not None: 1541 self.Incident_Discovery.export(lwrite, level, nsmap, namespace_, name_='Incident_Discovery', pretty_print=pretty_print) 1542 if self.Incident_Opened is not None: 1543 self.Incident_Opened.export(lwrite, level, nsmap, namespace_, name_='Incident_Opened', pretty_print=pretty_print) 1544 if self.Containment_Achieved is not None: 1545 self.Containment_Achieved.export(lwrite, level, nsmap, namespace_, name_='Containment_Achieved', pretty_print=pretty_print) 1546 if self.Restoration_Achieved is not None: 1547 self.Restoration_Achieved.export(lwrite, level, nsmap, namespace_, name_='Restoration_Achieved', pretty_print=pretty_print) 1548 if self.Incident_Reported is not None: 1549 self.Incident_Reported.export(lwrite, level, nsmap, namespace_, name_='Incident_Reported', pretty_print=pretty_print) 1550 if self.Incident_Closed is not None: 1551 self.Incident_Closed.export(lwrite, level, nsmap, namespace_, name_='Incident_Closed', pretty_print=pretty_print) 1552 def build(self, node): 1553 self.__sourcenode__ = node 1554 already_processed = set() 1555 self.buildAttributes(node, node.attrib, already_processed) 1556 for child in node: 1557 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1558 self.buildChildren(child, node, nodeName_) 1559 def buildAttributes(self, node, attrs, already_processed): 1560 pass 1561 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1562 if nodeName_ == 'First_Malicious_Action': 1563 obj_ = stix_common_binding.DateTimeWithPrecisionType.factory() 1564 obj_.build(child_) 1565 self.set_First_Malicious_Action(obj_) 1566 elif nodeName_ == 'Initial_Compromise': 1567 obj_ = stix_common_binding.DateTimeWithPrecisionType.factory() 1568 obj_.build(child_) 1569 self.set_Initial_Compromise(obj_) 1570 elif nodeName_ == 'First_Data_Exfiltration': 1571 obj_ = stix_common_binding.DateTimeWithPrecisionType.factory() 1572 obj_.build(child_) 1573 self.set_First_Data_Exfiltration(obj_) 1574 elif nodeName_ == 'Incident_Discovery': 1575 obj_ = stix_common_binding.DateTimeWithPrecisionType.factory() 1576 obj_.build(child_) 1577 self.set_Incident_Discovery(obj_) 1578 elif nodeName_ == 'Incident_Opened': 1579 obj_ = stix_common_binding.DateTimeWithPrecisionType.factory() 1580 obj_.build(child_) 1581 self.set_Incident_Opened(obj_) 1582 elif nodeName_ == 'Containment_Achieved': 1583 obj_ = stix_common_binding.DateTimeWithPrecisionType.factory() 1584 obj_.build(child_) 1585 self.set_Containment_Achieved(obj_) 1586 elif nodeName_ == 'Restoration_Achieved': 1587 obj_ = stix_common_binding.DateTimeWithPrecisionType.factory() 1588 obj_.build(child_) 1589 self.set_Restoration_Achieved(obj_) 1590 elif nodeName_ == 'Incident_Reported': 1591 obj_ = stix_common_binding.DateTimeWithPrecisionType.factory() 1592 obj_.build(child_) 1593 self.set_Incident_Reported(obj_) 1594 elif nodeName_ == 'Incident_Closed': 1595 obj_ = stix_common_binding.DateTimeWithPrecisionType.factory() 1596 obj_.build(child_) 1597 self.set_Incident_Closed(obj_) 1598# end class TimeType 1599 1600class CategoriesType(GeneratedsSuper): 1601 """Represents a list of incident categories that an incident is tagged 1602 with.""" 1603 subclass = None 1604 superclass = None 1605 def __init__(self, Category=None): 1606 if Category is None: 1607 self.Category = [] 1608 else: 1609 self.Category = Category 1610 def factory(*args_, **kwargs_): 1611 if CategoriesType.subclass: 1612 return CategoriesType.subclass(*args_, **kwargs_) 1613 else: 1614 return CategoriesType(*args_, **kwargs_) 1615 factory = staticmethod(factory) 1616 def get_Category(self): return self.Category 1617 def set_Category(self, Category): self.Category = Category 1618 def add_Category(self, value): self.Category.append(value) 1619 def insert_Category(self, index, value): self.Category[index] = value 1620 def hasContent_(self): 1621 if ( 1622 self.Category 1623 ): 1624 return True 1625 else: 1626 return False 1627 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='CategoriesType', namespacedef_='', pretty_print=True): 1628 if pretty_print: 1629 eol_ = '\n' 1630 else: 1631 eol_ = '' 1632 showIndent(lwrite, level, pretty_print) 1633 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1634 already_processed = set() 1635 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='CategoriesType') 1636 if self.hasContent_(): 1637 lwrite('>%s' % (eol_, )) 1638 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1639 showIndent(lwrite, level, pretty_print) 1640 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1641 else: 1642 lwrite('/>%s' % (eol_, )) 1643 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='CategoriesType'): 1644 pass 1645 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='CategoriesType', fromsubclass_=False, pretty_print=True): 1646 if pretty_print: 1647 eol_ = '\n' 1648 else: 1649 eol_ = '' 1650 for Category_ in self.Category: 1651 Category_.export(lwrite, level, nsmap, namespace_, name_='Category', pretty_print=pretty_print) 1652 def build(self, node): 1653 self.__sourcenode__ = node 1654 already_processed = set() 1655 self.buildAttributes(node, node.attrib, already_processed) 1656 for child in node: 1657 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1658 self.buildChildren(child, node, nodeName_) 1659 def buildAttributes(self, node, attrs, already_processed): 1660 pass 1661 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1662 if nodeName_ == 'Category': 1663 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 1664 obj_.build(child_) 1665 self.add_Category(obj_) 1666# end class CategoriesType 1667 1668class EffectsType(GeneratedsSuper): 1669 """Represents a list of incident effects that an incident is tagged 1670 with.""" 1671 subclass = None 1672 superclass = None 1673 def __init__(self, Effect=None): 1674 if Effect is None: 1675 self.Effect = [] 1676 else: 1677 self.Effect = Effect 1678 def factory(*args_, **kwargs_): 1679 if EffectsType.subclass: 1680 return EffectsType.subclass(*args_, **kwargs_) 1681 else: 1682 return EffectsType(*args_, **kwargs_) 1683 factory = staticmethod(factory) 1684 def get_Effect(self): return self.Effect 1685 def set_Effect(self, Effect): self.Effect = Effect 1686 def add_Effect(self, value): self.Effect.append(value) 1687 def insert_Effect(self, index, value): self.Effect[index] = value 1688 def hasContent_(self): 1689 if ( 1690 self.Effect 1691 ): 1692 return True 1693 else: 1694 return False 1695 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='EffectsType', namespacedef_='', pretty_print=True): 1696 if pretty_print: 1697 eol_ = '\n' 1698 else: 1699 eol_ = '' 1700 showIndent(lwrite, level, pretty_print) 1701 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1702 already_processed = set() 1703 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='EffectsType') 1704 if self.hasContent_(): 1705 lwrite('>%s' % (eol_, )) 1706 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1707 showIndent(lwrite, level, pretty_print) 1708 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1709 else: 1710 lwrite('/>%s' % (eol_, )) 1711 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='EffectsType'): 1712 pass 1713 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='EffectsType', fromsubclass_=False, pretty_print=True): 1714 if pretty_print: 1715 eol_ = '\n' 1716 else: 1717 eol_ = '' 1718 for Effect_ in self.Effect: 1719 Effect_.export(lwrite, level, nsmap, namespace_, name_='Effect', pretty_print=pretty_print) 1720 def build(self, node): 1721 self.__sourcenode__ = node 1722 already_processed = set() 1723 self.buildAttributes(node, node.attrib, already_processed) 1724 for child in node: 1725 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1726 self.buildChildren(child, node, nodeName_) 1727 def buildAttributes(self, node, attrs, already_processed): 1728 pass 1729 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1730 if nodeName_ == 'Effect': 1731 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 1732 obj_.build(child_) 1733 self.Effect.append(obj_) 1734# end class EffectsType 1735 1736class AttributedThreatActorsType(stix_common_binding.GenericRelationshipListType): 1737 """The AttributedThreatActorsType specifies a Threat Actor asserted to 1738 be attributed for this Incident.""" 1739 subclass = None 1740 superclass = stix_common_binding.GenericRelationshipListType 1741 def __init__(self, scope='exclusive', Threat_Actor=None): 1742 super(AttributedThreatActorsType, self).__init__(scope=scope) 1743 if Threat_Actor is None: 1744 self.Threat_Actor = [] 1745 else: 1746 self.Threat_Actor = Threat_Actor 1747 def factory(*args_, **kwargs_): 1748 if AttributedThreatActorsType.subclass: 1749 return AttributedThreatActorsType.subclass(*args_, **kwargs_) 1750 else: 1751 return AttributedThreatActorsType(*args_, **kwargs_) 1752 factory = staticmethod(factory) 1753 def get_Threat_Actor(self): return self.Threat_Actor 1754 def set_Threat_Actor(self, Threat_Actor): self.Threat_Actor = Threat_Actor 1755 def add_Threat_Actor(self, value): self.Threat_Actor.append(value) 1756 def insert_Threat_Actor(self, index, value): self.Threat_Actor[index] = value 1757 def hasContent_(self): 1758 if ( 1759 self.Threat_Actor or 1760 super(AttributedThreatActorsType, self).hasContent_() 1761 ): 1762 return True 1763 else: 1764 return False 1765 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='AttributedThreatActorsType', namespacedef_='', pretty_print=True): 1766 if pretty_print: 1767 eol_ = '\n' 1768 else: 1769 eol_ = '' 1770 showIndent(lwrite, level, pretty_print) 1771 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1772 already_processed = set() 1773 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='AttributedThreatActorsType') 1774 if self.hasContent_(): 1775 lwrite('>%s' % (eol_, )) 1776 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1777 showIndent(lwrite, level, pretty_print) 1778 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1779 else: 1780 lwrite('/>%s' % (eol_, )) 1781 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='AttributedThreatActorsType'): 1782 super(AttributedThreatActorsType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='AttributedThreatActorsType') 1783 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='AttributedThreatActorsType', fromsubclass_=False, pretty_print=True): 1784 super(AttributedThreatActorsType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, True, pretty_print=pretty_print) 1785 if pretty_print: 1786 eol_ = '\n' 1787 else: 1788 eol_ = '' 1789 for Threat_Actor_ in self.Threat_Actor: 1790 Threat_Actor_.export(lwrite, level, nsmap, namespace_, name_='Threat_Actor', pretty_print=pretty_print) 1791 def build(self, node): 1792 self.__sourcenode__ = node 1793 already_processed = set() 1794 self.buildAttributes(node, node.attrib, already_processed) 1795 for child in node: 1796 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1797 self.buildChildren(child, node, nodeName_) 1798 def buildAttributes(self, node, attrs, already_processed): 1799 super(AttributedThreatActorsType, self).buildAttributes(node, attrs, already_processed) 1800 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1801 if nodeName_ == 'Threat_Actor': 1802 obj_ = stix_common_binding.RelatedThreatActorType.factory() 1803 obj_.build(child_) 1804 self.Threat_Actor.append(obj_) 1805 super(AttributedThreatActorsType, self).buildChildren(child_, node, nodeName_, True) 1806# end class AttributedThreatActorsType 1807 1808class RelatedIndicatorsType(stix_common_binding.GenericRelationshipListType): 1809 subclass = None 1810 superclass = stix_common_binding.GenericRelationshipListType 1811 def __init__(self, scope='exclusive', Related_Indicator=None): 1812 super(RelatedIndicatorsType, self).__init__(scope=scope) 1813 if Related_Indicator is None: 1814 self.Related_Indicator = [] 1815 else: 1816 self.Related_Indicator = Related_Indicator 1817 def factory(*args_, **kwargs_): 1818 if RelatedIndicatorsType.subclass: 1819 return RelatedIndicatorsType.subclass(*args_, **kwargs_) 1820 else: 1821 return RelatedIndicatorsType(*args_, **kwargs_) 1822 factory = staticmethod(factory) 1823 def get_Related_Indicator(self): return self.Related_Indicator 1824 def set_Related_Indicator(self, Related_Indicator): self.Related_Indicator = Related_Indicator 1825 def add_Related_Indicator(self, value): self.Related_Indicator.append(value) 1826 def insert_Related_Indicator(self, index, value): self.Related_Indicator[index] = value 1827 def hasContent_(self): 1828 if ( 1829 self.Related_Indicator or 1830 super(RelatedIndicatorsType, self).hasContent_() 1831 ): 1832 return True 1833 else: 1834 return False 1835 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='RelatedIndicatorsType', namespacedef_='', pretty_print=True): 1836 if pretty_print: 1837 eol_ = '\n' 1838 else: 1839 eol_ = '' 1840 showIndent(lwrite, level, pretty_print) 1841 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1842 already_processed = set() 1843 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='RelatedIndicatorsType') 1844 if self.hasContent_(): 1845 lwrite('>%s' % (eol_, )) 1846 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1847 showIndent(lwrite, level, pretty_print) 1848 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1849 else: 1850 lwrite('/>%s' % (eol_, )) 1851 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='RelatedIndicatorsType'): 1852 super(RelatedIndicatorsType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='RelatedIndicatorsType') 1853 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='RelatedIndicatorsType', fromsubclass_=False, pretty_print=True): 1854 super(RelatedIndicatorsType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, True, pretty_print=pretty_print) 1855 if pretty_print: 1856 eol_ = '\n' 1857 else: 1858 eol_ = '' 1859 for Related_Indicator_ in self.Related_Indicator: 1860 Related_Indicator_.export(lwrite, level, nsmap, namespace_, name_='Related_Indicator', pretty_print=pretty_print) 1861 def build(self, node): 1862 self.__sourcenode__ = node 1863 already_processed = set() 1864 self.buildAttributes(node, node.attrib, already_processed) 1865 for child in node: 1866 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1867 self.buildChildren(child, node, nodeName_) 1868 def buildAttributes(self, node, attrs, already_processed): 1869 super(RelatedIndicatorsType, self).buildAttributes(node, attrs, already_processed) 1870 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1871 if nodeName_ == 'Related_Indicator': 1872 obj_ = stix_common_binding.RelatedIndicatorType.factory() 1873 obj_.build(child_) 1874 self.Related_Indicator.append(obj_) 1875 super(RelatedIndicatorsType, self).buildChildren(child_, node, nodeName_, True) 1876# end class RelatedIndicatorsType 1877 1878class RelatedObservablesType(stix_common_binding.GenericRelationshipListType): 1879 subclass = None 1880 superclass = stix_common_binding.GenericRelationshipListType 1881 def __init__(self, scope='exclusive', Related_Observable=None): 1882 super(RelatedObservablesType, self).__init__(scope=scope) 1883 if Related_Observable is None: 1884 self.Related_Observable = [] 1885 else: 1886 self.Related_Observable = Related_Observable 1887 def factory(*args_, **kwargs_): 1888 if RelatedObservablesType.subclass: 1889 return RelatedObservablesType.subclass(*args_, **kwargs_) 1890 else: 1891 return RelatedObservablesType(*args_, **kwargs_) 1892 factory = staticmethod(factory) 1893 def get_Related_Observable(self): return self.Related_Observable 1894 def set_Related_Observable(self, Related_Observable): self.Related_Observable = Related_Observable 1895 def add_Related_Observable(self, value): self.Related_Observable.append(value) 1896 def insert_Related_Observable(self, index, value): self.Related_Observable[index] = value 1897 def hasContent_(self): 1898 if ( 1899 self.Related_Observable or 1900 super(RelatedObservablesType, self).hasContent_() 1901 ): 1902 return True 1903 else: 1904 return False 1905 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='RelatedObservablesType', namespacedef_='', pretty_print=True): 1906 if pretty_print: 1907 eol_ = '\n' 1908 else: 1909 eol_ = '' 1910 showIndent(lwrite, level, pretty_print) 1911 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1912 already_processed = set() 1913 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='RelatedObservablesType') 1914 if self.hasContent_(): 1915 lwrite('>%s' % (eol_, )) 1916 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1917 showIndent(lwrite, level, pretty_print) 1918 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1919 else: 1920 lwrite('/>%s' % (eol_, )) 1921 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='RelatedObservablesType'): 1922 super(RelatedObservablesType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='RelatedObservablesType') 1923 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='RelatedObservablesType', fromsubclass_=False, pretty_print=True): 1924 super(RelatedObservablesType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, True, pretty_print=pretty_print) 1925 if pretty_print: 1926 eol_ = '\n' 1927 else: 1928 eol_ = '' 1929 for Related_Observable_ in self.Related_Observable: 1930 Related_Observable_.export(lwrite, level, nsmap, namespace_, name_='Related_Observable', pretty_print=pretty_print) 1931 def build(self, node): 1932 self.__sourcenode__ = node 1933 already_processed = set() 1934 self.buildAttributes(node, node.attrib, already_processed) 1935 for child in node: 1936 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1937 self.buildChildren(child, node, nodeName_) 1938 def buildAttributes(self, node, attrs, already_processed): 1939 super(RelatedObservablesType, self).buildAttributes(node, attrs, already_processed) 1940 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1941 if nodeName_ == 'Related_Observable': 1942 obj_ = stix_common_binding.RelatedObservableType.factory() 1943 obj_.build(child_) 1944 self.Related_Observable.append(obj_) 1945 super(RelatedObservablesType, self).buildChildren(child_, node, nodeName_, True) 1946# end class RelatedObservablesType 1947 1948class LeveragedTTPsType(stix_common_binding.GenericRelationshipListType): 1949 subclass = None 1950 superclass = stix_common_binding.GenericRelationshipListType 1951 def __init__(self, scope='exclusive', Leveraged_TTP=None): 1952 super(LeveragedTTPsType, self).__init__(scope=scope) 1953 if Leveraged_TTP is None: 1954 self.Leveraged_TTP = [] 1955 else: 1956 self.Leveraged_TTP = Leveraged_TTP 1957 def factory(*args_, **kwargs_): 1958 if LeveragedTTPsType.subclass: 1959 return LeveragedTTPsType.subclass(*args_, **kwargs_) 1960 else: 1961 return LeveragedTTPsType(*args_, **kwargs_) 1962 factory = staticmethod(factory) 1963 def get_Leveraged_TTP(self): return self.Leveraged_TTP 1964 def set_Leveraged_TTP(self, Leveraged_TTP): self.Leveraged_TTP = Leveraged_TTP 1965 def add_Leveraged_TTP(self, value): self.Leveraged_TTP.append(value) 1966 def insert_Leveraged_TTP(self, index, value): self.Leveraged_TTP[index] = value 1967 def hasContent_(self): 1968 if ( 1969 self.Leveraged_TTP or 1970 super(LeveragedTTPsType, self).hasContent_() 1971 ): 1972 return True 1973 else: 1974 return False 1975 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='LeveragedTTPsType', namespacedef_='', pretty_print=True): 1976 if pretty_print: 1977 eol_ = '\n' 1978 else: 1979 eol_ = '' 1980 showIndent(lwrite, level, pretty_print) 1981 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1982 already_processed = set() 1983 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='LeveragedTTPsType') 1984 if self.hasContent_(): 1985 lwrite('>%s' % (eol_, )) 1986 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 1987 showIndent(lwrite, level, pretty_print) 1988 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 1989 else: 1990 lwrite('/>%s' % (eol_, )) 1991 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='LeveragedTTPsType'): 1992 super(LeveragedTTPsType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='LeveragedTTPsType') 1993 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='LeveragedTTPsType', fromsubclass_=False, pretty_print=True): 1994 super(LeveragedTTPsType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, True, pretty_print=pretty_print) 1995 if pretty_print: 1996 eol_ = '\n' 1997 else: 1998 eol_ = '' 1999 for Leveraged_TTP_ in self.Leveraged_TTP: 2000 Leveraged_TTP_.export(lwrite, level, nsmap, namespace_, name_='Leveraged_TTP', pretty_print=pretty_print) 2001 def build(self, node): 2002 self.__sourcenode__ = node 2003 already_processed = set() 2004 self.buildAttributes(node, node.attrib, already_processed) 2005 for child in node: 2006 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2007 self.buildChildren(child, node, nodeName_) 2008 def buildAttributes(self, node, attrs, already_processed): 2009 super(LeveragedTTPsType, self).buildAttributes(node, attrs, already_processed) 2010 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2011 if nodeName_ == 'Leveraged_TTP': 2012 obj_ = stix_common_binding.RelatedTTPType.factory() 2013 obj_.build(child_) 2014 self.Leveraged_TTP.append(obj_) 2015 super(LeveragedTTPsType, self).buildChildren(child_, node, nodeName_, True) 2016# end class LeveragedTTPsType 2017 2018class RelatedIncidentsType(stix_common_binding.GenericRelationshipListType): 2019 subclass = None 2020 superclass = stix_common_binding.GenericRelationshipListType 2021 def __init__(self, scope='exclusive', Related_Incident=None): 2022 super(RelatedIncidentsType, self).__init__(scope=scope) 2023 if Related_Incident is None: 2024 self.Related_Incident = [] 2025 else: 2026 self.Related_Incident = Related_Incident 2027 def factory(*args_, **kwargs_): 2028 if RelatedIncidentsType.subclass: 2029 return RelatedIncidentsType.subclass(*args_, **kwargs_) 2030 else: 2031 return RelatedIncidentsType(*args_, **kwargs_) 2032 factory = staticmethod(factory) 2033 def get_Related_Incident(self): return self.Related_Incident 2034 def set_Related_Incident(self, Related_Incident): self.Related_Incident = Related_Incident 2035 def add_Related_Incident(self, value): self.Related_Incident.append(value) 2036 def insert_Related_Incident(self, index, value): self.Related_Incident[index] = value 2037 def hasContent_(self): 2038 if ( 2039 self.Related_Incident or 2040 super(RelatedIncidentsType, self).hasContent_() 2041 ): 2042 return True 2043 else: 2044 return False 2045 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='RelatedIncidentsType', namespacedef_='', pretty_print=True): 2046 if pretty_print: 2047 eol_ = '\n' 2048 else: 2049 eol_ = '' 2050 showIndent(lwrite, level, pretty_print) 2051 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2052 already_processed = set() 2053 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='RelatedIncidentsType') 2054 if self.hasContent_(): 2055 lwrite('>%s' % (eol_, )) 2056 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 2057 showIndent(lwrite, level, pretty_print) 2058 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 2059 else: 2060 lwrite('/>%s' % (eol_, )) 2061 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='RelatedIncidentsType'): 2062 super(RelatedIncidentsType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='RelatedIncidentsType') 2063 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='RelatedIncidentsType', fromsubclass_=False, pretty_print=True): 2064 super(RelatedIncidentsType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, True, pretty_print=pretty_print) 2065 if pretty_print: 2066 eol_ = '\n' 2067 else: 2068 eol_ = '' 2069 for Related_Incident_ in self.Related_Incident: 2070 Related_Incident_.export(lwrite, level, nsmap, namespace_, name_='Related_Incident', pretty_print=pretty_print) 2071 def build(self, node): 2072 self.__sourcenode__ = node 2073 already_processed = set() 2074 self.buildAttributes(node, node.attrib, already_processed) 2075 for child in node: 2076 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2077 self.buildChildren(child, node, nodeName_) 2078 def buildAttributes(self, node, attrs, already_processed): 2079 super(RelatedIncidentsType, self).buildAttributes(node, attrs, already_processed) 2080 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2081 if nodeName_ == 'Related_Incident': 2082 obj_ = stix_common_binding.RelatedIncidentType.factory() 2083 obj_.build(child_) 2084 self.Related_Incident.append(obj_) 2085 super(RelatedIncidentsType, self).buildChildren(child_, node, nodeName_, True) 2086# end class RelatedIncidentsType 2087 2088class AssetTypeType(stix_common_binding.ControlledVocabularyStringType): 2089 """This field specifies the number of assets of this type affected. 2090 This field is implemented through the xsi:type controlled 2091 vocabulary extension mechanism. The default vocabulary type is 2092 AssetTypeVocab-1.0 in the 2093 http://stix.mitre.org/default_vocabularies-1 namespace. This 2094 type is defined in the stix_default_vocabularies.xsd file or at 2095 the URL http://stix.mitre.org/XMLSchema/default_vocabularies/1.0 2096 .0/stix_default_vocabularies.xsd . Users may also define their 2097 own vocabulary using the type extension mechanism, specify a 2098 vocabulary name and reference using the attributes, or simply 2099 use this as a string field.""" 2100 subclass = None 2101 superclass = stix_common_binding.ControlledVocabularyStringType 2102 def __init__(self, vocab_reference=None, vocab_name=None, count_affected=None, valueOf_=None): 2103 super(AssetTypeType, self).__init__(vocab_reference=vocab_reference, vocab_name=vocab_name, valueOf_=valueOf_) 2104 self.count_affected = _cast(None, count_affected) 2105 self.valueOf_ = valueOf_ 2106 def factory(*args_, **kwargs_): 2107 if AssetTypeType.subclass: 2108 return AssetTypeType.subclass(*args_, **kwargs_) 2109 else: 2110 return AssetTypeType(*args_, **kwargs_) 2111 factory = staticmethod(factory) 2112 def get_count_affected(self): return self.count_affected 2113 def set_count_affected(self, count_affected): self.count_affected = count_affected 2114 def get_valueOf_(self): return self.valueOf_ 2115 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2116 def hasContent_(self): 2117 if ( 2118 self.valueOf_ or 2119 super(AssetTypeType, self).hasContent_() 2120 ): 2121 return True 2122 else: 2123 return False 2124 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='AssetTypeType', namespacedef_='', pretty_print=True): 2125 if pretty_print: 2126 eol_ = '\n' 2127 else: 2128 eol_ = '' 2129 showIndent(lwrite, level, pretty_print) 2130 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2131 already_processed = set() 2132 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='AssetTypeType') 2133 if self.hasContent_(): 2134 lwrite('>') 2135 lwrite(quote_xml(self.valueOf_)) 2136 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 2137 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 2138 else: 2139 lwrite('/>%s' % (eol_, )) 2140 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='AssetTypeType'): 2141 super(AssetTypeType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='AssetTypeType') 2142 if self.count_affected is not None and 'count_affected' not in already_processed: 2143 already_processed.add('count_affected') 2144 lwrite(' count_affected=%s' % (quote_attrib(self.count_affected), )) 2145 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='AssetTypeType', fromsubclass_=False, pretty_print=True): 2146 super(AssetTypeType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, True, pretty_print=pretty_print) 2147 pass 2148 def build(self, node): 2149 self.__sourcenode__ = node 2150 already_processed = set() 2151 self.buildAttributes(node, node.attrib, already_processed) 2152 self.valueOf_ = get_all_text_(node) 2153 for child in node: 2154 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2155 self.buildChildren(child, node, nodeName_) 2156 def buildAttributes(self, node, attrs, already_processed): 2157 value = find_attr_value_('count_affected', node) 2158 if value is not None and 'count_affected' not in already_processed: 2159 already_processed.add('count_affected') 2160 self.count_affected = value 2161 super(AssetTypeType, self).buildAttributes(node, attrs, already_processed) 2162 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2163 pass 2164# end class AssetTypeType 2165 2166 2167@register_extension 2168class IncidentType(stix_common_binding.IncidentBaseType): 2169 """The IncidentType characterizes a single cyber threat 2170 Incident.Specifies the relevant STIX-Incident schema version for 2171 this content.Specifies a URL referencing the location for the 2172 Incident specification.""" 2173 subclass = None 2174 superclass = stix_common_binding.IncidentBaseType 2175 2176 xmlns = "http://stix.mitre.org/Incident-1" 2177 xmlns_prefix = "incident" 2178 xml_type = "IncidentType" 2179 xsi_type = "%s:%s" % (xmlns_prefix, xml_type) 2180 2181 def __init__(self, idref=None, id=None, timestamp=None, URL=None, version=None, Title=None, External_ID=None, Time=None, Description=None, Short_Description=None, Categories=None, Reporter=None, Responder=None, Coordinator=None, Victim=None, Affected_Assets=None, Impact_Assessment=None, Status=None, Related_Indicators=None, Related_Observables=None, Leveraged_TTPs=None, Attributed_Threat_Actors=None, Intended_Effect=None, Security_Compromise=None, Discovery_Method=None, Related_Incidents=None, COA_Requested=None, COA_Taken=None, Confidence=None, Contact=None, History=None, Information_Source=None, Handling=None, Related_Packages=None): 2182 super(IncidentType, self).__init__(timestamp=timestamp, idref=idref, id=id) 2183 self.URL = _cast(None, URL) 2184 self.version = _cast(None, version) 2185 self.Title = Title 2186 if External_ID is None: 2187 self.External_ID = [] 2188 else: 2189 self.External_ID = External_ID 2190 self.Time = Time 2191 if Description is None: 2192 self.Description = [] 2193 else: 2194 self.Description = Description 2195 if Short_Description is None: 2196 self.Short_Description = [] 2197 else: 2198 self.Short_Description = Short_Description 2199 self.Categories = Categories 2200 self.Reporter = Reporter 2201 if Responder is None: 2202 self.Responder = [] 2203 else: 2204 self.Responder = Responder 2205 if Coordinator is None: 2206 self.Coordinator = [] 2207 else: 2208 self.Coordinator = Coordinator 2209 if Victim is None: 2210 self.Victim = [] 2211 else: 2212 self.Victim = Victim 2213 self.Affected_Assets = Affected_Assets 2214 self.Impact_Assessment = Impact_Assessment 2215 self.Status = Status 2216 self.Related_Indicators = Related_Indicators 2217 self.Related_Observables = Related_Observables 2218 self.Leveraged_TTPs = Leveraged_TTPs 2219 self.Attributed_Threat_Actors = Attributed_Threat_Actors 2220 if Intended_Effect is None: 2221 self.Intended_Effect = [] 2222 else: 2223 self.Intended_Effect = Intended_Effect 2224 self.Security_Compromise = Security_Compromise 2225 if Discovery_Method is None: 2226 self.Discovery_Method = [] 2227 else: 2228 self.Discovery_Method = Discovery_Method 2229 self.Related_Incidents = Related_Incidents 2230 if COA_Requested is None: 2231 self.COA_Requested = [] 2232 else: 2233 self.COA_Requested = COA_Requested 2234 if COA_Taken is None: 2235 self.COA_Taken = [] 2236 else: 2237 self.COA_Taken = COA_Taken 2238 self.Confidence = Confidence 2239 if Contact is None: 2240 self.Contact = [] 2241 else: 2242 self.Contact = Contact 2243 self.History = History 2244 self.Information_Source = Information_Source 2245 self.Handling = Handling 2246 self.Related_Packages = Related_Packages 2247 def factory(*args_, **kwargs_): 2248 if IncidentType.subclass: 2249 return IncidentType.subclass(*args_, **kwargs_) 2250 else: 2251 return IncidentType(*args_, **kwargs_) 2252 factory = staticmethod(factory) 2253 def get_Title(self): return self.Title 2254 def set_Title(self, Title): self.Title = Title 2255 def get_External_ID(self): return self.External_ID 2256 def set_External_ID(self, External_ID): self.External_ID = External_ID 2257 def add_External_ID(self, value): self.External_ID.append(value) 2258 def insert_External_ID(self, index, value): self.External_ID[index] = value 2259 def get_Time(self): return self.Time 2260 def set_Time(self, Time): self.Time = Time 2261 def insert_Description(self, index, value): self.Description[index] = value 2262 def add_Description(self, Description): self.Description.append(Description) 2263 def get_Description(self): return self.Description 2264 def set_Description(self, Description): self.Description = Description 2265 def insert_Short_Description(self, index, value): self.Short_Description[index] = value 2266 def add_Short_Description(self, Short_Description): self.Short_Description.append(Short_Description) 2267 def get_Short_Description(self): return self.Short_Description 2268 def set_Short_Description(self, Short_Description): self.Short_Description = Short_Description 2269 def get_Categories(self): return self.Categories 2270 def set_Categories(self, Categories): self.Categories = Categories 2271 def get_Reporter(self): return self.Reporter 2272 def set_Reporter(self, Reporter): self.Reporter = Reporter 2273 def get_Responder(self): return self.Responder 2274 def set_Responder(self, Responder): self.Responder = Responder 2275 def add_Responder(self, value): self.Responder.append(value) 2276 def insert_Responder(self, index, value): self.Responder[index] = value 2277 def get_Coordinator(self): return self.Coordinator 2278 def set_Coordinator(self, Coordinator): self.Coordinator = Coordinator 2279 def add_Coordinator(self, value): self.Coordinator.append(value) 2280 def insert_Coordinator(self, index, value): self.Coordinator[index] = value 2281 def get_Victim(self): return self.Victim 2282 def set_Victim(self, Victim): self.Victim = Victim 2283 def add_Victim(self, value): self.Victim.append(value) 2284 def insert_Victim(self, index, value): self.Victim[index] = value 2285 def get_Affected_Assets(self): return self.Affected_Assets 2286 def set_Affected_Assets(self, Affected_Assets): self.Affected_Assets = Affected_Assets 2287 def get_Impact_Assessment(self): return self.Impact_Assessment 2288 def set_Impact_Assessment(self, Impact_Assessment): self.Impact_Assessment = Impact_Assessment 2289 def get_Status(self): return self.Status 2290 def set_Status(self, Status): self.Status = Status 2291 def get_Related_Indicators(self): return self.Related_Indicators 2292 def set_Related_Indicators(self, Related_Indicators): self.Related_Indicators = Related_Indicators 2293 def get_Related_Observables(self): return self.Related_Observables 2294 def set_Related_Observables(self, Related_Observables): self.Related_Observables = Related_Observables 2295 def get_Leveraged_TTPs(self): return self.Leveraged_TTPs 2296 def set_Leveraged_TTPs(self, Leveraged_TTPs): self.Leveraged_TTPs = Leveraged_TTPs 2297 def get_Attributed_Threat_Actors(self): return self.Attributed_Threat_Actors 2298 def set_Attributed_Threat_Actors(self, Attributed_Threat_Actors): self.Attributed_Threat_Actors = Attributed_Threat_Actors 2299 def get_Intended_Effect(self): return self.Intended_Effect 2300 def set_Intended_Effect(self, Intended_Effect): self.Intended_Effect = Intended_Effect 2301 def add_Intended_Effect(self, value): self.Intended_Effect.append(value) 2302 def insert_Intended_Effect(self, index, value): self.Intended_Effect[index] = value 2303 def get_Security_Compromise(self): return self.Security_Compromise 2304 def set_Security_Compromise(self, Security_Compromise): self.Security_Compromise = Security_Compromise 2305 def get_Discovery_Method(self): return self.Discovery_Method 2306 def set_Discovery_Method(self, Discovery_Method): self.Discovery_Method = Discovery_Method 2307 def add_Discovery_Method(self, value): self.Discovery_Method.append(value) 2308 def insert_Discovery_Method(self, index, value): self.Discovery_Method[index] = value 2309 def get_Related_Incidents(self): return self.Related_Incidents 2310 def set_Related_Incidents(self, Related_Incidents): self.Related_Incidents = Related_Incidents 2311 def get_COA_Requested(self): return self.COA_Requested 2312 def set_COA_Requested(self, COA_Requested): self.COA_Requested = COA_Requested 2313 def add_COA_Requested(self, value): self.COA_Requested.append(value) 2314 def insert_COA_Requested(self, index, value): self.COA_Requested[index] = value 2315 def get_COA_Taken(self): return self.COA_Taken 2316 def set_COA_Taken(self, COA_Taken): self.COA_Taken = COA_Taken 2317 def add_COA_Taken(self, value): self.COA_Taken.append(value) 2318 def insert_COA_Taken(self, index, value): self.COA_Taken[index] = value 2319 def get_Confidence(self): return self.Confidence 2320 def set_Confidence(self, Confidence): self.Confidence = Confidence 2321 def get_Contact(self): return self.Contact 2322 def set_Contact(self, Contact): self.Contact = Contact 2323 def add_Contact(self, value): self.Contact.append(value) 2324 def insert_Contact(self, index, value): self.Contact[index] = value 2325 def get_History(self): return self.History 2326 def set_History(self, History): self.History = History 2327 def get_Information_Source(self): return self.Information_Source 2328 def set_Information_Source(self, Information_Source): self.Information_Source = Information_Source 2329 def get_Handling(self): return self.Handling 2330 def set_Handling(self, Handling): self.Handling = Handling 2331 def get_Related_Packages(self): return self.Related_Packages 2332 def set_Related_Packages(self, Related_Packages): self.Related_Packages = Related_Packages 2333 def get_URL(self): return self.URL 2334 def set_URL(self, URL): self.URL = URL 2335 def get_version(self): return self.version 2336 def set_version(self, version): self.version = version 2337 def hasContent_(self): 2338 if ( 2339 self.Title is not None or 2340 self.External_ID or 2341 self.Time is not None or 2342 self.Description or 2343 self.Short_Description or 2344 self.Categories is not None or 2345 self.Reporter is not None or 2346 self.Responder or 2347 self.Coordinator or 2348 self.Victim or 2349 self.Affected_Assets is not None or 2350 self.Impact_Assessment is not None or 2351 self.Status is not None or 2352 self.Related_Indicators is not None or 2353 self.Related_Observables is not None or 2354 self.Leveraged_TTPs is not None or 2355 self.Attributed_Threat_Actors is not None or 2356 self.Intended_Effect or 2357 self.Security_Compromise is not None or 2358 self.Discovery_Method or 2359 self.Related_Incidents is not None or 2360 self.COA_Requested or 2361 self.COA_Taken or 2362 self.Confidence is not None or 2363 self.Contact or 2364 self.History is not None or 2365 self.Information_Source is not None or 2366 self.Handling is not None or 2367 self.Related_Packages is not None or 2368 super(IncidentType, self).hasContent_() 2369 ): 2370 return True 2371 else: 2372 return False 2373 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='Incident', namespacedef_='', pretty_print=True): 2374 if pretty_print: 2375 eol_ = '\n' 2376 else: 2377 eol_ = '' 2378 showIndent(lwrite, level, pretty_print) 2379 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2380 already_processed = set() 2381 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='Incident') 2382 if self.hasContent_(): 2383 lwrite('>%s' % (eol_, )) 2384 self.exportChildren(lwrite, level + 1, nsmap, XML_NS, name_, pretty_print=pretty_print) 2385 showIndent(lwrite, level, pretty_print) 2386 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 2387 else: 2388 lwrite('/>%s' % (eol_, )) 2389 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='Incident'): 2390 super(IncidentType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='Incident') 2391# if 'xmlns' not in already_processed: 2392# already_processed.add('xmlns') 2393# xmlns = " xmlns:%s='%s'" % (self.xmlns_prefix, self.xmlns) 2394# lwrite(xmlns) 2395 if 'xsi:type' not in already_processed: 2396 already_processed.add('xsi:type') 2397 xsi_type = " xsi:type='%s:%s'" % (self.xmlns_prefix, self.xml_type) 2398 lwrite(xsi_type) 2399 if self.URL is not None and 'URL' not in already_processed: 2400 already_processed.add('URL') 2401 lwrite(' URL=%s' % (quote_attrib(self.URL), )) 2402 if self.version is not None and 'version' not in already_processed: 2403 already_processed.add('version') 2404 lwrite(' version=%s' % (quote_attrib(self.version), )) 2405 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='IncidentType', fromsubclass_=False, pretty_print=True): 2406 super(IncidentType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, True, pretty_print=pretty_print) 2407 if pretty_print: 2408 eol_ = '\n' 2409 else: 2410 eol_ = '' 2411 if self.Title is not None: 2412 showIndent(lwrite, level, pretty_print) 2413 lwrite('<%s:Title>%s</%s:Title>%s' % (nsmap[namespace_], quote_xml(self.Title), nsmap[namespace_], eol_)) 2414 for External_ID_ in self.External_ID: 2415 External_ID_.export(lwrite, level, nsmap, namespace_, name_='External_ID', pretty_print=pretty_print) 2416 if self.Time is not None: 2417 self.Time.export(lwrite, level, nsmap, namespace_, name_='Time', pretty_print=pretty_print) 2418 for Description in self.Description: 2419 Description.export(lwrite, level, nsmap, namespace_, name_='Description', pretty_print=pretty_print) 2420 for Short_Description in self.Short_Description: 2421 Short_Description.export(lwrite, level, nsmap, namespace_, name_='Short_Description', pretty_print=pretty_print) 2422 if self.Categories is not None: 2423 self.Categories.export(lwrite, level, nsmap, namespace_, name_='Categories', pretty_print=pretty_print) 2424 if self.Reporter is not None: 2425 self.Reporter.export(lwrite, level, nsmap, namespace_, name_='Reporter', pretty_print=pretty_print) 2426 for Responder_ in self.Responder: 2427 Responder_.export(lwrite, level, nsmap, namespace_, name_='Responder', pretty_print=pretty_print) 2428 for Coordinator_ in self.Coordinator: 2429 Coordinator_.export(lwrite, level, nsmap, namespace_, name_='Coordinator', pretty_print=pretty_print) 2430 for Victim_ in self.Victim: 2431 Victim_.export(lwrite, level, nsmap, namespace_, name_='Victim', pretty_print=pretty_print) 2432 if self.Affected_Assets is not None: 2433 self.Affected_Assets.export(lwrite, level, nsmap, namespace_, name_='Affected_Assets', pretty_print=pretty_print) 2434 if self.Impact_Assessment is not None: 2435 self.Impact_Assessment.export(lwrite, level, nsmap, namespace_, name_='Impact_Assessment', pretty_print=pretty_print) 2436 if self.Status is not None: 2437 self.Status.export(lwrite, level, nsmap, namespace_, name_='Status', pretty_print=pretty_print) 2438 if self.Related_Indicators is not None: 2439 self.Related_Indicators.export(lwrite, level, nsmap, namespace_, name_='Related_Indicators', pretty_print=pretty_print) 2440 if self.Related_Observables is not None: 2441 self.Related_Observables.export(lwrite, level, nsmap, namespace_, name_='Related_Observables', pretty_print=pretty_print) 2442 if self.Leveraged_TTPs is not None: 2443 self.Leveraged_TTPs.export(lwrite, level, nsmap, namespace_, name_='Leveraged_TTPs', pretty_print=pretty_print) 2444 if self.Attributed_Threat_Actors is not None: 2445 self.Attributed_Threat_Actors.export(lwrite, level, nsmap, namespace_, name_='Attributed_Threat_Actors', pretty_print=pretty_print) 2446 for Intended_Effect_ in self.Intended_Effect: 2447 Intended_Effect_.export(lwrite, level, nsmap, namespace_, name_='Intended_Effect', pretty_print=pretty_print) 2448 if self.Security_Compromise is not None: 2449 self.Security_Compromise.export(lwrite, level, nsmap, namespace_, name_='Security_Compromise', pretty_print=pretty_print) 2450 for Discovery_Method_ in self.Discovery_Method: 2451 Discovery_Method_.export(lwrite, level, nsmap, namespace_, name_='Discovery_Method', pretty_print=pretty_print) 2452 if self.Related_Incidents is not None: 2453 self.Related_Incidents.export(lwrite, level, nsmap, namespace_, name_='Related_Incidents', pretty_print=pretty_print) 2454 for COA_Requested_ in self.COA_Requested: 2455 COA_Requested_.export(lwrite, level, nsmap, namespace_, name_='COA_Requested', pretty_print=pretty_print) 2456 for COA_Taken_ in self.COA_Taken: 2457 COA_Taken_.export(lwrite, level, nsmap, namespace_, name_='COA_Taken', pretty_print=pretty_print) 2458 if self.Confidence is not None: 2459 self.Confidence.export(lwrite, level, nsmap, namespace_, name_='Confidence', pretty_print=pretty_print) 2460 for Contact_ in self.Contact: 2461 Contact_.export(lwrite, level, nsmap, namespace_, name_='Contact', pretty_print=pretty_print) 2462 if self.History is not None: 2463 self.History.export(lwrite, level, nsmap, namespace_, name_='History', pretty_print=pretty_print) 2464 if self.Information_Source is not None: 2465 self.Information_Source.export(lwrite, level, nsmap, namespace_, name_='Information_Source', pretty_print=pretty_print) 2466 if self.Handling is not None: 2467 self.Handling.export(lwrite, level, nsmap, namespace_, name_='Handling', pretty_print=pretty_print) 2468 if self.Related_Packages is not None: 2469 self.Related_Packages.export(lwrite, level, nsmap, namespace_, name_='Related_Packages', pretty_print=pretty_print) 2470 def build(self, node): 2471 self.__sourcenode__ = node 2472 already_processed = set() 2473 self.buildAttributes(node, node.attrib, already_processed) 2474 for child in node: 2475 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2476 self.buildChildren(child, node, nodeName_) 2477 def buildAttributes(self, node, attrs, already_processed): 2478 value = find_attr_value_('URL', node) 2479 if value is not None and 'URL' not in already_processed: 2480 already_processed.add('URL') 2481 self.URL = value 2482 value = find_attr_value_('version', node) 2483 if value is not None and 'version' not in already_processed: 2484 already_processed.add('version') 2485 self.version = value 2486 super(IncidentType, self).buildAttributes(node, attrs, already_processed) 2487 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2488 if nodeName_ == 'Title': 2489 Title_ = child_.text 2490 Title_ = self.gds_validate_string(Title_, node, 'Title') 2491 self.Title = Title_ 2492 elif nodeName_ == 'External_ID': 2493 obj_ = ExternalIDType.factory() 2494 obj_.build(child_) 2495 self.External_ID.append(obj_) 2496 elif nodeName_ == 'Time': 2497 obj_ = TimeType.factory() 2498 obj_.build(child_) 2499 self.set_Time(obj_) 2500 elif nodeName_ == 'Description': 2501 obj_ = stix_common_binding.StructuredTextType.factory() 2502 obj_.build(child_) 2503 self.add_Description(obj_) 2504 elif nodeName_ == 'Short_Description': 2505 obj_ = stix_common_binding.StructuredTextType.factory() 2506 obj_.build(child_) 2507 self.add_Short_Description(obj_) 2508 elif nodeName_ == 'Categories': 2509 obj_ = CategoriesType.factory() 2510 obj_.build(child_) 2511 self.set_Categories(obj_) 2512 elif nodeName_ == 'Reporter': 2513 obj_ = stix_common_binding.InformationSourceType.factory() 2514 obj_.build(child_) 2515 self.set_Reporter(obj_) 2516 elif nodeName_ == 'Responder': 2517 obj_ = stix_common_binding.InformationSourceType.factory() 2518 obj_.build(child_) 2519 self.Responder.append(obj_) 2520 elif nodeName_ == 'Coordinator': 2521 obj_ = stix_common_binding.InformationSourceType.factory() 2522 obj_.build(child_) 2523 self.Coordinator.append(obj_) 2524 elif nodeName_ == 'Victim': 2525 import stix.bindings.extensions.identity.ciq_identity_3_0 as ciq_identity_binding 2526 obj_ = lookup_extension(child_, stix_common_binding.IdentityType).factory() 2527 obj_.build(child_) 2528 self.Victim.append(obj_) 2529 elif nodeName_ == 'Affected_Assets': 2530 obj_ = AffectedAssetsType.factory() 2531 obj_.build(child_) 2532 self.set_Affected_Assets(obj_) 2533 elif nodeName_ == 'Impact_Assessment': 2534 obj_ = ImpactAssessmentType.factory() 2535 obj_.build(child_) 2536 self.set_Impact_Assessment(obj_) 2537 elif nodeName_ == 'Status': 2538 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 2539 obj_.build(child_) 2540 self.set_Status(obj_) 2541 elif nodeName_ == 'Related_Indicators': 2542 obj_ = RelatedIndicatorsType.factory() 2543 obj_.build(child_) 2544 self.set_Related_Indicators(obj_) 2545 elif nodeName_ == 'Related_Observables': 2546 obj_ = RelatedObservablesType.factory() 2547 obj_.build(child_) 2548 self.set_Related_Observables(obj_) 2549 elif nodeName_ == 'Leveraged_TTPs': 2550 obj_ = LeveragedTTPsType.factory() 2551 obj_.build(child_) 2552 self.set_Leveraged_TTPs(obj_) 2553 elif nodeName_ == 'Attributed_Threat_Actors': 2554 obj_ = AttributedThreatActorsType.factory() 2555 obj_.build(child_) 2556 self.set_Attributed_Threat_Actors(obj_) 2557 elif nodeName_ == 'Intended_Effect': 2558 obj_ = stix_common_binding.StatementType.factory() 2559 obj_.build(child_) 2560 self.Intended_Effect.append(obj_) 2561 elif nodeName_ == 'Security_Compromise': 2562 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 2563 obj_.build(child_) 2564 self.set_Security_Compromise(obj_) 2565 elif nodeName_ == 'Discovery_Method': 2566 obj_ = stix_common_binding.ControlledVocabularyStringType.factory() 2567 obj_.build(child_) 2568 self.Discovery_Method.append(obj_) 2569 elif nodeName_ == 'Related_Incidents': 2570 obj_ = RelatedIncidentsType.factory() 2571 obj_.build(child_) 2572 self.set_Related_Incidents(obj_) 2573 elif nodeName_ == 'COA_Requested': 2574 obj_ = COARequestedType.factory() 2575 obj_.build(child_) 2576 self.COA_Requested.append(obj_) 2577 elif nodeName_ == 'COA_Taken': 2578 class_obj_ = self.get_class_obj_(child_, COATakenType) 2579 obj_ = class_obj_.factory() 2580 obj_.build(child_) 2581 self.COA_Taken.append(obj_) 2582 elif nodeName_ == 'Confidence': 2583 obj_ = stix_common_binding.ConfidenceType.factory() 2584 obj_.build(child_) 2585 self.set_Confidence(obj_) 2586 elif nodeName_ == 'Contact': 2587 obj_ = stix_common_binding.InformationSourceType.factory() 2588 obj_.build(child_) 2589 self.Contact.append(obj_) 2590 elif nodeName_ == 'History': 2591 obj_ = HistoryType.factory() 2592 obj_.build(child_) 2593 self.set_History(obj_) 2594 elif nodeName_ == 'Information_Source': 2595 obj_ = stix_common_binding.InformationSourceType.factory() 2596 obj_.build(child_) 2597 self.set_Information_Source(obj_) 2598 elif nodeName_ == 'Handling': 2599 obj_ = data_marking_binding.MarkingType.factory() 2600 obj_.build(child_) 2601 self.set_Handling(obj_) 2602 elif nodeName_ == 'Related_Packages': 2603 obj_ = stix_common_binding.RelatedPackageRefsType.factory() 2604 obj_.build(child_) 2605 self.set_Related_Packages(obj_) 2606 super(IncidentType, self).buildChildren(child_, node, nodeName_, True) 2607# end class IncidentType 2608 2609class NonPublicDataCompromisedType(stix_common_binding.ControlledVocabularyStringType): 2610 """This type represents whether non-public data was compromised or 2611 exposed and whether that data was encrypted or not.Indicates 2612 whether the data that was compromised was encrypted or not.""" 2613 subclass = None 2614 superclass = stix_common_binding.ControlledVocabularyStringType 2615 def __init__(self, vocab_reference=None, vocab_name=None, data_encrypted=None): 2616 super(NonPublicDataCompromisedType, self).__init__(vocab_reference=vocab_reference, vocab_name=vocab_name) 2617 self.data_encrypted = _cast(bool, data_encrypted) 2618 pass 2619 def factory(*args_, **kwargs_): 2620 if NonPublicDataCompromisedType.subclass: 2621 return NonPublicDataCompromisedType.subclass(*args_, **kwargs_) 2622 else: 2623 return NonPublicDataCompromisedType(*args_, **kwargs_) 2624 factory = staticmethod(factory) 2625 def get_data_encrypted(self): return self.data_encrypted 2626 def set_data_encrypted(self, data_encrypted): self.data_encrypted = data_encrypted 2627 def hasContent_(self): 2628 if ( 2629 super(NonPublicDataCompromisedType, self).hasContent_() 2630 ): 2631 return True 2632 else: 2633 return False 2634 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='NonPublicDataCompromisedType', namespacedef_='', pretty_print=True): 2635 if pretty_print: 2636 eol_ = '\n' 2637 else: 2638 eol_ = '' 2639 showIndent(lwrite, level, pretty_print) 2640 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2641 already_processed = set() 2642 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='NonPublicDataCompromisedType') 2643 if self.hasContent_(): 2644 lwrite('>') 2645 lwrite(quote_xml(self.valueOf_)) 2646 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 2647 else: 2648 lwrite('/>%s' % (eol_, )) 2649 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='NonPublicDataCompromisedType'): 2650 super(NonPublicDataCompromisedType, self).exportAttributes(lwrite, level, already_processed, namespace_, name_='NonPublicDataCompromisedType') 2651 if self.data_encrypted is not None and 'data_encrypted' not in already_processed: 2652 already_processed.add('data_encrypted') 2653 lwrite(' data_encrypted="%s"' % self.gds_format_boolean(self.data_encrypted, input_name='data_encrypted')) 2654 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='NonPublicDataCompromisedType', fromsubclass_=False, pretty_print=True): 2655 super(NonPublicDataCompromisedType, self).exportChildren(lwrite, level, nsmap, namespace_, name_, True, pretty_print=pretty_print) 2656 pass 2657 def build(self, node): 2658 self.__sourcenode__ = node 2659 already_processed = set() 2660 self.buildAttributes(node, node.attrib, already_processed) 2661 for child in node: 2662 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2663 self.buildChildren(child, node, nodeName_) 2664 def buildAttributes(self, node, attrs, already_processed): 2665 value = find_attr_value_('data_encrypted', node) 2666 if value is not None and 'data_encrypted' not in already_processed: 2667 already_processed.add('data_encrypted') 2668 if value in ('true', '1'): 2669 self.data_encrypted = True 2670 elif value in ('false', '0'): 2671 self.data_encrypted = False 2672 else: 2673 raise_parse_error(node, 'Bad boolean attribute') 2674 super(NonPublicDataCompromisedType, self).buildAttributes(node, attrs, already_processed) 2675 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2676 super(NonPublicDataCompromisedType, self).buildChildren(child_, node, nodeName_, True) 2677 pass 2678# end class NonPublicDataCompromisedType 2679 2680class ExternalIDType(GeneratedsSuper): 2681 """The ExternalIDType provides a reference to an ID of an incident in a 2682 remote system.Specifies the source of the External ID.""" 2683 subclass = None 2684 superclass = None 2685 def __init__(self, source=None, valueOf_=None): 2686 self.source = _cast(None, source) 2687 self.valueOf_ = valueOf_ 2688 def factory(*args_, **kwargs_): 2689 if ExternalIDType.subclass: 2690 return ExternalIDType.subclass(*args_, **kwargs_) 2691 else: 2692 return ExternalIDType(*args_, **kwargs_) 2693 factory = staticmethod(factory) 2694 def get_source(self): return self.source 2695 def set_source(self, source): self.source = source 2696 def get_valueOf_(self): return self.valueOf_ 2697 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2698 def hasContent_(self): 2699 if ( 2700 self.valueOf_ 2701 ): 2702 return True 2703 else: 2704 return False 2705 def export(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ExternalIDType', namespacedef_='', pretty_print=True): 2706 if pretty_print: 2707 eol_ = '\n' 2708 else: 2709 eol_ = '' 2710 showIndent(lwrite, level, pretty_print) 2711 lwrite('<%s:%s%s' % (nsmap[namespace_], name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2712 already_processed = set() 2713 self.exportAttributes(lwrite, level, already_processed, namespace_, name_='ExternalIDType') 2714 if self.hasContent_(): 2715 lwrite('>') 2716 lwrite(quote_xml(self.valueOf_)) 2717 lwrite('</%s:%s>%s' % (nsmap[namespace_], name_, eol_)) 2718 else: 2719 lwrite('/>%s' % (eol_, )) 2720 def exportAttributes(self, lwrite, level, already_processed, namespace_='incident:', name_='ExternalIDType'): 2721 if self.source is not None and 'source' not in already_processed: 2722 already_processed.add('source') 2723 lwrite(' source=%s' % (quote_attrib(self.source), )) 2724 def exportChildren(self, lwrite, level, nsmap, namespace_=XML_NS, name_='ExternalIDType', fromsubclass_=False, pretty_print=True): 2725 pass 2726 def build(self, node): 2727 self.__sourcenode__ = node 2728 already_processed = set() 2729 self.buildAttributes(node, node.attrib, already_processed) 2730 self.valueOf_ = get_all_text_(node) 2731 for child in node: 2732 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2733 self.buildChildren(child, node, nodeName_) 2734 def buildAttributes(self, node, attrs, already_processed): 2735 value = find_attr_value_('source', node) 2736 if value is not None and 'source' not in already_processed: 2737 already_processed.add('source') 2738 self.source = value 2739 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2740 pass 2741# end class ExternalIDType 2742 2743 2744GDSClassesMapping = {} 2745 2746USAGE_TEXT = """ 2747Usage: python <Parser>.py [ -s ] <in_xml_file> 2748""" 2749 2750def usage(): 2751 print(USAGE_TEXT) 2752 sys.exit(1) 2753 2754def get_root_tag(node): 2755 tag = Tag_pattern_.match(node.tag).groups()[-1] 2756 rootClass = GDSClassesMapping.get(tag) 2757 if rootClass is None: 2758 rootClass = globals().get(tag) 2759 return tag, rootClass 2760 2761def parse(inFileName): 2762 doc = parsexml_(inFileName) 2763 rootNode = doc.getroot() 2764 rootTag, rootClass = get_root_tag(rootNode) 2765 if rootClass is None: 2766 rootTag = 'Incident' 2767 rootClass = IncidentType 2768 rootObj = rootClass.factory() 2769 rootObj.build(rootNode) 2770 # Enable Python to collect the space used by the DOM. 2771 doc = None 2772 # sys.stdout.write('<?xml version="1.0" ?>\n') 2773 # rootObj.export(sys.stdout, 0, name_=rootTag, 2774 # namespacedef_='', 2775 # pretty_print=True) 2776 return rootObj 2777 2778def parseEtree(inFileName): 2779 doc = parsexml_(inFileName) 2780 rootNode = doc.getroot() 2781 rootTag, rootClass = get_root_tag(rootNode) 2782 if rootClass is None: 2783 rootTag = 'Incident' 2784 rootClass = IncidentType 2785 rootObj = rootClass.factory() 2786 rootObj.build(rootNode) 2787 # Enable Python to collect the space used by the DOM. 2788 doc = None 2789 rootElement = rootObj.to_etree(None, name_=rootTag) 2790 content = etree_.tostring(rootElement, pretty_print=True, 2791 xml_declaration=True, encoding="utf-8") 2792 sys.stdout.write(content) 2793 sys.stdout.write('\n') 2794 return rootObj, rootElement 2795 2796def parseString(inString): 2797 from mixbox.vendor.six import BytesIO 2798 doc = parsexml_(BytesIO(inString.encode('utf-8'))) 2799 rootNode = doc.getroot() 2800 rootTag, rootClass = get_root_tag(rootNode) 2801 if rootClass is None: 2802 rootTag = 'Incident' 2803 rootClass = IncidentType 2804 rootObj = rootClass.factory() 2805 rootObj.build(rootNode) 2806 # Enable Python to collect the space used by the DOM. 2807 doc = None 2808 # sys.stdout.write('<?xml version="1.0" ?>\n') 2809 # rootObj.export(sys.stdout, 0, name_="Incident", 2810 # namespacedef_='') 2811 return rootObj 2812 2813def main(): 2814 args = sys.argv[1:] 2815 if len(args) == 1: 2816 parse(args[0]) 2817 else: 2818 usage() 2819 2820if __name__ == '__main__': 2821 #import pdb; pdb.set_trace() 2822 main() 2823 2824__all__ = [ 2825 "PropertyAffectedType", 2826 "AffectedAssetType", 2827 "ImpactAssessmentType", 2828 "ExternalImpactAssessmentModelType", 2829 "COATakenType", 2830 "JournalEntryType", 2831 "COARequestedType", 2832 "ContributorsType", 2833 "COATimeType", 2834 "LossEstimationType", 2835 "TotalLossEstimationType", 2836 "IndirectImpactSummaryType", 2837 "DirectImpactSummaryType", 2838 "NatureOfSecurityEffectType", 2839 "HistoryItemType", 2840 "HistoryType", 2841 "AffectedAssetsType", 2842 "TimeType", 2843 "CategoriesType", 2844 "EffectsType", 2845 "AttributedThreatActorsType", 2846 "RelatedIndicatorsType", 2847 "RelatedObservablesType", 2848 "LeveragedTTPsType", 2849 "RelatedIncidentsType", 2850 "AssetTypeType", 2851 "IncidentType" 2852 ] 2853