1# -*- coding: utf-8 -*- 2# Copyright (c) 2018, The MITRE Corporation. All rights reserved. 3# See LICENSE.txt for complete terms. 4 5import sys 6 7from mixbox.binding_utils import * 8 9class malwareMetaData(GeneratedsSuper): 10 """This is the top level element for the xml document. Required 11 attribute is version. Open issues: 2. Right way to express 12 commonality in field data so that it can be combined properly 3. 13 How to handle unicode in urls Change list 08/26/2011 Clean-file 14 attribute based changes 1. added digitalSignature to objects 2. 15 added softwarePackage to objects 3. added taggant to objects 4. 16 added numerous elements to fileObject 11/12/2009 1. adding 17 documentation across the schema 2. added partner to 18 OriginTypeEnum 3. made sha1 in fileObject optional 4. added 19 isDamaged as a propertyType 5. changed property name isNon- 20 replicating to isNonReplicating 6/11/2009 1. incremented version 21 2.Rename parents/children in relationship to source/target 3. 22 Add generic relationship, ‘relatedTo’ 4. Make commonality 23 element in fieldDataEntry optional 5. Add unknown element to 24 origintypeenum 6. Remove ipv4 and ipv6 from locationenum 7. Make 25 id on ip object startaddress-endaddress even if startaddress == 26 endaddress. Added IPRange type 8. Add optional firstSeenDate to 27 fieldDataEntry, for first time entity providing data saw the 28 object 6/4/2009 1. File - id should be a xs:hexBinary 2. File - 29 extraHash should be a xs:string 3. Uri – add optional 30 ipProtocol field, with enumeration of values tcp/udp/icmp etc. 31 4. Uri – add documentation that protocol in uri needs to be 32 either from well known list (from iana.org) or ‘unknown’ 5. 33 Domain - need to fix documentation for domain – example is 34 wrong 6. registry – remove valuedata – it is in a property 35 7. ip object – rename to ip, and give it a start address and 36 end address. Share a single address by making start and end the 37 same. Id will be address or startaddress-endaddress 8. service 38 – delete – subsumed by uri with extra data elements in it 9. 39 classification – remove modifiers (attributes) on category and 40 put in properties 10. classification – add documentation that 41 category is companyname:category 11. objectProperty – move 42 timestamp to be top level instead of on each property and make 43 it required 12. relationship – make timestamp required 13. 44 relationship – add doc on runs. removed 'exploits' - it refers 45 to environment object that no longer exists 14. added comment 46 field to propertyenum 15. made timeStamp -> timestamp for 47 consistency 16.incremented version 5/31/2009 1. incremented 48 version 2. changed url to uri 3. removed environment object and 49 related enumerations 4. added restriction on uri to not allow a 50 question mark (?) 5/15/2009 1. incremented version 2. Added 51 neutral classification type 3. Added numberOfWebsitesHosting and 52 numberOfWebsitesRedirecting to volume units enumeration 4. added 53 referrer, operatingSystem, userAgent and browser to properties 54 5. made classification type attribute required 5/8/2009 1. added 55 new object type for asn 2. moved domain information to 56 properties, so that domains info can be timestamped 3. added 57 properties for geolocation of an ip address 4. added property 58 for location url for a file 5. added VolumeUnitsEnum and volume 59 tag in fieldData. This is to allow sharing of actual prevalence 60 numbers, with various units. 6. Added ipProtocol (tcp/udp) to 61 service object. Also changed names of expectedProtocol and 62 actualProtocol to be expectedApplicationProtocol and 63 actualApplicationProtocol 7. added 'references' surrounding tag 64 to ref tag in fieldDataEntry and objectProperty, so that can 65 assign multiple references if required 8. made id on file back 66 to hexBinary. Use length to figure out what hash it is. 9. 67 incremented version 10. added properties for httpMethod and 68 postData 11. added relationship types 'contactedBy' and 69 'downloadedFrom' 4/17/2009 1. Incremented version 2. Added 70 unwanted to ClassificationTypeEnum 3. Added text about ids for 71 files to documentation 4. Removed filename from file object 72 definition 5. Relaxed requirement on id of file to be an 73 xs:hexString to be an xs:string to allow e.g. md5:aaaaabbbbccc 74 as an id. Not enormously happy about that… 6. Made sha256 75 optional and sha1 required in files 7. Added “open issues” 76 section in documentation for top level element 8. Category is 77 now an xs:string; deleted CategoryTypeEnum 9. Added comment to 78 doc on fieldDataEntry about using standard time periods, but 79 kept start date and end date 10. Added objectProperties element, 80 and example illustratingProperties.xml. Currently allowed 81 properties are filename, filepath, registryValueData and 82 urlParameterString. There is an optional timestamp on each 83 property. I allowed objectProperty to have an id, so that it can 84 be referenced elsewhere, although we might want to re-think 85 that. 11. Added some better documentation to relationships 12. 86 Added more documentation throughout The version of the schema. 87 This is currently fixed to be 1.1. A required identifier for the 88 document.""" 89 subclass = None 90 superclass = None 91 def __init__(self, version=None, id=None, company=None, author=None, comment=None, timestamp=None, objects=None, objectProperties=None, relationships=None, fieldData=None): 92 self.version = _cast(float, version) 93 self.id = _cast(None, id) 94 self.company = company 95 self.author = author 96 self.comment = comment 97 self.timestamp = timestamp 98 self.objects = objects 99 self.objectProperties = objectProperties 100 self.relationships = relationships 101 self.fieldData = fieldData 102 def factory(*args_, **kwargs_): 103 if malwareMetaData.subclass: 104 return malwareMetaData.subclass(*args_, **kwargs_) 105 else: 106 return malwareMetaData(*args_, **kwargs_) 107 factory = staticmethod(factory) 108 def get_company(self): return self.company 109 def set_company(self, company): self.company = company 110 def get_author(self): return self.author 111 def set_author(self, author): self.author = author 112 def get_comment(self): return self.comment 113 def set_comment(self, comment): self.comment = comment 114 def get_timestamp(self): return self.timestamp 115 def set_timestamp(self, timestamp): self.timestamp = timestamp 116 def get_objects(self): return self.objects 117 def set_objects(self, objects): self.objects = objects 118 def get_objectProperties(self): return self.objectProperties 119 def set_objectProperties(self, objectProperties): self.objectProperties = objectProperties 120 def get_relationships(self): return self.relationships 121 def set_relationships(self, relationships): self.relationships = relationships 122 def get_fieldData(self): return self.fieldData 123 def set_fieldData(self, fieldData): self.fieldData = fieldData 124 def get_version(self): return self.version 125 def set_version(self, version): self.version = version 126 def get_id(self): return self.id 127 def set_id(self, id): self.id = id 128 def export(self, write, level, namespace_='', name_='malwareMetaData', namespacedef_=''): 129 showIndent(write, level) 130 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 131 already_processed = [] 132 self.exportAttributes(write, level, already_processed, namespace_, name_='malwareMetaData') 133 if self.hasContent_(): 134 write('>\n') 135 self.exportChildren(write, level + 1, namespace_, name_) 136 showIndent(write, level) 137 write('</%s%s>\n' % (namespace_, name_)) 138 else: 139 write('/>\n') 140 def exportAttributes(self, write, level, already_processed, namespace_='', name_='malwareMetaData'): 141 if self.version is not None and 'version' not in already_processed: 142 already_processed.append('version') 143 write(' version="%s"' % self.gds_format_float(self.version, input_name='version')) 144 if self.id is not None and 'id' not in already_processed: 145 already_processed.append('id') 146 write(' id=%s' % (quote_attrib(self.id))) 147 def exportChildren(self, write, level, namespace_='', name_='malwareMetaData', fromsubclass_=False): 148 if self.company is not None: 149 showIndent(write, level) 150 write('<%scompany>%s</%scompany>\n' % (namespace_, quote_xml(self.company), namespace_)) 151 if self.author is not None: 152 showIndent(write, level) 153 write('<%sauthor>%s</%sauthor>\n' % (namespace_, quote_xml(self.author), namespace_)) 154 if self.comment is not None: 155 showIndent(write, level) 156 write('<%scomment>%s</%scomment>\n' % (namespace_, quote_xml(self.comment), namespace_)) 157 if self.timestamp is not None: 158 showIndent(write, level) 159 write('<%stimestamp>%s</%stimestamp>\n' % (namespace_, quote_xml(self.timestamp), namespace_)) 160 if self.objects is not None: 161 self.objects.export(write, level, namespace_, name_='objects') 162 if self.objectProperties is not None: 163 self.objectProperties.export(write, level, namespace_, name_='objectProperties') 164 if self.relationships is not None: 165 self.relationships.export(write, level, namespace_, name_='relationships') 166 if self.fieldData is not None: 167 self.fieldData.export(write, level, namespace_, name_='fieldData') 168 def hasContent_(self): 169 if ( 170 self.company is not None or 171 self.author is not None or 172 self.comment is not None or 173 self.timestamp is not None or 174 self.objects is not None or 175 self.objectProperties is not None or 176 self.relationships is not None or 177 self.fieldData is not None 178 ): 179 return True 180 else: 181 return False 182 def build(self, node): 183 self.__sourcenode__ = node 184 self.buildAttributes(node, node.attrib, []) 185 for child in node: 186 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 187 self.buildChildren(child, node, nodeName_) 188 def buildAttributes(self, node, attrs, already_processed): 189 value = find_attr_value_('version', node) 190 if value is not None and 'version' not in already_processed: 191 already_processed.append('version') 192 try: 193 self.version = float(value) 194 except ValueError as exp: 195 raise ValueError('Bad float/double attribute (version): %s' % exp) 196 value = find_attr_value_('id', node) 197 if value is not None and 'id' not in already_processed: 198 already_processed.append('id') 199 self.id = value 200 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 201 if nodeName_ == 'company': 202 company_ = child_.text 203 company_ = self.gds_validate_string(company_, node, 'company') 204 self.company = company_ 205 elif nodeName_ == 'author': 206 author_ = child_.text 207 author_ = self.gds_validate_string(author_, node, 'author') 208 self.author = author_ 209 elif nodeName_ == 'comment': 210 comment_ = child_.text 211 comment_ = self.gds_validate_string(comment_, node, 'comment') 212 self.comment = comment_ 213 elif nodeName_ == 'timestamp': 214 timestamp_ = child_.text 215 timestamp_ = self.gds_validate_string(timestamp_, node, 'timestamp') 216 self.timestamp = timestamp_ 217 elif nodeName_ == 'objects': 218 obj_ = objects.factory() 219 obj_.build(child_) 220 self.set_objects(obj_) 221 elif nodeName_ == 'objectProperties': 222 obj_ = objectProperties.factory() 223 obj_.build(child_) 224 self.set_objectProperties(obj_) 225 elif nodeName_ == 'relationships': 226 obj_ = relationships.factory() 227 obj_.build(child_) 228 self.set_relationships(obj_) 229 elif nodeName_ == 'fieldData': 230 obj_ = fieldData.factory() 231 obj_.build(child_) 232 self.set_fieldData(obj_) 233# end class malwareMetaData 234 235 236class objects(GeneratedsSuper): 237 """Objects are globally unique files, urls, domain, registry, ipAddress 238 etc. The data within the object is supporting data for the 239 globally unique object. For example, files have an id (by 240 convention the hash, sha256 if available, else weaker ones), and 241 the data for the file is the hashes, sizes etc. Urls have an id 242 (the url itself), and data which is simply the url parts broken 243 out. There are no dates, etc in the objects. These are first 244 class, global objects.""" 245 subclass = None 246 superclass = None 247 def __init__(self, file=None, uri=None, domain=None, registry=None, ip=None, asn=None, entity=None, classification=None, softwarePackage=None, digitalSignature=None, taggant=None): 248 if file is None: 249 self.file = [] 250 else: 251 self.file = file 252 if uri is None: 253 self.uri = [] 254 else: 255 self.uri = uri 256 if domain is None: 257 self.domain = [] 258 else: 259 self.domain = domain 260 if registry is None: 261 self.registry = [] 262 else: 263 self.registry = registry 264 if ip is None: 265 self.ip = [] 266 else: 267 self.ip = ip 268 if asn is None: 269 self.asn = [] 270 else: 271 self.asn = asn 272 if entity is None: 273 self.entity = [] 274 else: 275 self.entity = entity 276 if classification is None: 277 self.classification = [] 278 else: 279 self.classification = classification 280 if softwarePackage is None: 281 self.softwarePackage = [] 282 else: 283 self.softwarePackage = softwarePackage 284 if digitalSignature is None: 285 self.digitalSignature = [] 286 else: 287 self.digitalSignature = digitalSignature 288 if taggant is None: 289 self.taggant = [] 290 else: 291 self.taggant = taggant 292 def factory(*args_, **kwargs_): 293 if objects.subclass: 294 return objects.subclass(*args_, **kwargs_) 295 else: 296 return objects(*args_, **kwargs_) 297 factory = staticmethod(factory) 298 def get_file(self): return self.file 299 def set_file(self, file): self.file = file 300 def add_file(self, value): self.file.append(value) 301 def insert_file(self, index, value): self.file[index] = value 302 def get_uri(self): return self.uri 303 def set_uri(self, uri): self.uri = uri 304 def add_uri(self, value): self.uri.append(value) 305 def insert_uri(self, index, value): self.uri[index] = value 306 def get_domain(self): return self.domain 307 def set_domain(self, domain): self.domain = domain 308 def add_domain(self, value): self.domain.append(value) 309 def insert_domain(self, index, value): self.domain[index] = value 310 def get_registry(self): return self.registry 311 def set_registry(self, registry): self.registry = registry 312 def add_registry(self, value): self.registry.append(value) 313 def insert_registry(self, index, value): self.registry[index] = value 314 def get_ip(self): return self.ip 315 def set_ip(self, ip): self.ip = ip 316 def add_ip(self, value): self.ip.append(value) 317 def insert_ip(self, index, value): self.ip[index] = value 318 def get_asn(self): return self.asn 319 def set_asn(self, asn): self.asn = asn 320 def add_asn(self, value): self.asn.append(value) 321 def insert_asn(self, index, value): self.asn[index] = value 322 def get_entity(self): return self.entity 323 def set_entity(self, entity): self.entity = entity 324 def add_entity(self, value): self.entity.append(value) 325 def insert_entity(self, index, value): self.entity[index] = value 326 def get_classification(self): return self.classification 327 def set_classification(self, classification): self.classification = classification 328 def add_classification(self, value): self.classification.append(value) 329 def insert_classification(self, index, value): self.classification[index] = value 330 def get_softwarePackage(self): return self.softwarePackage 331 def set_softwarePackage(self, softwarePackage): self.softwarePackage = softwarePackage 332 def add_softwarePackage(self, value): self.softwarePackage.append(value) 333 def insert_softwarePackage(self, index, value): self.softwarePackage[index] = value 334 def get_digitalSignature(self): return self.digitalSignature 335 def set_digitalSignature(self, digitalSignature): self.digitalSignature = digitalSignature 336 def add_digitalSignature(self, value): self.digitalSignature.append(value) 337 def insert_digitalSignature(self, index, value): self.digitalSignature[index] = value 338 def get_taggant(self): return self.taggant 339 def set_taggant(self, taggant): self.taggant = taggant 340 def add_taggant(self, value): self.taggant.append(value) 341 def insert_taggant(self, index, value): self.taggant[index] = value 342 def export(self, write, level, namespace_='', name_='objects', namespacedef_=''): 343 showIndent(write, level) 344 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 345 already_processed = [] 346 self.exportAttributes(write, level, already_processed, namespace_, name_='objects') 347 if self.hasContent_(): 348 write('>\n') 349 self.exportChildren(write, level + 1, namespace_, name_) 350 showIndent(write, level) 351 write('</%s%s>\n' % (namespace_, name_)) 352 else: 353 write('/>\n') 354 def exportAttributes(self, write, level, already_processed, namespace_='', name_='objects'): 355 pass 356 def exportChildren(self, write, level, namespace_='', name_='objects', fromsubclass_=False): 357 for file_ in self.file: 358 file_.export(write, level, namespace_, name_='file') 359 for uri_ in self.uri: 360 uri_.export(write, level, namespace_, name_='uri') 361 for domain_ in self.domain: 362 domain_.export(write, level, namespace_, name_='domain') 363 for registry_ in self.registry: 364 registry_.export(write, level, namespace_, name_='registry') 365 for ip_ in self.ip: 366 ip_.export(write, level, namespace_, name_='ip') 367 for asn_ in self.asn: 368 asn_.export(write, level, namespace_, name_='asn') 369 for entity_ in self.entity: 370 entity_.export(write, level, namespace_, name_='entity') 371 for classification_ in self.classification: 372 classification_.export(write, level, namespace_, name_='classification') 373 for softwarePackage_ in self.softwarePackage: 374 softwarePackage_.export(write, level, namespace_, name_='softwarePackage') 375 for digitalSignature_ in self.digitalSignature: 376 digitalSignature_.export(write, level, namespace_, name_='digitalSignature') 377 for taggant_ in self.taggant: 378 taggant_.export(write, level, namespace_, name_='taggant') 379 def hasContent_(self): 380 if ( 381 self.file or 382 self.uri or 383 self.domain or 384 self.registry or 385 self.ip or 386 self.asn or 387 self.entity or 388 self.classification or 389 self.softwarePackage or 390 self.digitalSignature or 391 self.taggant 392 ): 393 return True 394 else: 395 return False 396 def build(self, node): 397 self.__sourcenode__ = node 398 self.buildAttributes(node, node.attrib, []) 399 for child in node: 400 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 401 self.buildChildren(child, node, nodeName_) 402 def buildAttributes(self, node, attrs, already_processed): 403 pass 404 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 405 if nodeName_ == 'file': 406 obj_ = fileObject.factory() 407 obj_.build(child_) 408 self.file.append(obj_) 409 elif nodeName_ == 'uri': 410 obj_ = uriObject.factory() 411 obj_.build(child_) 412 self.uri.append(obj_) 413 elif nodeName_ == 'domain': 414 obj_ = domainObject.factory() 415 obj_.build(child_) 416 self.domain.append(obj_) 417 elif nodeName_ == 'registry': 418 obj_ = registryObject.factory() 419 obj_.build(child_) 420 self.registry.append(obj_) 421 elif nodeName_ == 'ip': 422 obj_ = IPObject.factory() 423 obj_.build(child_) 424 self.ip.append(obj_) 425 elif nodeName_ == 'asn': 426 obj_ = ASNObject.factory() 427 obj_.build(child_) 428 self.asn.append(obj_) 429 elif nodeName_ == 'entity': 430 obj_ = entityObject.factory() 431 obj_.build(child_) 432 self.entity.append(obj_) 433 elif nodeName_ == 'classification': 434 obj_ = classificationObject.factory() 435 obj_.build(child_) 436 self.classification.append(obj_) 437 elif nodeName_ == 'softwarePackage': 438 obj_ = softwarePackageObject.factory() 439 obj_.build(child_) 440 self.softwarePackage.append(obj_) 441 elif nodeName_ == 'digitalSignature': 442 obj_ = digitalSignatureObject.factory() 443 obj_.build(child_) 444 self.digitalSignature.append(obj_) 445 elif nodeName_ == 'taggant': 446 obj_ = taggantObject.factory() 447 obj_.build(child_) 448 self.taggant.append(obj_) 449# end class objects 450 451 452class objectProperties(GeneratedsSuper): 453 """Properties of objects that do not make sense as relationships. e.g. 454 file names, url parameter strings, registry value data.""" 455 subclass = None 456 superclass = None 457 def __init__(self, objectProperty=None): 458 if objectProperty is None: 459 self.objectProperty = [] 460 else: 461 self.objectProperty = objectProperty 462 def factory(*args_, **kwargs_): 463 if objectProperties.subclass: 464 return objectProperties.subclass(*args_, **kwargs_) 465 else: 466 return objectProperties(*args_, **kwargs_) 467 factory = staticmethod(factory) 468 def get_objectProperty(self): return self.objectProperty 469 def set_objectProperty(self, objectProperty): self.objectProperty = objectProperty 470 def add_objectProperty(self, value): self.objectProperty.append(value) 471 def insert_objectProperty(self, index, value): self.objectProperty[index] = value 472 def export(self, write, level, namespace_='', name_='objectProperties', namespacedef_=''): 473 showIndent(write, level) 474 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 475 already_processed = [] 476 self.exportAttributes(write, level, already_processed, namespace_, name_='objectProperties') 477 if self.hasContent_(): 478 write('>\n') 479 self.exportChildren(write, level + 1, namespace_, name_) 480 showIndent(write, level) 481 write('</%s%s>\n' % (namespace_, name_)) 482 else: 483 write('/>\n') 484 def exportAttributes(self, write, level, already_processed, namespace_='', name_='objectProperties'): 485 pass 486 def exportChildren(self, write, level, namespace_='', name_='objectProperties', fromsubclass_=False): 487 for objectProperty_ in self.objectProperty: 488 objectProperty_.export(write, level, namespace_, name_='objectProperty') 489 def hasContent_(self): 490 if ( 491 self.objectProperty 492 ): 493 return True 494 else: 495 return False 496 def build(self, node): 497 self.__sourcenode__ = node 498 self.buildAttributes(node, node.attrib, []) 499 for child in node: 500 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 501 self.buildChildren(child, node, nodeName_) 502 def buildAttributes(self, node, attrs, already_processed): 503 pass 504 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 505 if nodeName_ == 'objectProperty': 506 obj_ = objectProperty.factory() 507 obj_.build(child_) 508 self.objectProperty.append(obj_) 509# end class objectProperties 510 511 512class relationships(GeneratedsSuper): 513 """Relationships between objects.""" 514 subclass = None 515 superclass = None 516 def __init__(self, relationship=None): 517 if relationship is None: 518 self.relationship = [] 519 else: 520 self.relationship = relationship 521 def factory(*args_, **kwargs_): 522 if relationships.subclass: 523 return relationships.subclass(*args_, **kwargs_) 524 else: 525 return relationships(*args_, **kwargs_) 526 factory = staticmethod(factory) 527 def get_relationship(self): return self.relationship 528 def set_relationship(self, relationship): self.relationship = relationship 529 def add_relationship(self, value): self.relationship.append(value) 530 def insert_relationship(self, index, value): self.relationship[index] = value 531 def export(self, write, level, namespace_='', name_='relationships', namespacedef_=''): 532 showIndent(write, level) 533 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 534 already_processed = [] 535 self.exportAttributes(write, level, already_processed, namespace_, name_='relationships') 536 if self.hasContent_(): 537 write('>\n') 538 self.exportChildren(write, level + 1, namespace_, name_) 539 showIndent(write, level) 540 write('</%s%s>\n' % (namespace_, name_)) 541 else: 542 write('/>\n') 543 def exportAttributes(self, write, level, already_processed, namespace_='', name_='relationships'): 544 pass 545 def exportChildren(self, write, level, namespace_='', name_='relationships', fromsubclass_=False): 546 for relationship_ in self.relationship: 547 relationship_.export(write, level, namespace_, name_='relationship') 548 def hasContent_(self): 549 if ( 550 self.relationship 551 ): 552 return True 553 else: 554 return False 555 def build(self, node): 556 self.__sourcenode__ = node 557 self.buildAttributes(node, node.attrib, []) 558 for child in node: 559 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 560 self.buildChildren(child, node, nodeName_) 561 def buildAttributes(self, node, attrs, already_processed): 562 pass 563 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 564 if nodeName_ == 'relationship': 565 obj_ = relationship.factory() 566 obj_.build(child_) 567 self.relationship.append(obj_) 568# end class relationships 569 570 571class fieldData(GeneratedsSuper): 572 """Prevalence data.""" 573 subclass = None 574 superclass = None 575 def __init__(self, fieldDataEntry=None): 576 if fieldDataEntry is None: 577 self.fieldDataEntry = [] 578 else: 579 self.fieldDataEntry = fieldDataEntry 580 def factory(*args_, **kwargs_): 581 if fieldData.subclass: 582 return fieldData.subclass(*args_, **kwargs_) 583 else: 584 return fieldData(*args_, **kwargs_) 585 factory = staticmethod(factory) 586 def get_fieldDataEntry(self): return self.fieldDataEntry 587 def set_fieldDataEntry(self, fieldDataEntry): self.fieldDataEntry = fieldDataEntry 588 def add_fieldDataEntry(self, value): self.fieldDataEntry.append(value) 589 def insert_fieldDataEntry(self, index, value): self.fieldDataEntry[index] = value 590 def export(self, write, level, namespace_='', name_='fieldData', namespacedef_=''): 591 showIndent(write, level) 592 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 593 already_processed = [] 594 self.exportAttributes(write, level, already_processed, namespace_, name_='fieldData') 595 if self.hasContent_(): 596 write('>\n') 597 self.exportChildren(write, level + 1, namespace_, name_) 598 showIndent(write, level) 599 write('</%s%s>\n' % (namespace_, name_)) 600 else: 601 write('/>\n') 602 def exportAttributes(self, write, level, already_processed, namespace_='', name_='fieldData'): 603 pass 604 def exportChildren(self, write, level, namespace_='', name_='fieldData', fromsubclass_=False): 605 for fieldDataEntry_ in self.fieldDataEntry: 606 fieldDataEntry_.export(write, level, namespace_, name_='fieldDataEntry') 607 def hasContent_(self): 608 if ( 609 self.fieldDataEntry 610 ): 611 return True 612 else: 613 return False 614 def build(self, node): 615 self.__sourcenode__ = node 616 self.buildAttributes(node, node.attrib, []) 617 for child in node: 618 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 619 self.buildChildren(child, node, nodeName_) 620 def buildAttributes(self, node, attrs, already_processed): 621 pass 622 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 623 if nodeName_ == 'fieldDataEntry': 624 obj_ = fieldDataEntry.factory() 625 obj_.build(child_) 626 self.fieldDataEntry.append(obj_) 627# end class fieldData 628 629 630class fileObject(GeneratedsSuper): 631 """Object definition for files. The required attribute is the id, which 632 needs to be globally unique. By convention, the value used is a 633 hash, the stronger the better. The choice should be: use sha256 634 if you have it, if not use sha1, if not use md5. Other hashes 635 and file sizes are recorded in the elements. File names are put 636 in as properties.""" 637 subclass = None 638 superclass = None 639 def __init__(self, id=None, md5=None, sha1=None, sha256=None, sha512=None, size=None, crc32=None, fileType=None, extraHash=None, filename=None, normalizedNativePath=None, filenameWithinInstaller=None, folderWithinInstaller=None, vendor=None, internalName=None, language=None, productName=None, fileVersion=None, productVersion=None, developmentEnvironment=None, checksum=None, architecture=None, buildTimeDateStamp=None, compilerVersion=None, linkerVersion=None, minOSVersionCPE=None, numberOfSections=None, MIMEType=None, requiredPrivilege=None, digitalSignature=None, taggant=None): 640 self.id = _cast(None, id) 641 self.md5 = md5 642 self.sha1 = sha1 643 self.sha256 = sha256 644 self.sha512 = sha512 645 self.size = size 646 self.crc32 = crc32 647 if fileType is None: 648 self.fileType = [] 649 else: 650 self.fileType = fileType 651 if extraHash is None: 652 self.extraHash = [] 653 else: 654 self.extraHash = extraHash 655 if filename is None: 656 self.filename = [] 657 else: 658 self.filename = filename 659 if normalizedNativePath is None: 660 self.normalizedNativePath = [] 661 else: 662 self.normalizedNativePath = normalizedNativePath 663 if filenameWithinInstaller is None: 664 self.filenameWithinInstaller = [] 665 else: 666 self.filenameWithinInstaller = filenameWithinInstaller 667 if folderWithinInstaller is None: 668 self.folderWithinInstaller = [] 669 else: 670 self.folderWithinInstaller = folderWithinInstaller 671 self.vendor = vendor 672 if internalName is None: 673 self.internalName = [] 674 else: 675 self.internalName = internalName 676 if language is None: 677 self.language = [] 678 else: 679 self.language = language 680 self.productName = productName 681 self.fileVersion = fileVersion 682 self.productVersion = productVersion 683 self.developmentEnvironment = developmentEnvironment 684 self.checksum = checksum 685 self.architecture = architecture 686 self.buildTimeDateStamp = buildTimeDateStamp 687 self.compilerVersion = compilerVersion 688 self.linkerVersion = linkerVersion 689 self.minOSVersionCPE = minOSVersionCPE 690 self.numberOfSections = numberOfSections 691 self.MIMEType = MIMEType 692 self.requiredPrivilege = requiredPrivilege 693 self.digitalSignature = digitalSignature 694 self.taggant = taggant 695 def factory(*args_, **kwargs_): 696 if fileObject.subclass: 697 return fileObject.subclass(*args_, **kwargs_) 698 else: 699 return fileObject(*args_, **kwargs_) 700 factory = staticmethod(factory) 701 def get_md5(self): return self.md5 702 def set_md5(self, md5): self.md5 = md5 703 def get_sha1(self): return self.sha1 704 def set_sha1(self, sha1): self.sha1 = sha1 705 def get_sha256(self): return self.sha256 706 def set_sha256(self, sha256): self.sha256 = sha256 707 def get_sha512(self): return self.sha512 708 def set_sha512(self, sha512): self.sha512 = sha512 709 def get_size(self): return self.size 710 def set_size(self, size): self.size = size 711 def get_crc32(self): return self.crc32 712 def set_crc32(self, crc32): self.crc32 = crc32 713 def get_fileType(self): return self.fileType 714 def set_fileType(self, fileType): self.fileType = fileType 715 def add_fileType(self, value): self.fileType.append(value) 716 def insert_fileType(self, index, value): self.fileType[index] = value 717 def get_extraHash(self): return self.extraHash 718 def set_extraHash(self, extraHash): self.extraHash = extraHash 719 def add_extraHash(self, value): self.extraHash.append(value) 720 def insert_extraHash(self, index, value): self.extraHash[index] = value 721 def get_filename(self): return self.filename 722 def set_filename(self, filename): self.filename = filename 723 def add_filename(self, value): self.filename.append(value) 724 def insert_filename(self, index, value): self.filename[index] = value 725 def get_normalizedNativePath(self): return self.normalizedNativePath 726 def set_normalizedNativePath(self, normalizedNativePath): self.normalizedNativePath = normalizedNativePath 727 def add_normalizedNativePath(self, value): self.normalizedNativePath.append(value) 728 def insert_normalizedNativePath(self, index, value): self.normalizedNativePath[index] = value 729 def get_filenameWithinInstaller(self): return self.filenameWithinInstaller 730 def set_filenameWithinInstaller(self, filenameWithinInstaller): self.filenameWithinInstaller = filenameWithinInstaller 731 def add_filenameWithinInstaller(self, value): self.filenameWithinInstaller.append(value) 732 def insert_filenameWithinInstaller(self, index, value): self.filenameWithinInstaller[index] = value 733 def get_folderWithinInstaller(self): return self.folderWithinInstaller 734 def set_folderWithinInstaller(self, folderWithinInstaller): self.folderWithinInstaller = folderWithinInstaller 735 def add_folderWithinInstaller(self, value): self.folderWithinInstaller.append(value) 736 def insert_folderWithinInstaller(self, index, value): self.folderWithinInstaller[index] = value 737 def get_vendor(self): return self.vendor 738 def set_vendor(self, vendor): self.vendor = vendor 739 def get_internalName(self): return self.internalName 740 def set_internalName(self, internalName): self.internalName = internalName 741 def add_internalName(self, value): self.internalName.append(value) 742 def insert_internalName(self, index, value): self.internalName[index] = value 743 def get_language(self): return self.language 744 def set_language(self, language): self.language = language 745 def add_language(self, value): self.language.append(value) 746 def insert_language(self, index, value): self.language[index] = value 747 def get_productName(self): return self.productName 748 def set_productName(self, productName): self.productName = productName 749 def get_fileVersion(self): return self.fileVersion 750 def set_fileVersion(self, fileVersion): self.fileVersion = fileVersion 751 def get_productVersion(self): return self.productVersion 752 def set_productVersion(self, productVersion): self.productVersion = productVersion 753 def get_developmentEnvironment(self): return self.developmentEnvironment 754 def set_developmentEnvironment(self, developmentEnvironment): self.developmentEnvironment = developmentEnvironment 755 def get_checksum(self): return self.checksum 756 def set_checksum(self, checksum): self.checksum = checksum 757 def get_architecture(self): return self.architecture 758 def set_architecture(self, architecture): self.architecture = architecture 759 def get_buildTimeDateStamp(self): return self.buildTimeDateStamp 760 def set_buildTimeDateStamp(self, buildTimeDateStamp): self.buildTimeDateStamp = buildTimeDateStamp 761 def get_compilerVersion(self): return self.compilerVersion 762 def set_compilerVersion(self, compilerVersion): self.compilerVersion = compilerVersion 763 def get_linkerVersion(self): return self.linkerVersion 764 def set_linkerVersion(self, linkerVersion): self.linkerVersion = linkerVersion 765 def get_minOSVersionCPE(self): return self.minOSVersionCPE 766 def set_minOSVersionCPE(self, minOSVersionCPE): self.minOSVersionCPE = minOSVersionCPE 767 def get_numberOfSections(self): return self.numberOfSections 768 def set_numberOfSections(self, numberOfSections): self.numberOfSections = numberOfSections 769 def get_MIMEType(self): return self.MIMEType 770 def set_MIMEType(self, MIMEType): self.MIMEType = MIMEType 771 def get_requiredPrivilege(self): return self.requiredPrivilege 772 def set_requiredPrivilege(self, requiredPrivilege): self.requiredPrivilege = requiredPrivilege 773 def get_digitalSignature(self): return self.digitalSignature 774 def set_digitalSignature(self, digitalSignature): self.digitalSignature = digitalSignature 775 def get_taggant(self): return self.taggant 776 def set_taggant(self, taggant): self.taggant = taggant 777 def get_id(self): return self.id 778 def set_id(self, id): self.id = id 779 def export(self, write, level, namespace_='', name_='fileObject', namespacedef_=''): 780 showIndent(write, level) 781 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 782 already_processed = [] 783 self.exportAttributes(write, level, already_processed, namespace_, name_='fileObject') 784 if self.hasContent_(): 785 write('>\n') 786 self.exportChildren(write, level + 1, namespace_, name_) 787 showIndent(write, level) 788 write('</%s%s>\n' % (namespace_, name_)) 789 else: 790 write('/>\n') 791 def exportAttributes(self, write, level, already_processed, namespace_='', name_='fileObject'): 792 if self.id is not None and 'id' not in already_processed: 793 already_processed.append('id') 794 write(' id=%s' % (quote_attrib(self.id), )) 795 def exportChildren(self, write, level, namespace_='', name_='fileObject', fromsubclass_=False): 796 if self.md5 is not None: 797 self.md5.export(write, level, namespace_, name_='md5', ) 798 if self.sha1 is not None: 799 self.sha1.export(write, level, namespace_, name_='sha1') 800 if self.sha256 is not None: 801 self.sha256.export(write, level, namespace_, name_='sha256') 802 if self.sha512 is not None: 803 self.sha512.export(write, level, namespace_, name_='sha512') 804 if self.size is not None: 805 showIndent(write, level) 806 write('<%ssize>%s</%ssize>\n' % (namespace_, self.gds_format_integer(self.size, input_name='size'), namespace_)) 807 if self.crc32 is not None: 808 showIndent(write, level) 809 write('<%scrc32>%s</%scrc32>\n' % (namespace_, quote_xml(self.crc32), namespace_)) 810 for fileType_ in self.fileType: 811 showIndent(write, level) 812 write('<%sfileType>%s</%sfileType>\n' % (namespace_, quote_xml(fileType_), namespace_)) 813 for extraHash_ in self.extraHash: 814 extraHash_.export(write, level, namespace_, name_='extraHash') 815 for filename_ in self.filename: 816 showIndent(write, level) 817 write('<%sfilename>%s</%sfilename>\n' % (namespace_, quote_xml(filename_), namespace_)) 818 for normalizedNativePath_ in self.normalizedNativePath: 819 showIndent(write, level) 820 write('<%snormalizedNativePath>%s</%snormalizedNativePath>\n' % (namespace_, quote_xml(normalizedNativePath_), namespace_)) 821 for filenameWithinInstaller_ in self.filenameWithinInstaller: 822 showIndent(write, level) 823 write('<%sfilenameWithinInstaller>%s</%sfilenameWithinInstaller>\n' % (namespace_, quote_xml(filenameWithinInstaller_), namespace_)) 824 for folderWithinInstaller_ in self.folderWithinInstaller: 825 showIndent(write, level) 826 write('<%sfolderWithinInstaller>%s</%sfolderWithinInstaller>\n' % (namespace_, quote_xml(folderWithinInstaller_), namespace_)) 827 if self.vendor is not None: 828 showIndent(write, level) 829 write('<%svendor>%s</%svendor>\n' % (namespace_, quote_xml(self.vendor), namespace_)) 830 for internalName_ in self.internalName: 831 showIndent(write, level) 832 write('<%sinternalName>%s</%sinternalName>\n' % (namespace_, quote_xml(internalName_), namespace_)) 833 for language_ in self.language: 834 showIndent(write, level) 835 write('<%slanguage>%s</%slanguage>\n' % (namespace_, quote_xml(language_), namespace_)) 836 if self.productName is not None: 837 showIndent(write, level) 838 write('<%sproductName>%s</%sproductName>\n' % (namespace_, quote_xml(self.productName), namespace_)) 839 if self.fileVersion is not None: 840 showIndent(write, level) 841 write('<%sfileVersion>%s</%sfileVersion>\n' % (namespace_, quote_xml(self.fileVersion), namespace_)) 842 if self.productVersion is not None: 843 showIndent(write, level) 844 write('<%sproductVersion>%s</%sproductVersion>\n' % (namespace_, quote_xml(self.productVersion), namespace_)) 845 if self.developmentEnvironment is not None: 846 showIndent(write, level) 847 write('<%sdevelopmentEnvironment>%s</%sdevelopmentEnvironment>\n' % (namespace_, quote_xml(self.developmentEnvironment), namespace_)) 848 if self.checksum is not None: 849 self.checksum.export(write, level, namespace_, name_='checksum') 850 if self.architecture is not None: 851 showIndent(write, level) 852 write('<%sarchitecture>%s</%sarchitecture>\n' % (namespace_, quote_xml(self.architecture), namespace_)) 853 if self.buildTimeDateStamp is not None: 854 showIndent(write, level) 855 write('<%sbuildTimeDateStamp>%s</%sbuildTimeDateStamp>\n' % (namespace_, quote_xml(self.buildTimeDateStamp), namespace_)) 856 if self.compilerVersion is not None: 857 showIndent(write, level) 858 write('<%scompilerVersion>%s</%scompilerVersion>\n' % (namespace_, quote_xml(self.compilerVersion), namespace_)) 859 if self.linkerVersion is not None: 860 showIndent(write, level) 861 write('<%slinkerVersion>%s</%slinkerVersion>\n' % (namespace_, self.gds_format_float(self.linkerVersion, input_name='linkerVersion'), namespace_)) 862 if self.minOSVersionCPE is not None: 863 showIndent(write, level) 864 write('<%sminOSVersionCPE>%s</%sminOSVersionCPE>\n' % (namespace_, quote_xml(self.minOSVersionCPE), namespace_)) 865 if self.numberOfSections is not None: 866 showIndent(write, level) 867 write('<%snumberOfSections>%s</%snumberOfSections>\n' % (namespace_, self.gds_format_integer(self.numberOfSections, input_name='numberOfSections'), namespace_)) 868 if self.MIMEType is not None: 869 showIndent(write, level) 870 write('<%sMIMEType>%s</%sMIMEType>\n' % (namespace_, quote_xml(self.MIMEType), namespace_)) 871 if self.requiredPrivilege is not None: 872 showIndent(write, level) 873 write('<%srequiredPrivilege>%s</%srequiredPrivilege>\n' % (namespace_, quote_xml(self.requiredPrivilege), namespace_)) 874 if self.digitalSignature is not None: 875 self.digitalSignature.export(write, level, namespace_, name_='digitalSignature') 876 if self.taggant is not None: 877 self.taggant.export(write, level, namespace_, name_='taggant') 878 def hasContent_(self): 879 if ( 880 self.md5 is not None or 881 self.sha1 is not None or 882 self.sha256 is not None or 883 self.sha512 is not None or 884 self.size is not None or 885 self.crc32 is not None or 886 self.fileType or 887 self.extraHash or 888 self.filename or 889 self.normalizedNativePath or 890 self.filenameWithinInstaller or 891 self.folderWithinInstaller or 892 self.vendor is not None or 893 self.internalName or 894 self.language or 895 self.productName is not None or 896 self.fileVersion is not None or 897 self.productVersion is not None or 898 self.developmentEnvironment is not None or 899 self.checksum is not None or 900 self.architecture is not None or 901 self.buildTimeDateStamp is not None or 902 self.compilerVersion is not None or 903 self.linkerVersion is not None or 904 self.minOSVersionCPE is not None or 905 self.numberOfSections is not None or 906 self.MIMEType is not None or 907 self.requiredPrivilege is not None or 908 self.digitalSignature is not None or 909 self.taggant is not None 910 ): 911 return True 912 else: 913 return False 914 def build(self, node): 915 self.__sourcenode__ = node 916 self.buildAttributes(node, node.attrib, []) 917 for child in node: 918 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 919 self.buildChildren(child, node, nodeName_) 920 def buildAttributes(self, node, attrs, already_processed): 921 value = find_attr_value_('id', node) 922 if value is not None and 'id' not in already_processed: 923 already_processed.append('id') 924 self.id = value 925 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 926 if nodeName_ == 'md5': 927 obj_ = xs_hexBinary.factory() 928 obj_.build(child_) 929 self.set_md5(obj_) 930 elif nodeName_ == 'sha1': 931 obj_ = xs_hexBinary.factory() 932 obj_.build(child_) 933 self.set_sha1(obj_) 934 elif nodeName_ == 'sha256': 935 obj_ = xs_hexBinary.factory() 936 obj_.build(child_) 937 self.set_sha256(obj_) 938 elif nodeName_ == 'sha512': 939 obj_ = xs_hexBinary.factory() 940 obj_.build(child_) 941 self.set_sha512(obj_) 942 elif nodeName_ == 'size': 943 sval_ = child_.text 944 try: 945 ival_ = int(sval_) 946 except (TypeError, ValueError) as exp: 947 raise_parse_error(child_, 'requires integer: %s' % exp) 948 ival_ = self.gds_validate_integer(ival_, node, 'size') 949 self.size = ival_ 950 elif nodeName_ == 'crc32': 951 crc32_ = child_.text 952 crc32_ = self.gds_validate_string(crc32_, node, 'crc32') 953 self.crc32 = crc32_ 954 elif nodeName_ == 'fileType': 955 fileType_ = child_.text 956 fileType_ = self.gds_validate_string(fileType_, node, 'fileType') 957 self.fileType.append(fileType_) 958 elif nodeName_ == 'extraHash': 959 obj_ = extraHash.factory() 960 obj_.build(child_) 961 self.extraHash.append(obj_) 962 elif nodeName_ == 'filename': 963 filename_ = child_.text 964 filename_ = self.gds_validate_string(filename_, node, 'filename') 965 self.filename.append(filename_) 966 elif nodeName_ == 'normalizedNativePath': 967 normalizedNativePath_ = child_.text 968 normalizedNativePath_ = self.gds_validate_string(normalizedNativePath_, node, 'normalizedNativePath') 969 self.normalizedNativePath.append(normalizedNativePath_) 970 elif nodeName_ == 'filenameWithinInstaller': 971 filenameWithinInstaller_ = child_.text 972 filenameWithinInstaller_ = self.gds_validate_string(filenameWithinInstaller_, node, 'filenameWithinInstaller') 973 self.filenameWithinInstaller.append(filenameWithinInstaller_) 974 elif nodeName_ == 'folderWithinInstaller': 975 folderWithinInstaller_ = child_.text 976 folderWithinInstaller_ = self.gds_validate_string(folderWithinInstaller_, node, 'folderWithinInstaller') 977 self.folderWithinInstaller.append(folderWithinInstaller_) 978 elif nodeName_ == 'vendor': 979 vendor_ = child_.text 980 vendor_ = self.gds_validate_string(vendor_, node, 'vendor') 981 self.vendor = vendor_ 982 elif nodeName_ == 'internalName': 983 internalName_ = child_.text 984 internalName_ = self.gds_validate_string(internalName_, node, 'internalName') 985 self.internalName.append(internalName_) 986 elif nodeName_ == 'language': 987 language_ = child_.text 988 language_ = self.gds_validate_string(language_, node, 'language') 989 self.language.append(language_) 990 elif nodeName_ == 'productName': 991 productName_ = child_.text 992 productName_ = self.gds_validate_string(productName_, node, 'productName') 993 self.productName = productName_ 994 elif nodeName_ == 'fileVersion': 995 fileVersion_ = child_.text 996 fileVersion_ = self.gds_validate_string(fileVersion_, node, 'fileVersion') 997 self.fileVersion = fileVersion_ 998 elif nodeName_ == 'productVersion': 999 productVersion_ = child_.text 1000 productVersion_ = self.gds_validate_string(productVersion_, node, 'productVersion') 1001 self.productVersion = productVersion_ 1002 elif nodeName_ == 'developmentEnvironment': 1003 developmentEnvironment_ = child_.text 1004 developmentEnvironment_ = self.gds_validate_string(developmentEnvironment_, node, 'developmentEnvironment') 1005 self.developmentEnvironment = developmentEnvironment_ 1006 elif nodeName_ == 'checksum': 1007 obj_ = xs_hexBinary.factory() 1008 obj_.build(child_) 1009 self.set_checksum(obj_) 1010 elif nodeName_ == 'architecture': 1011 architecture_ = child_.text 1012 architecture_ = self.gds_validate_string(architecture_, node, 'architecture') 1013 self.architecture = architecture_ 1014 elif nodeName_ == 'buildTimeDateStamp': 1015 buildTimeDateStamp_ = child_.text 1016 buildTimeDateStamp_ = self.gds_validate_string(buildTimeDateStamp_, node, 'buildTimeDateStamp') 1017 self.buildTimeDateStamp = buildTimeDateStamp_ 1018 elif nodeName_ == 'compilerVersion': 1019 compilerVersion_ = child_.text 1020 compilerVersion_ = self.gds_validate_string(compilerVersion_, node, 'compilerVersion') 1021 self.compilerVersion = compilerVersion_ 1022 elif nodeName_ == 'linkerVersion': 1023 sval_ = child_.text 1024 try: 1025 fval_ = float(sval_) 1026 except (TypeError, ValueError) as exp: 1027 raise_parse_error(child_, 'requires float or double: %s' % exp) 1028 fval_ = self.gds_validate_float(fval_, node, 'linkerVersion') 1029 self.linkerVersion = fval_ 1030 elif nodeName_ == 'minOSVersionCPE': 1031 minOSVersionCPE_ = child_.text 1032 minOSVersionCPE_ = self.gds_validate_string(minOSVersionCPE_, node, 'minOSVersionCPE') 1033 self.minOSVersionCPE = minOSVersionCPE_ 1034 elif nodeName_ == 'numberOfSections': 1035 sval_ = child_.text 1036 try: 1037 ival_ = int(sval_) 1038 except (TypeError, ValueError) as exp: 1039 raise_parse_error(child_, 'requires integer: %s' % exp) 1040 ival_ = self.gds_validate_integer(ival_, node, 'numberOfSections') 1041 self.numberOfSections = ival_ 1042 elif nodeName_ == 'MIMEType': 1043 MIMEType_ = child_.text 1044 MIMEType_ = self.gds_validate_string(MIMEType_, node, 'MIMEType') 1045 self.MIMEType = MIMEType_ 1046 elif nodeName_ == 'requiredPrivilege': 1047 requiredPrivilege_ = child_.text 1048 requiredPrivilege_ = self.gds_validate_string(requiredPrivilege_, node, 'requiredPrivilege') 1049 self.requiredPrivilege = requiredPrivilege_ 1050 elif nodeName_ == 'digitalSignature': 1051 obj_ = digitalSignatureObject.factory() 1052 obj_.build(child_) 1053 self.set_digitalSignature(obj_) 1054 elif nodeName_ == 'taggant': 1055 obj_ = taggantObject.factory() 1056 obj_.build(child_) 1057 self.set_taggant(obj_) 1058# end class fileObject 1059 1060 1061class extraHash(GeneratedsSuper): 1062 """Element for inserting fuzzy hashes for example pehash, ssdeep. These 1063 are put in with this element, with a required attribute 'type' 1064 used to hold the type of hash.""" 1065 subclass = None 1066 superclass = None 1067 def __init__(self, type_=None, valueOf_=None): 1068 self.type_ = _cast(None, type_) 1069 self.valueOf_ = valueOf_ 1070 def factory(*args_, **kwargs_): 1071 if extraHash.subclass: 1072 return extraHash.subclass(*args_, **kwargs_) 1073 else: 1074 return extraHash(*args_, **kwargs_) 1075 factory = staticmethod(factory) 1076 def get_type(self): return self.type_ 1077 def set_type(self, type_): self.type_ = type_ 1078 def get_valueOf_(self): return self.valueOf_ 1079 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 1080 def export(self, write, level, namespace_='', name_='extraHash', namespacedef_=''): 1081 showIndent(write, level) 1082 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1083 already_processed = [] 1084 self.exportAttributes(write, level, already_processed, namespace_, name_='extraHash') 1085 if self.hasContent_(): 1086 write('>') 1087 write(quote_xml(self.valueOf_)) 1088 self.exportChildren(write, level + 1, namespace_, name_) 1089 write('</%s%s>\n' % (namespace_, name_)) 1090 else: 1091 write('/>\n') 1092 def exportAttributes(self, write, level, already_processed, namespace_='', name_='extraHash'): 1093 if self.type_ is not None and 'type_' not in already_processed: 1094 already_processed.append('type_') 1095 write(' type=%s' % (quote_attrib(self.type_))) 1096 def exportChildren(self, write, level, namespace_='', name_='extraHash', fromsubclass_=False): 1097 pass 1098 def hasContent_(self): 1099 if ( 1100 self.valueOf_ 1101 ): 1102 return True 1103 else: 1104 return False 1105 def build(self, node): 1106 self.__sourcenode__ = node 1107 self.buildAttributes(node, node.attrib, []) 1108 self.valueOf_ = get_all_text_(node) 1109 for child in node: 1110 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1111 self.buildChildren(child, node, nodeName_) 1112 def buildAttributes(self, node, attrs, already_processed): 1113 value = find_attr_value_('type', node) 1114 if value is not None and 'type' not in already_processed: 1115 already_processed.append('type') 1116 self.type_ = value 1117 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1118 pass 1119# end class extraHash 1120 1121 1122class registryObject(GeneratedsSuper): 1123 """Registry object. The required attribute is 'id', which is taken to 1124 be key\\valueName. Keys end in a \, value names start with a \, 1125 so you have e.g. key = 1126 hklm\software\microsoft\currentversion\windows\run\ value =\foo 1127 making the id 1128 hklm\software\microsoft\currentversion\windows\run\\foo""" 1129 subclass = None 1130 superclass = None 1131 def __init__(self, id=None, key=None, valueName=None): 1132 self.id = _cast(None, id) 1133 self.key = key 1134 self.valueName = valueName 1135 def factory(*args_, **kwargs_): 1136 if registryObject.subclass: 1137 return registryObject.subclass(*args_, **kwargs_) 1138 else: 1139 return registryObject(*args_, **kwargs_) 1140 factory = staticmethod(factory) 1141 def get_key(self): return self.key 1142 def set_key(self, key): self.key = key 1143 def get_valueName(self): return self.valueName 1144 def set_valueName(self, valueName): self.valueName = valueName 1145 def get_id(self): return self.id 1146 def set_id(self, id): self.id = id 1147 def export(self, write, level, namespace_='', name_='registryObject', namespacedef_=''): 1148 showIndent(write, level) 1149 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1150 already_processed = [] 1151 self.exportAttributes(write, level, already_processed, namespace_, name_='registryObject') 1152 if self.hasContent_(): 1153 write('>\n') 1154 self.exportChildren(write, level + 1, namespace_, name_) 1155 showIndent(write, level) 1156 write('</%s%s>\n' % (namespace_, name_)) 1157 else: 1158 write('/>\n') 1159 def exportAttributes(self, write, level, already_processed, namespace_='', name_='registryObject'): 1160 if self.id is not None and 'id' not in already_processed: 1161 already_processed.append('id') 1162 write(' id=%s' % (quote_attrib(self.id))) 1163 def exportChildren(self, write, level, namespace_='', name_='registryObject', fromsubclass_=False): 1164 if self.key is not None: 1165 showIndent(write, level) 1166 write('<%skey>%s</%skey>\n' % (namespace_, quote_xml(self.key), namespace_)) 1167 if self.valueName is not None: 1168 showIndent(write, level) 1169 write('<%svalueName>%s</%svalueName>\n' % (namespace_, quote_xml(self.valueName), namespace_)) 1170 def hasContent_(self): 1171 if ( 1172 self.key is not None or 1173 self.valueName is not None 1174 ): 1175 return True 1176 else: 1177 return False 1178 def build(self, node): 1179 self.__sourcenode__ = node 1180 self.buildAttributes(node, node.attrib, []) 1181 for child in node: 1182 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1183 self.buildChildren(child, node, nodeName_) 1184 def buildAttributes(self, node, attrs, already_processed): 1185 value = find_attr_value_('id', node) 1186 if value is not None and 'id' not in already_processed: 1187 already_processed.append('id') 1188 self.id = value 1189 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1190 if nodeName_ == 'key': 1191 key_ = child_.text 1192 key_ = self.gds_validate_string(key_, node, 'key') 1193 self.key = key_ 1194 elif nodeName_ == 'valueName': 1195 valueName_ = child_.text 1196 valueName_ = self.gds_validate_string(valueName_, node, 'valueName') 1197 self.valueName = valueName_ 1198# end class registryObject 1199 1200 1201class entityObject(GeneratedsSuper): 1202 """Entity Object. This is used to record groups, companies etc., and 1203 departments within organizations. The globally unique id 1204 (attribute) should be constructed from the company and 1205 department name, e.g. "Company name:Department name", 1206 "Mcafee:AVERT labs", or "Russian Business Network".""" 1207 subclass = None 1208 superclass = None 1209 def __init__(self, id=None, name=None): 1210 self.id = _cast(None, id) 1211 self.name = name 1212 def factory(*args_, **kwargs_): 1213 if entityObject.subclass: 1214 return entityObject.subclass(*args_, **kwargs_) 1215 else: 1216 return entityObject(*args_, **kwargs_) 1217 factory = staticmethod(factory) 1218 def get_name(self): return self.name 1219 def set_name(self, name): self.name = name 1220 def get_id(self): return self.id 1221 def set_id(self, id): self.id = id 1222 def export(self, write, level, namespace_='', name_='entityObject', namespacedef_=''): 1223 showIndent(write, level) 1224 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1225 already_processed = [] 1226 self.exportAttributes(write, level, already_processed, namespace_, name_='entityObject') 1227 if self.hasContent_(): 1228 write('>\n') 1229 self.exportChildren(write, level + 1, namespace_, name_) 1230 showIndent(write, level) 1231 write('</%s%s>\n' % (namespace_, name_)) 1232 else: 1233 write('/>\n') 1234 def exportAttributes(self, write, level, already_processed, namespace_='', name_='entityObject'): 1235 if self.id is not None and 'id' not in already_processed: 1236 already_processed.append('id') 1237 write(' id=%s' % (quote_attrib(self.id))) 1238 def exportChildren(self, write, level, namespace_='', name_='entityObject', fromsubclass_=False): 1239 if self.name is not None: 1240 showIndent(write, level) 1241 write('<%sname>%s</%sname>\n' % (namespace_, quote_xml(self.name), namespace_)) 1242 def hasContent_(self): 1243 if ( 1244 self.name is not None 1245 ): 1246 return True 1247 else: 1248 return False 1249 def build(self, node): 1250 self.__sourcenode__ = node 1251 self.buildAttributes(node, node.attrib, []) 1252 for child in node: 1253 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1254 self.buildChildren(child, node, nodeName_) 1255 def buildAttributes(self, node, attrs, already_processed): 1256 value = find_attr_value_('id', node) 1257 if value is not None and 'id' not in already_processed: 1258 already_processed.append('id') 1259 self.id = value 1260 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1261 if nodeName_ == 'name': 1262 name_ = child_.text 1263 name_ = self.gds_validate_string(name_, node, 'name') 1264 self.name = name_ 1265# end class entityObject 1266 1267 1268class uriObject(GeneratedsSuper): 1269 """Uri object. Only required element is uri string itself. There are 1270 elements for each of the broken out elements. The protocol 1271 should be take from the list at http://www.iana.org/assignments 1272 /port-numbers, or if not in that list have the value 'unknown'. 1273 The ipProtocol should be taken from the list 1274 http://www.iana.org/assignments/protocol-numbers/. The elements 1275 correspond to the usual breakdown of a uri into its component 1276 domain, hostname, path, port etc, as described at 1277 http://en.wikipedia.org/wiki/Uniform_Resource_Locator.""" 1278 subclass = None 1279 superclass = None 1280 def __init__(self, id=None, uriString=None, protocol=None, hostname=None, domain=None, port=None, path=None, ipProtocol=None): 1281 self.id = _cast(None, id) 1282 self.uriString = uriString 1283 self.protocol = protocol 1284 self.hostname = hostname 1285 self.domain = domain 1286 self.port = port 1287 self.path = path 1288 self.ipProtocol = ipProtocol 1289 def factory(*args_, **kwargs_): 1290 if uriObject.subclass: 1291 return uriObject.subclass(*args_, **kwargs_) 1292 else: 1293 return uriObject(*args_, **kwargs_) 1294 factory = staticmethod(factory) 1295 def get_uriString(self): return self.uriString 1296 def set_uriString(self, uriString): self.uriString = uriString 1297 def validate_NoQuestionMark(self, value): 1298 # Validate type NoQuestionMark, a restriction on xs:string. 1299 pass 1300 def get_protocol(self): return self.protocol 1301 def set_protocol(self, protocol): self.protocol = protocol 1302 def get_hostname(self): return self.hostname 1303 def set_hostname(self, hostname): self.hostname = hostname 1304 def get_domain(self): return self.domain 1305 def set_domain(self, domain): self.domain = domain 1306 def get_port(self): return self.port 1307 def set_port(self, port): self.port = port 1308 def get_path(self): return self.path 1309 def set_path(self, path): self.path = path 1310 def get_ipProtocol(self): return self.ipProtocol 1311 def set_ipProtocol(self, ipProtocol): self.ipProtocol = ipProtocol 1312 def get_id(self): return self.id 1313 def set_id(self, id): self.id = id 1314 def export(self, write, level, namespace_='', name_='uriObject', namespacedef_=''): 1315 showIndent(write, level) 1316 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1317 already_processed = [] 1318 self.exportAttributes(write, level, already_processed, namespace_, name_='uriObject') 1319 if self.hasContent_(): 1320 write('>\n') 1321 self.exportChildren(write, level + 1, namespace_, name_) 1322 showIndent(write, level) 1323 write('</%s%s>\n' % (namespace_, name_)) 1324 else: 1325 write('/>\n') 1326 def exportAttributes(self, write, level, already_processed, namespace_='', name_='uriObject'): 1327 if self.id is not None and 'id' not in already_processed: 1328 already_processed.append('id') 1329 write(' id=%s' % (quote_attrib(self.id), )) 1330 def exportChildren(self, write, level, namespace_='', name_='uriObject', fromsubclass_=False): 1331 if self.uriString is not None: 1332 showIndent(write, level) 1333 write('<%suriString>%s</%suriString>\n' % (namespace_, quote_xml(self.uriString), namespace_)) 1334 if self.protocol is not None: 1335 showIndent(write, level) 1336 write('<%sprotocol>%s</%sprotocol>\n' % (namespace_, quote_xml(self.protocol), namespace_)) 1337 if self.hostname is not None: 1338 showIndent(write, level) 1339 write('<%shostname>%s</%shostname>\n' % (namespace_, quote_xml(self.hostname), namespace_)) 1340 if self.domain is not None: 1341 showIndent(write, level) 1342 write('<%sdomain>%s</%sdomain>\n' % (namespace_, quote_xml(self.domain), namespace_)) 1343 if self.port is not None: 1344 showIndent(write, level) 1345 write('<%sport>%s</%sport>\n' % (namespace_, self.gds_format_integer(self.port, input_name='port'), namespace_)) 1346 if self.path is not None: 1347 showIndent(write, level) 1348 write('<%spath>%s</%spath>\n' % (namespace_, quote_xml(self.path), namespace_)) 1349 if self.ipProtocol is not None: 1350 showIndent(write, level) 1351 write('<%sipProtocol>%s</%sipProtocol>\n' % (namespace_, quote_xml(self.ipProtocol), namespace_)) 1352 def hasContent_(self): 1353 if ( 1354 self.uriString is not None or 1355 self.protocol is not None or 1356 self.hostname is not None or 1357 self.domain is not None or 1358 self.port is not None or 1359 self.path is not None or 1360 self.ipProtocol is not None 1361 ): 1362 return True 1363 else: 1364 return False 1365 def build(self, node): 1366 self.__sourcenode__ = node 1367 self.buildAttributes(node, node.attrib, []) 1368 for child in node: 1369 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1370 self.buildChildren(child, node, nodeName_) 1371 def buildAttributes(self, node, attrs, already_processed): 1372 value = find_attr_value_('id', node) 1373 if value is not None and 'id' not in already_processed: 1374 already_processed.append('id') 1375 self.id = value 1376 self.validate_NoQuestionMark(self.id) # validate type NoQuestionMark 1377 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1378 if nodeName_ == 'uriString': 1379 uriString_ = child_.text 1380 uriString_ = self.gds_validate_string(uriString_, node, 'uriString') 1381 self.uriString = uriString_ 1382 self.validate_NoQuestionMark(self.uriString) # validate type NoQuestionMark 1383 elif nodeName_ == 'protocol': 1384 protocol_ = child_.text 1385 protocol_ = self.gds_validate_string(protocol_, node, 'protocol') 1386 self.protocol = protocol_ 1387 elif nodeName_ == 'hostname': 1388 hostname_ = child_.text 1389 hostname_ = self.gds_validate_string(hostname_, node, 'hostname') 1390 self.hostname = hostname_ 1391 elif nodeName_ == 'domain': 1392 domain_ = child_.text 1393 domain_ = self.gds_validate_string(domain_, node, 'domain') 1394 self.domain = domain_ 1395 elif nodeName_ == 'port': 1396 sval_ = child_.text 1397 try: 1398 ival_ = int(sval_) 1399 except (TypeError, ValueError) as exp: 1400 raise_parse_error(child_, 'requires integer: %s' % exp) 1401 ival_ = self.gds_validate_integer(ival_, node, 'port') 1402 self.port = ival_ 1403 elif nodeName_ == 'path': 1404 path_ = child_.text 1405 path_ = self.gds_validate_string(path_, node, 'path') 1406 self.path = path_ 1407 elif nodeName_ == 'ipProtocol': 1408 ipProtocol_ = child_.text 1409 ipProtocol_ = self.gds_validate_string(ipProtocol_, node, 'ipProtocol') 1410 self.ipProtocol = ipProtocol_ 1411# end class uriObject 1412 1413 1414class IPObject(GeneratedsSuper): 1415 """IP object. Used to hold ipv4, ipv6 ip addresses and address ranges. 1416 The globally unique id is 'startAddress-endAddress'. There are 1417 two required elements, startAddress and endAddress, make these 1418 the same if you are specifying a single address. Thus for ip 1419 range id, would be e.g. 213.23.45.7-213.23.45.19 For a single 1420 ip, id would be e.g. 12.34.56.1-12.34.56.1""" 1421 subclass = None 1422 superclass = None 1423 def __init__(self, id=None, startAddress=None, endAddress=None): 1424 self.id = _cast(None, id) 1425 self.startAddress = startAddress 1426 self.endAddress = endAddress 1427 def factory(*args_, **kwargs_): 1428 if IPObject.subclass: 1429 return IPObject.subclass(*args_, **kwargs_) 1430 else: 1431 return IPObject(*args_, **kwargs_) 1432 factory = staticmethod(factory) 1433 def get_startAddress(self): return self.startAddress 1434 def set_startAddress(self, startAddress): self.startAddress = startAddress 1435 def get_endAddress(self): return self.endAddress 1436 def set_endAddress(self, endAddress): self.endAddress = endAddress 1437 def get_id(self): return self.id 1438 def set_id(self, id): self.id = id 1439 def validate_IPRange(self, value): 1440 # Validate type IPRange, a restriction on xs:string. 1441 pass 1442 def export(self, write, level, namespace_='', name_='IPObject', namespacedef_=''): 1443 showIndent(write, level) 1444 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1445 already_processed = [] 1446 self.exportAttributes(write, level, already_processed, namespace_, name_='IPObject') 1447 if self.hasContent_(): 1448 write('>\n') 1449 self.exportChildren(write, level + 1, namespace_, name_) 1450 showIndent(write, level) 1451 write('</%s%s>\n' % (namespace_, name_)) 1452 else: 1453 write('/>\n') 1454 def exportAttributes(self, write, level, already_processed, namespace_='', name_='IPObject'): 1455 if self.id is not None and 'id' not in already_processed: 1456 already_processed.append('id') 1457 write(' id=%s' % (quote_attrib(self.id), )) 1458 def exportChildren(self, write, level, namespace_='', name_='IPObject', fromsubclass_=False): 1459 if self.startAddress is not None: 1460 self.startAddress.export(write, level, namespace_, name_='startAddress', ) 1461 if self.endAddress is not None: 1462 self.endAddress.export(write, level, namespace_, name_='endAddress', ) 1463 def hasContent_(self): 1464 if ( 1465 self.startAddress is not None or 1466 self.endAddress is not None 1467 ): 1468 return True 1469 else: 1470 return False 1471 def build(self, node): 1472 self.__sourcenode__ = node 1473 self.buildAttributes(node, node.attrib, []) 1474 for child in node: 1475 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1476 self.buildChildren(child, node, nodeName_) 1477 def buildAttributes(self, node, attrs, already_processed): 1478 value = find_attr_value_('id', node) 1479 if value is not None and 'id' not in already_processed: 1480 already_processed.append('id') 1481 self.id = value 1482 self.validate_IPRange(self.id) # validate type IPRange 1483 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1484 if nodeName_ == 'startAddress': 1485 obj_ = IPAddress.factory() 1486 obj_.build(child_) 1487 self.set_startAddress(obj_) 1488 elif nodeName_ == 'endAddress': 1489 obj_ = IPAddress.factory() 1490 obj_.build(child_) 1491 self.set_endAddress(obj_) 1492# end class IPObject 1493 1494 1495class IPAddress(GeneratedsSuper): 1496 """ip address - string for the actual address and attribute either 1497 ipv4, ipv6.""" 1498 subclass = None 1499 superclass = None 1500 def __init__(self, type_=None, valueOf_=None): 1501 self.type_ = _cast(None, type_) 1502 self.valueOf_ = valueOf_ 1503 def factory(*args_, **kwargs_): 1504 if IPAddress.subclass: 1505 return IPAddress.subclass(*args_, **kwargs_) 1506 else: 1507 return IPAddress(*args_, **kwargs_) 1508 factory = staticmethod(factory) 1509 def get_type(self): return self.type_ 1510 def set_type(self, type_): self.type_ = type_ 1511 def validate_IPTypeEnum(self, value): 1512 # Validate type IPTypeEnum, a restriction on xs:string. 1513 pass 1514 def get_valueOf_(self): return self.valueOf_ 1515 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 1516 def export(self, write, level, namespace_='', name_='IPAddress', namespacedef_=''): 1517 showIndent(write, level) 1518 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1519 already_processed = [] 1520 self.exportAttributes(write, level, already_processed, namespace_, name_='IPAddress') 1521 if self.hasContent_(): 1522 write('>') 1523 write(quote_xml(self.valueOf_)) 1524 self.exportChildren(write, level + 1, namespace_, name_) 1525 write('</%s%s>\n' % (namespace_, name_)) 1526 else: 1527 write('/>\n') 1528 def exportAttributes(self, write, level, already_processed, namespace_='', name_='IPAddress'): 1529 if self.type_ is not None and 'type_' not in already_processed: 1530 already_processed.append('type_') 1531 write(' type=%s' % (quote_attrib(self.type_), )) 1532 def exportChildren(self, write, level, namespace_='', name_='IPAddress', fromsubclass_=False): 1533 pass 1534 def hasContent_(self): 1535 if ( 1536 self.valueOf_ 1537 ): 1538 return True 1539 else: 1540 return False 1541 def build(self, node): 1542 self.__sourcenode__ = node 1543 self.buildAttributes(node, node.attrib, []) 1544 self.valueOf_ = get_all_text_(node) 1545 for child in node: 1546 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1547 self.buildChildren(child, node, nodeName_) 1548 def buildAttributes(self, node, attrs, already_processed): 1549 value = find_attr_value_('type', node) 1550 if value is not None and 'type' not in already_processed: 1551 already_processed.append('type') 1552 self.type_ = value 1553 self.validate_IPTypeEnum(self.type_) # validate type IPTypeEnum 1554 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1555 pass 1556# end class IPAddress 1557 1558 1559class domainObject(GeneratedsSuper): 1560 """Domain object, used to hold internet domains, e.g.yahoo.com. The 1561 globally unique identifier (id attribute) is the domain itself. 1562 whois information on domain is recorded using object properties.""" 1563 subclass = None 1564 superclass = None 1565 def __init__(self, id=None, domain=None): 1566 self.id = _cast(None, id) 1567 self.domain = domain 1568 def factory(*args_, **kwargs_): 1569 if domainObject.subclass: 1570 return domainObject.subclass(*args_, **kwargs_) 1571 else: 1572 return domainObject(*args_, **kwargs_) 1573 factory = staticmethod(factory) 1574 def get_domain(self): return self.domain 1575 def set_domain(self, domain): self.domain = domain 1576 def get_id(self): return self.id 1577 def set_id(self, id): self.id = id 1578 def export(self, write, level, namespace_='', name_='domainObject', namespacedef_=''): 1579 showIndent(write, level) 1580 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1581 already_processed = [] 1582 self.exportAttributes(write, level, already_processed, namespace_, name_='domainObject') 1583 if self.hasContent_(): 1584 write('>\n') 1585 self.exportChildren(write, level + 1, namespace_, name_) 1586 showIndent(write, level) 1587 write('</%s%s>\n' % (namespace_, name_)) 1588 else: 1589 write('/>\n') 1590 def exportAttributes(self, write, level, already_processed, namespace_='', name_='domainObject'): 1591 if self.id is not None and 'id' not in already_processed: 1592 already_processed.append('id') 1593 write(' id=%s' % (quote_attrib(self.id))) 1594 def exportChildren(self, write, level, namespace_='', name_='domainObject', fromsubclass_=False): 1595 if self.domain is not None: 1596 showIndent(write, level) 1597 write('<%sdomain>%s</%sdomain>\n' % (namespace_, quote_xml(self.domain), namespace_)) 1598 def hasContent_(self): 1599 if ( 1600 self.domain is not None 1601 ): 1602 return True 1603 else: 1604 return False 1605 def build(self, node): 1606 self.__sourcenode__ = node 1607 self.buildAttributes(node, node.attrib, []) 1608 for child in node: 1609 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1610 self.buildChildren(child, node, nodeName_) 1611 def buildAttributes(self, node, attrs, already_processed): 1612 value = find_attr_value_('id', node) 1613 if value is not None and 'id' not in already_processed: 1614 already_processed.append('id') 1615 self.id = value 1616 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1617 if nodeName_ == 'domain': 1618 domain_ = child_.text 1619 domain_ = self.gds_validate_string(domain_, node, 'domain') 1620 self.domain = domain_ 1621# end class domainObject 1622 1623 1624class ASNObject(GeneratedsSuper): 1625 """Object used to hold information on Autonomous System Numbers. An 1626 autonomous system (AS) is a collection of connected Internet 1627 Protocol (IP) routing prefixes under the control of one or more 1628 network operators that presents a common, clearly defined 1629 routing policy to the Internet. The id is the number, written as 1630 an integer for both 16 and 32 bit numbers.""" 1631 subclass = None 1632 superclass = None 1633 def __init__(self, id=None, as_number=None): 1634 self.id = _cast(int, id) 1635 self.as_number = as_number 1636 def factory(*args_, **kwargs_): 1637 if ASNObject.subclass: 1638 return ASNObject.subclass(*args_, **kwargs_) 1639 else: 1640 return ASNObject(*args_, **kwargs_) 1641 factory = staticmethod(factory) 1642 def get_as_number(self): return self.as_number 1643 def set_as_number(self, as_number): self.as_number = as_number 1644 def get_id(self): return self.id 1645 def set_id(self, id): self.id = id 1646 def export(self, write, level, namespace_='', name_='ASNObject', namespacedef_=''): 1647 showIndent(write, level) 1648 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1649 already_processed = [] 1650 self.exportAttributes(write, level, already_processed, namespace_, name_='ASNObject') 1651 if self.hasContent_(): 1652 write('>\n') 1653 self.exportChildren(write, level + 1, namespace_, name_) 1654 showIndent(write, level) 1655 write('</%s%s>\n' % (namespace_, name_)) 1656 else: 1657 write('/>\n') 1658 def exportAttributes(self, write, level, already_processed, namespace_='', name_='ASNObject'): 1659 if self.id is not None and 'id' not in already_processed: 1660 already_processed.append('id') 1661 write(' id="%s"' % self.gds_format_integer(self.id, input_name='id')) 1662 def exportChildren(self, write, level, namespace_='', name_='ASNObject', fromsubclass_=False): 1663 if self.as_number is not None: 1664 showIndent(write, level) 1665 write('<%sas-number>%s</%sas-number>\n' % (namespace_, self.gds_format_integer(self.as_number, input_name='as-number'), namespace_)) 1666 def hasContent_(self): 1667 if ( 1668 self.as_number is not None 1669 ): 1670 return True 1671 else: 1672 return False 1673 def build(self, node): 1674 self.__sourcenode__ = node 1675 self.buildAttributes(node, node.attrib, []) 1676 for child in node: 1677 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1678 self.buildChildren(child, node, nodeName_) 1679 def buildAttributes(self, node, attrs, already_processed): 1680 value = find_attr_value_('id', node) 1681 if value is not None and 'id' not in already_processed: 1682 already_processed.append('id') 1683 try: 1684 self.id = int(value) 1685 except ValueError as exp: 1686 raise_parse_error(node, 'Bad integer attribute: %s' % exp) 1687 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1688 if nodeName_ == 'as-number': 1689 sval_ = child_.text 1690 try: 1691 ival_ = int(sval_) 1692 except (TypeError, ValueError) as exp: 1693 raise_parse_error(child_, 'requires integer: %s' % exp) 1694 ival_ = self.gds_validate_integer(ival_, node, 'as_number') 1695 self.as_number = ival_ 1696# end class ASNObject 1697 1698 1699class classificationObject(GeneratedsSuper): 1700 """Classification object, used to hold names or classifications of 1701 objects. The most common use case for this is detection names 1702 for files from av scanners. However, this object could be used 1703 for general classification. The globally unique id (attribute) 1704 should be created from "Company name:internal classification 1705 name", e.g. "Mcafee:Generic.DX". The other required attribute is 1706 the type of classification, e.g. clean, dirty, unknown. There 1707 are elements to capture the category of the classification. The 1708 category should be entered in the same way to the classification 1709 name, e.g. company name:category name, e..g Mcafee:Trojan.""" 1710 subclass = None 1711 superclass = None 1712 def __init__(self, type_=None, id=None, classificationName=None, companyName=None, category=None, classificationDetails=None): 1713 self.type_ = _cast(None, type_) 1714 self.id = _cast(None, id) 1715 self.classificationName = classificationName 1716 self.companyName = companyName 1717 self.category = category 1718 self.classificationDetails = classificationDetails 1719 def factory(*args_, **kwargs_): 1720 if classificationObject.subclass: 1721 return classificationObject.subclass(*args_, **kwargs_) 1722 else: 1723 return classificationObject(*args_, **kwargs_) 1724 factory = staticmethod(factory) 1725 def get_classificationName(self): return self.classificationName 1726 def set_classificationName(self, classificationName): self.classificationName = classificationName 1727 def get_companyName(self): return self.companyName 1728 def set_companyName(self, companyName): self.companyName = companyName 1729 def get_category(self): return self.category 1730 def set_category(self, category): self.category = category 1731 def get_classificationDetails(self): return self.classificationDetails 1732 def set_classificationDetails(self, classificationDetails): self.classificationDetails = classificationDetails 1733 def get_type(self): return self.type_ 1734 def set_type(self, type_): self.type_ = type_ 1735 def validate_ClassificationTypeEnum(self, value): 1736 # Validate type ClassificationTypeEnum, a restriction on xs:string. 1737 pass 1738 def get_id(self): return self.id 1739 def set_id(self, id): self.id = id 1740 def export(self, write, level, namespace_='', name_='classificationObject', namespacedef_=''): 1741 showIndent(write, level) 1742 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1743 already_processed = [] 1744 self.exportAttributes(write, level, already_processed, namespace_, name_='classificationObject') 1745 if self.hasContent_(): 1746 write('>\n') 1747 self.exportChildren(write, level + 1, namespace_, name_) 1748 showIndent(write, level) 1749 write('</%s%s>\n' % (namespace_, name_)) 1750 else: 1751 write('/>\n') 1752 def exportAttributes(self, write, level, already_processed, namespace_='', name_='classificationObject'): 1753 if self.type_ is not None and 'type_' not in already_processed: 1754 already_processed.append('type_') 1755 write(' type=%s' % (quote_attrib(self.type_), )) 1756 if self.id is not None and 'id' not in already_processed: 1757 already_processed.append('id') 1758 write(' id=%s' % (quote_attrib(self.id))) 1759 def exportChildren(self, write, level, namespace_='', name_='classificationObject', fromsubclass_=False): 1760 if self.classificationName is not None: 1761 showIndent(write, level) 1762 write('<%sclassificationName>%s</%sclassificationName>\n' % ('mmdef:', quote_xml(self.classificationName), 'mmdef:')) 1763 if self.companyName is not None: 1764 showIndent(write, level) 1765 write('<%scompanyName>%s</%scompanyName>\n' % ('mmdef:', quote_xml(self.companyName), 'mmdef:')) 1766 if self.category is not None: 1767 showIndent(write, level) 1768 write('<%scategory>%s</%scategory>\n' % ('mmdef:', quote_xml(self.category), 'mmdef:')) 1769 if self.classificationDetails is not None: 1770 self.classificationDetails.export(write, level, namespace_, name_='classificationDetails') 1771 def hasContent_(self): 1772 if ( 1773 self.classificationName is not None or 1774 self.companyName is not None or 1775 self.category is not None or 1776 self.classificationDetails is not None 1777 ): 1778 return True 1779 else: 1780 return False 1781 def build(self, node): 1782 self.__sourcenode__ = node 1783 self.buildAttributes(node, node.attrib, []) 1784 for child in node: 1785 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1786 self.buildChildren(child, node, nodeName_) 1787 def buildAttributes(self, node, attrs, already_processed): 1788 value = find_attr_value_('type', node) 1789 if value is not None and 'type' not in already_processed: 1790 already_processed.append('type') 1791 self.type_ = value 1792 self.validate_ClassificationTypeEnum(self.type_) # validate type ClassificationTypeEnum 1793 value = find_attr_value_('id', node) 1794 if value is not None and 'id' not in already_processed: 1795 already_processed.append('id') 1796 self.id = value 1797 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1798 if nodeName_ == 'classificationName': 1799 classificationName_ = child_.text 1800 classificationName_ = self.gds_validate_string(classificationName_, node, 'classificationName') 1801 self.classificationName = classificationName_ 1802 elif nodeName_ == 'companyName': 1803 companyName_ = child_.text 1804 companyName_ = self.gds_validate_string(companyName_, node, 'companyName') 1805 self.companyName = companyName_ 1806 elif nodeName_ == 'category': 1807 category_ = child_.text 1808 category_ = self.gds_validate_string(category_, node, 'category') 1809 self.category = category_ 1810 elif nodeName_ == 'classificationDetails': 1811 obj_ = classificationDetails.factory() 1812 obj_.build(child_) 1813 self.set_classificationDetails(obj_) 1814# end class classificationObject 1815 1816 1817class classificationDetails(GeneratedsSuper): 1818 """Details of the classification, giving product details, particularly 1819 useful for anti-virus scanner detections.""" 1820 subclass = None 1821 superclass = None 1822 def __init__(self, definitionVersion=None, detectionAddedTimeStamp=None, detectionShippedTimeStamp=None, product=None, productVersion=None): 1823 self.definitionVersion = definitionVersion 1824 self.detectionAddedTimeStamp = detectionAddedTimeStamp 1825 self.detectionShippedTimeStamp = detectionShippedTimeStamp 1826 self.product = product 1827 self.productVersion = productVersion 1828 def factory(*args_, **kwargs_): 1829 if classificationDetails.subclass: 1830 return classificationDetails.subclass(*args_, **kwargs_) 1831 else: 1832 return classificationDetails(*args_, **kwargs_) 1833 factory = staticmethod(factory) 1834 def get_definitionVersion(self): return self.definitionVersion 1835 def set_definitionVersion(self, definitionVersion): self.definitionVersion = definitionVersion 1836 def get_detectionAddedTimeStamp(self): return self.detectionAddedTimeStamp 1837 def set_detectionAddedTimeStamp(self, detectionAddedTimeStamp): self.detectionAddedTimeStamp = detectionAddedTimeStamp 1838 def get_detectionShippedTimeStamp(self): return self.detectionShippedTimeStamp 1839 def set_detectionShippedTimeStamp(self, detectionShippedTimeStamp): self.detectionShippedTimeStamp = detectionShippedTimeStamp 1840 def get_product(self): return self.product 1841 def set_product(self, product): self.product = product 1842 def get_productVersion(self): return self.productVersion 1843 def set_productVersion(self, productVersion): self.productVersion = productVersion 1844 def export(self, write, level, namespace_='', name_='classificationDetails', namespacedef_=''): 1845 showIndent(write, level) 1846 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 1847 already_processed = [] 1848 self.exportAttributes(write, level, already_processed, namespace_, name_='classificationDetails') 1849 if self.hasContent_(): 1850 write('>\n') 1851 self.exportChildren(write, level + 1, namespace_, name_) 1852 showIndent(write, level) 1853 write('</%s%s>\n' % (namespace_, name_)) 1854 else: 1855 write('/>\n') 1856 def exportAttributes(self, write, level, already_processed, namespace_='', name_='classificationDetails'): 1857 pass 1858 def exportChildren(self, write, level, namespace_='', name_='classificationDetails', fromsubclass_=False): 1859 if self.definitionVersion is not None: 1860 showIndent(write, level) 1861 write('<%sdefinitionVersion>%s</%sdefinitionVersion>\n' % (namespace_, quote_xml(self.definitionVersion), namespace_)) 1862 if self.detectionAddedTimeStamp is not None: 1863 showIndent(write, level) 1864 write('<%sdetectionAddedTimeStamp>%s</%sdetectionAddedTimeStamp>\n' % (namespace_, quote_xml(self.detectionAddedTimeStamp), namespace_)) 1865 if self.detectionShippedTimeStamp is not None: 1866 showIndent(write, level) 1867 write('<%sdetectionShippedTimeStamp>%s</%sdetectionShippedTimeStamp>\n' % (namespace_, quote_xml(self.detectionShippedTimeStamp), namespace_)) 1868 if self.product is not None: 1869 showIndent(write, level) 1870 write('<%sproduct>%s</%sproduct>\n' % (namespace_, quote_xml(self.product), namespace_)) 1871 if self.productVersion is not None: 1872 showIndent(write, level) 1873 write('<%sproductVersion>%s</%sproductVersion>\n' % (namespace_, quote_xml(self.productVersion), namespace_)) 1874 def hasContent_(self): 1875 if ( 1876 self.definitionVersion is not None or 1877 self.detectionAddedTimeStamp is not None or 1878 self.detectionShippedTimeStamp is not None or 1879 self.product is not None or 1880 self.productVersion is not None 1881 ): 1882 return True 1883 else: 1884 return False 1885 def build(self, node): 1886 self.__sourcenode__ = node 1887 self.buildAttributes(node, node.attrib, []) 1888 for child in node: 1889 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 1890 self.buildChildren(child, node, nodeName_) 1891 def buildAttributes(self, node, attrs, already_processed): 1892 pass 1893 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 1894 if nodeName_ == 'definitionVersion': 1895 definitionVersion_ = child_.text 1896 definitionVersion_ = self.gds_validate_string(definitionVersion_, node, 'definitionVersion') 1897 self.definitionVersion = definitionVersion_ 1898 elif nodeName_ == 'detectionAddedTimeStamp': 1899 detectionAddedTimeStamp_ = child_.text 1900 detectionAddedTimeStamp_ = self.gds_validate_string(detectionAddedTimeStamp_, node, 'detectionAddedTimeStamp') 1901 self.detectionAddedTimeStamp = detectionAddedTimeStamp_ 1902 elif nodeName_ == 'detectionShippedTimeStamp': 1903 detectionShippedTimeStamp_ = child_.text 1904 detectionShippedTimeStamp_ = self.gds_validate_string(detectionShippedTimeStamp_, node, 'detectionShippedTimeStamp') 1905 self.detectionShippedTimeStamp = detectionShippedTimeStamp_ 1906 elif nodeName_ == 'product': 1907 product_ = child_.text 1908 product_ = self.gds_validate_string(product_, node, 'product') 1909 self.product = product_ 1910 elif nodeName_ == 'productVersion': 1911 productVersion_ = child_.text 1912 productVersion_ = self.gds_validate_string(productVersion_, node, 'productVersion') 1913 self.productVersion = productVersion_ 1914# end class classificationDetails 1915 1916 1917class fieldDataEntry(GeneratedsSuper): 1918 """Data structure to hold prevalence information. The data includes a 1919 reference to another object (which is an xpath expression 1920 pointing to an object inside the 'ref' element), together with a 1921 time period (startDate -> endDate), an origin - where the object 1922 came from, and various location tags. This allows rich 1923 information on prevalence to be recorded. By convention, time 1924 periods should be wherever possible standard time periods, e.g. 1925 minute, hour, 24 hours, week, month, quarter, year. This will 1926 facilitate combination of data from multiple sources. To 1927 represent a single entry, make startDate == endDate. Commonality 1928 is calculated from the sightings of malware objects (and so such 1929 calculation is easier to automate). Importance is reserved for 1930 cases when “commonality” is not available or if there is a 1931 need to communicate the importance when commonality is low. We 1932 define the commonality on a scale 0 to 100 (0 means “never 1933 found in the field” and 100 means “found very 1934 frequently”). Scaling commonality to 0..100 range instead of 1935 using actual sample counts is to avoid the effect of the user 1936 base size on the commonality. We derive commonality from the 1937 number of affected computers – not from the number of samples 1938 (for example, a hundred parasitic infections of the same virus 1939 on a single computer are to be counted as one). To calculate the 1940 commonality we use two-stage approach and logarithmic scale: - 1941 If the number of affected users exceeds 0.1% of your user base 1942 (more frequent than 1 in a 1000) set commonality to “100” - 1943 Otherwise, calculate the ratio of infected computers amongst 1944 your user base by dividing the real number of affected computers 1945 ‘n’ by the total number ‘N’ - Apply the following 1946 formula to get the commonality –( log2(1+n*1000/N) ) * 100 - 1947 Round to the closest integer Obviously, the calculation above 1948 can only be applied to counting of malware sightings on 1949 desktops. If telemetry is collected from a fraction of such 1950 desktops then an appropriate correction should be used. For all 1951 other cases (e.g. sighting on gateways, in some network security 1952 appliance, on an ISP level, etc.) please exercise your best 1953 judgment and apply provided desktop guideline as an example to 1954 make sure the commonality factor is as comparable as possible. 1955 For a URL object the commonality could reflect, for example, how 1956 widely it was spammed. “Importance” should not be used 1957 together with “commonality” (unless commonality=“0”) to 1958 avoid possible confusion. High “importance”, for example, 1959 can be assigned to samples that are over-hyped by media when 1960 their commonality is still “0”. Use the following guidelines 1961 for “importance” which is also defined on a scale 0..100: 1962 100 – you’d expect your CEO and/or media to call you any 1963 second about this object 80 – you might get a call from your 1964 CEO and/or media 60 – you’d expect your boss to call you any 1965 second 40 – you might get a call from your boss 20 – someone 1966 is very likely to contact you about this object 10 – you might 1967 get contacted about this object 0 – you’d be surprised if 1968 anyone would ever contact you about this object""" 1969 subclass = None 1970 superclass = None 1971 def __init__(self, references=None, startDate=None, endDate=None, firstSeenDate=None, origin=None, commonality=None, volume=None, importance=None, location=None): 1972 self.references = references 1973 self.startDate = startDate 1974 self.endDate = endDate 1975 self.firstSeenDate = firstSeenDate 1976 self.origin = origin 1977 self.commonality = commonality 1978 if volume is None: 1979 self.volume = [] 1980 else: 1981 self.volume = volume 1982 self.importance = importance 1983 self.location = location 1984 def factory(*args_, **kwargs_): 1985 if fieldDataEntry.subclass: 1986 return fieldDataEntry.subclass(*args_, **kwargs_) 1987 else: 1988 return fieldDataEntry(*args_, **kwargs_) 1989 factory = staticmethod(factory) 1990 def get_references(self): return self.references 1991 def set_references(self, references): self.references = references 1992 def get_startDate(self): return self.startDate 1993 def set_startDate(self, startDate): self.startDate = startDate 1994 def get_endDate(self): return self.endDate 1995 def set_endDate(self, endDate): self.endDate = endDate 1996 def get_firstSeenDate(self): return self.firstSeenDate 1997 def set_firstSeenDate(self, firstSeenDate): self.firstSeenDate = firstSeenDate 1998 def get_origin(self): return self.origin 1999 def set_origin(self, origin): self.origin = origin 2000 def validate_OriginTypeEnum(self, value): 2001 # Validate type OriginTypeEnum, a restriction on xs:string. 2002 pass 2003 def get_commonality(self): return self.commonality 2004 def set_commonality(self, commonality): self.commonality = commonality 2005 def validate_intBetween0and100(self, value): 2006 # Validate type intBetween0and100, a restriction on xs:integer. 2007 pass 2008 def get_volume(self): return self.volume 2009 def set_volume(self, volume): self.volume = volume 2010 def add_volume(self, value): self.volume.append(value) 2011 def insert_volume(self, index, value): self.volume[index] = value 2012 def get_importance(self): return self.importance 2013 def set_importance(self, importance): self.importance = importance 2014 def get_location(self): return self.location 2015 def set_location(self, location): self.location = location 2016 def export(self, write, level, namespace_='', name_='fieldDataEntry', namespacedef_=''): 2017 showIndent(write, level) 2018 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2019 already_processed = [] 2020 self.exportAttributes(write, level, already_processed, namespace_, name_='fieldDataEntry') 2021 if self.hasContent_(): 2022 write('>\n') 2023 self.exportChildren(write, level + 1, namespace_, name_) 2024 showIndent(write, level) 2025 write('</%s%s>\n' % (namespace_, name_)) 2026 else: 2027 write('/>\n') 2028 def exportAttributes(self, write, level, already_processed, namespace_='', name_='fieldDataEntry'): 2029 pass 2030 def exportChildren(self, write, level, namespace_='', name_='fieldDataEntry', fromsubclass_=False): 2031 if self.references is not None: 2032 self.references.export(write, level, namespace_, name_='references', ) 2033 if self.startDate is not None: 2034 showIndent(write, level) 2035 write('<%sstartDate>%s</%sstartDate>\n' % (namespace_, quote_xml(self.startDate), namespace_)) 2036 if self.endDate is not None: 2037 showIndent(write, level) 2038 write('<%sendDate>%s</%sendDate>\n' % (namespace_, quote_xml(self.endDate), namespace_)) 2039 if self.firstSeenDate is not None: 2040 showIndent(write, level) 2041 write('<%sfirstSeenDate>%s</%sfirstSeenDate>\n' % (namespace_, quote_xml(self.firstSeenDate), namespace_)) 2042 if self.origin is not None: 2043 showIndent(write, level) 2044 write('<%sorigin>%s</%sorigin>\n' % (namespace_, quote_xml(self.origin), namespace_)) 2045 if self.commonality is not None: 2046 showIndent(write, level) 2047 write('<%scommonality>%s</%scommonality>\n' % (namespace_, self.gds_format_integer(self.commonality, input_name='commonality'), namespace_)) 2048 for volume_ in self.volume: 2049 volume_.export(write, level, namespace_, name_='volume') 2050 if self.importance is not None: 2051 showIndent(write, level) 2052 write('<%simportance>%s</%simportance>\n' % (namespace_, self.gds_format_integer(self.importance, input_name='importance'), namespace_)) 2053 if self.location is not None: 2054 self.location.export(write, level, namespace_, name_='location') 2055 def hasContent_(self): 2056 if ( 2057 self.references is not None or 2058 self.startDate is not None or 2059 self.endDate is not None or 2060 self.firstSeenDate is not None or 2061 self.origin is not None or 2062 self.commonality is not None or 2063 self.volume or 2064 self.importance is not None or 2065 self.location is not None 2066 ): 2067 return True 2068 else: 2069 return False 2070 def build(self, node): 2071 self.__sourcenode__ = node 2072 self.buildAttributes(node, node.attrib, []) 2073 for child in node: 2074 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2075 self.buildChildren(child, node, nodeName_) 2076 def buildAttributes(self, node, attrs, already_processed): 2077 pass 2078 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2079 if nodeName_ == 'references': 2080 obj_ = references.factory() 2081 obj_.build(child_) 2082 self.set_references(obj_) 2083 elif nodeName_ == 'startDate': 2084 startDate_ = child_.text 2085 startDate_ = self.gds_validate_string(startDate_, node, 'startDate') 2086 self.startDate = startDate_ 2087 elif nodeName_ == 'endDate': 2088 endDate_ = child_.text 2089 endDate_ = self.gds_validate_string(endDate_, node, 'endDate') 2090 self.endDate = endDate_ 2091 elif nodeName_ == 'firstSeenDate': 2092 firstSeenDate_ = child_.text 2093 firstSeenDate_ = self.gds_validate_string(firstSeenDate_, node, 'firstSeenDate') 2094 self.firstSeenDate = firstSeenDate_ 2095 elif nodeName_ == 'origin': 2096 origin_ = child_.text 2097 origin_ = self.gds_validate_string(origin_, node, 'origin') 2098 self.origin = origin_ 2099 self.validate_OriginTypeEnum(self.origin) # validate type OriginTypeEnum 2100 elif nodeName_ == 'commonality': 2101 sval_ = child_.text 2102 try: 2103 ival_ = int(sval_) 2104 except (TypeError, ValueError) as exp: 2105 raise_parse_error(child_, 'requires integer: %s' % exp) 2106 ival_ = self.gds_validate_integer(ival_, node, 'commonality') 2107 self.commonality = ival_ 2108 self.validate_intBetween0and100(self.commonality) # validate type intBetween0and100 2109 elif nodeName_ == 'volume': 2110 obj_ = volume.factory() 2111 obj_.build(child_) 2112 self.volume.append(obj_) 2113 elif nodeName_ == 'importance': 2114 sval_ = child_.text 2115 try: 2116 ival_ = int(sval_) 2117 except (TypeError, ValueError) as exp: 2118 raise_parse_error(child_, 'requires integer: %s' % exp) 2119 ival_ = self.gds_validate_integer(ival_, node, 'importance') 2120 self.importance = ival_ 2121 self.validate_intBetween0and100(self.importance) # validate type intBetween0and100 2122 elif nodeName_ == 'location': 2123 obj_ = location.factory() 2124 obj_.build(child_) 2125 self.set_location(obj_) 2126# end class fieldDataEntry 2127 2128 2129class references(GeneratedsSuper): 2130 """The objects the prevalence information pertains to.""" 2131 subclass = None 2132 superclass = None 2133 def __init__(self, ref=None): 2134 if ref is None: 2135 self.ref = [] 2136 else: 2137 self.ref = ref 2138 def factory(*args_, **kwargs_): 2139 if references.subclass: 2140 return references.subclass(*args_, **kwargs_) 2141 else: 2142 return references(*args_, **kwargs_) 2143 factory = staticmethod(factory) 2144 def get_ref(self): return self.ref 2145 def set_ref(self, ref): self.ref = ref 2146 def add_ref(self, value): self.ref.append(value) 2147 def insert_ref(self, index, value): self.ref[index] = value 2148 def export(self, write, level, namespace_='', name_='references', namespacedef_=''): 2149 showIndent(write, level) 2150 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2151 already_processed = [] 2152 self.exportAttributes(write, level, already_processed, namespace_, name_='references') 2153 if self.hasContent_(): 2154 write('>\n') 2155 self.exportChildren(write, level + 1, namespace_, name_) 2156 showIndent(write, level) 2157 write('</%s%s>\n' % (namespace_, name_)) 2158 else: 2159 write('/>\n') 2160 def exportAttributes(self, write, level, already_processed, namespace_='', name_='references'): 2161 pass 2162 def exportChildren(self, write, level, namespace_='', name_='references', fromsubclass_=False): 2163 for ref_ in self.ref: 2164 ref_.export(write, level, namespace_, name_='ref') 2165 def hasContent_(self): 2166 if ( 2167 self.ref 2168 ): 2169 return True 2170 else: 2171 return False 2172 def build(self, node): 2173 self.__sourcenode__ = node 2174 self.buildAttributes(node, node.attrib, []) 2175 for child in node: 2176 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2177 self.buildChildren(child, node, nodeName_) 2178 def buildAttributes(self, node, attrs, already_processed): 2179 pass 2180 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2181 if nodeName_ == 'ref': 2182 obj_ = reference.factory() 2183 obj_.build(child_) 2184 self.ref.append(obj_) 2185# end class references 2186 2187 2188class volume(GeneratedsSuper): 2189 """Quantitive measurements of prevalence.""" 2190 subclass = None 2191 superclass = None 2192 def __init__(self, units=None, valueOf_=None): 2193 self.units = _cast(None, units) 2194 self.valueOf_ = valueOf_ 2195 def factory(*args_, **kwargs_): 2196 if volume.subclass: 2197 return volume.subclass(*args_, **kwargs_) 2198 else: 2199 return volume(*args_, **kwargs_) 2200 factory = staticmethod(factory) 2201 def get_units(self): return self.units 2202 def set_units(self, units): self.units = units 2203 def validate_VolumeUnitsEnum(self, value): 2204 # Validate type VolumeUnitsEnum, a restriction on xs:string. 2205 pass 2206 def get_valueOf_(self): return self.valueOf_ 2207 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2208 def export(self, write, level, namespace_='', name_='volume', namespacedef_=''): 2209 showIndent(write, level) 2210 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2211 already_processed = [] 2212 self.exportAttributes(write, level, already_processed, namespace_, name_='volume') 2213 if self.hasContent_(): 2214 write('>') 2215 write(quote_xml(self.valueOf_)) 2216 self.exportChildren(write, level + 1, namespace_, name_) 2217 write('</%s%s>\n' % (namespace_, name_)) 2218 else: 2219 write('/>\n') 2220 def exportAttributes(self, write, level, already_processed, namespace_='', name_='volume'): 2221 if self.units is not None and 'units' not in already_processed: 2222 already_processed.append('units') 2223 write(' units=%s' % (quote_attrib(self.units), )) 2224 def exportChildren(self, write, level, namespace_='', name_='volume', fromsubclass_=False): 2225 pass 2226 def hasContent_(self): 2227 if ( 2228 self.valueOf_ 2229 ): 2230 return True 2231 else: 2232 return False 2233 def build(self, node): 2234 self.__sourcenode__ = node 2235 self.buildAttributes(node, node.attrib, []) 2236 self.valueOf_ = get_all_text_(node) 2237 for child in node: 2238 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2239 self.buildChildren(child, node, nodeName_) 2240 def buildAttributes(self, node, attrs, already_processed): 2241 value = find_attr_value_('units', node) 2242 if value is not None and 'units' not in already_processed: 2243 already_processed.append('units') 2244 self.units = value 2245 self.validate_VolumeUnitsEnum(self.units) # validate type VolumeUnitsEnum 2246 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2247 pass 2248# end class volume 2249 2250 2251class location(GeneratedsSuper): 2252 """Geolocation information for prevalence.""" 2253 subclass = None 2254 superclass = None 2255 def __init__(self, type_=None, valueOf_=None): 2256 self.type_ = _cast(None, type_) 2257 self.valueOf_ = valueOf_ 2258 def factory(*args_, **kwargs_): 2259 if location.subclass: 2260 return location.subclass(*args_, **kwargs_) 2261 else: 2262 return location(*args_, **kwargs_) 2263 factory = staticmethod(factory) 2264 def get_type(self): return self.type_ 2265 def set_type(self, type_): self.type_ = type_ 2266 def validate_LocationTypeEnum(self, value): 2267 # Validate type LocationTypeEnum, a restriction on xs:string. 2268 pass 2269 def get_valueOf_(self): return self.valueOf_ 2270 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2271 def export(self, write, level, namespace_='', name_='location', namespacedef_=''): 2272 showIndent(write, level) 2273 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2274 already_processed = [] 2275 self.exportAttributes(write, level, already_processed, namespace_, name_='location') 2276 if self.hasContent_(): 2277 write('>') 2278 write(quote_xml(self.valueOf_)) 2279 self.exportChildren(write, level + 1, namespace_, name_) 2280 write('</%s%s>\n' % (namespace_, name_)) 2281 else: 2282 write('/>\n') 2283 def exportAttributes(self, write, level, already_processed, namespace_='', name_='location'): 2284 if self.type_ is not None and 'type_' not in already_processed: 2285 already_processed.append('type_') 2286 write(' type=%s' % (quote_attrib(self.type_), )) 2287 def exportChildren(self, write, level, namespace_='', name_='location', fromsubclass_=False): 2288 pass 2289 def hasContent_(self): 2290 if ( 2291 self.valueOf_ 2292 ): 2293 return True 2294 else: 2295 return False 2296 def build(self, node): 2297 self.__sourcenode__ = node 2298 self.buildAttributes(node, node.attrib, []) 2299 self.valueOf_ = get_all_text_(node) 2300 for child in node: 2301 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2302 self.buildChildren(child, node, nodeName_) 2303 def buildAttributes(self, node, attrs, already_processed): 2304 value = find_attr_value_('type', node) 2305 if value is not None and 'type' not in already_processed: 2306 already_processed.append('type') 2307 self.type_ = value 2308 self.validate_LocationTypeEnum(self.type_) # validate type LocationTypeEnum 2309 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2310 pass 2311# end class location 2312 2313 2314class reference(GeneratedsSuper): 2315 """Reference element used to hold xpath expressions to objects, for 2316 example file[@id="12345"].""" 2317 subclass = None 2318 superclass = None 2319 def __init__(self, valueOf_=None): 2320 self.valueOf_ = valueOf_ 2321 def factory(*args_, **kwargs_): 2322 if reference.subclass: 2323 return reference.subclass(*args_, **kwargs_) 2324 else: 2325 return reference(*args_, **kwargs_) 2326 factory = staticmethod(factory) 2327 def get_valueOf_(self): return self.valueOf_ 2328 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2329 def export(self, write, level, namespace_='', name_='reference', namespacedef_=''): 2330 showIndent(write, level) 2331 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2332 already_processed = [] 2333 self.exportAttributes(write, level, already_processed, namespace_, name_='reference') 2334 if self.hasContent_(): 2335 write('>') 2336 write(quote_xml(self.valueOf_)) 2337 self.exportChildren(write, level + 1, namespace_, name_) 2338 write('</%s%s>\n' % (namespace_, name_)) 2339 else: 2340 write('/>\n') 2341 def exportAttributes(self, write, level, already_processed, namespace_='', name_='reference'): 2342 pass 2343 def exportChildren(self, write, level, namespace_='', name_='reference', fromsubclass_=False): 2344 pass 2345 def hasContent_(self): 2346 if ( 2347 self.valueOf_ 2348 ): 2349 return True 2350 else: 2351 return False 2352 def build(self, node): 2353 self.__sourcenode__ = node 2354 self.buildAttributes(node, node.attrib, []) 2355 self.valueOf_ = get_all_text_(node) 2356 for child in node: 2357 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2358 self.buildChildren(child, node, nodeName_) 2359 def buildAttributes(self, node, attrs, already_processed): 2360 pass 2361 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2362 pass 2363# end class reference 2364 2365 2366class property(GeneratedsSuper): 2367 """A property.""" 2368 subclass = None 2369 superclass = None 2370 def __init__(self, type_=None, valueOf_=None): 2371 self.type_ = _cast(None, type_) 2372 self.valueOf_ = valueOf_ 2373 def factory(*args_, **kwargs_): 2374 if property.subclass: 2375 return property.subclass(*args_, **kwargs_) 2376 else: 2377 return property(*args_, **kwargs_) 2378 factory = staticmethod(factory) 2379 def get_type(self): return self.type_ 2380 def set_type(self, type_): self.type_ = type_ 2381 def validate_PropertyTypeEnum(self, value): 2382 # Validate type PropertyTypeEnum, a restriction on xs:string. 2383 pass 2384 def get_valueOf_(self): return self.valueOf_ 2385 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2386 def export(self, write, level, namespace_='', name_='property', namespacedef_=''): 2387 showIndent(write, level) 2388 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2389 already_processed = [] 2390 self.exportAttributes(write, level, already_processed, namespace_, name_='property') 2391 if self.hasContent_(): 2392 write('>') 2393 write(quote_xml(self.valueOf_)) 2394 self.exportChildren(write, level + 1, namespace_, name_) 2395 write('</%s%s>\n' % (namespace_, name_)) 2396 else: 2397 write('/>\n') 2398 def exportAttributes(self, write, level, already_processed, namespace_='', name_='property'): 2399 if self.type_ is not None and 'type_' not in already_processed: 2400 already_processed.append('type_') 2401 write(' type=%s' % (quote_attrib(self.type_), )) 2402 def exportChildren(self, write, level, namespace_='', name_='property', fromsubclass_=False): 2403 pass 2404 def hasContent_(self): 2405 if ( 2406 self.valueOf_ 2407 ): 2408 return True 2409 else: 2410 return False 2411 def build(self, node): 2412 self.__sourcenode__ = node 2413 self.buildAttributes(node, node.attrib, []) 2414 self.valueOf_ = get_all_text_(node) 2415 for child in node: 2416 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2417 self.buildChildren(child, node, nodeName_) 2418 def buildAttributes(self, node, attrs, already_processed): 2419 value = find_attr_value_('type', node) 2420 if value is not None and 'type' not in already_processed: 2421 already_processed.append('type') 2422 self.type_ = value 2423 self.validate_PropertyTypeEnum(self.type_) # validate type PropertyTypeEnum 2424 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2425 pass 2426# end class property 2427 2428 2429class objectProperty(GeneratedsSuper): 2430 """Property; a reference to the object, a timestamp and an unbounded 2431 set of properties. This is used to describe extra information 2432 about an object. For example, to show the url parameter strings 2433 associated with a particular URI object. Or to show file names 2434 associated with a particular file. Properties can also be 2435 applied to relationships, by referencing the relationship by id. 2436 This allows use such as e.g. recording the post data sent in an 2437 http request between a malware (file object) and a uri (uri 2438 object).""" 2439 subclass = None 2440 superclass = None 2441 def __init__(self, id=None, references=None, timestamp=None, property=None): 2442 self.id = _cast(None, id) 2443 self.references = references 2444 self.timestamp = timestamp 2445 if property is None: 2446 self.property = [] 2447 else: 2448 self.property = property 2449 def factory(*args_, **kwargs_): 2450 if objectProperty.subclass: 2451 return objectProperty.subclass(*args_, **kwargs_) 2452 else: 2453 return objectProperty(*args_, **kwargs_) 2454 factory = staticmethod(factory) 2455 def get_references(self): return self.references 2456 def set_references(self, references): self.references = references 2457 def get_timestamp(self): return self.timestamp 2458 def set_timestamp(self, timestamp): self.timestamp = timestamp 2459 def get_property(self): return self.property 2460 def set_property(self, property): self.property = property 2461 def add_property(self, value): self.property.append(value) 2462 def insert_property(self, index, value): self.property[index] = value 2463 def get_id(self): return self.id 2464 def set_id(self, id): self.id = id 2465 def export(self, write, level, namespace_='', name_='objectProperty', namespacedef_=''): 2466 showIndent(write, level) 2467 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2468 already_processed = [] 2469 self.exportAttributes(write, level, already_processed, namespace_, name_='objectProperty') 2470 if self.hasContent_(): 2471 write('>\n') 2472 self.exportChildren(write, level + 1, namespace_, name_) 2473 showIndent(write, level) 2474 write('</%s%s>\n' % (namespace_, name_)) 2475 else: 2476 write('/>\n') 2477 def exportAttributes(self, write, level, already_processed, namespace_='', name_='objectProperty'): 2478 if self.id is not None and 'id' not in already_processed: 2479 already_processed.append('id') 2480 write(' id=%s' % (quote_attrib(self.id), )) 2481 def exportChildren(self, write, level, namespace_='', name_='objectProperty', fromsubclass_=False): 2482 if self.references is not None: 2483 self.references.export(write, level, namespace_, name_='references', ) 2484 if self.timestamp is not None: 2485 showIndent(write, level) 2486 write('<%stimestamp>%s</%stimestamp>\n' % (namespace_, quote_xml(self.timestamp), namespace_)) 2487 for property_ in self.property: 2488 property_.export(write, level, namespace_, name_='property') 2489 def hasContent_(self): 2490 if ( 2491 self.references is not None or 2492 self.timestamp is not None or 2493 self.property 2494 ): 2495 return True 2496 else: 2497 return False 2498 def build(self, node): 2499 self.__sourcenode__ = node 2500 self.buildAttributes(node, node.attrib, []) 2501 for child in node: 2502 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2503 self.buildChildren(child, node, nodeName_) 2504 def buildAttributes(self, node, attrs, already_processed): 2505 value = find_attr_value_('id', node) 2506 if value is not None and 'id' not in already_processed: 2507 already_processed.append('id') 2508 self.id = value 2509 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2510 if nodeName_ == 'references': 2511 obj_ = references.factory() 2512 obj_.build(child_) 2513 self.set_references(obj_) 2514 elif nodeName_ == 'timestamp': 2515 timestamp_ = child_.text 2516 timestamp_ = self.gds_validate_string(timestamp_, node, 'timestamp') 2517 self.timestamp = timestamp_ 2518 elif nodeName_ == 'property': 2519 obj_ = property.factory() 2520 obj_.build(child_) 2521 self.property.append(obj_) 2522# end class objectProperty 2523 2524 2525class relationship(GeneratedsSuper): 2526 """Relationships are used to express relationships between objects, and 2527 dates. Relationships have a type (an attribute with a defined 2528 list of allowed relationships), source (a set of xpath 2529 references to the parent end of the relationship), target (xpath 2530 references to the other end of the relationship) and an optional 2531 date. The linking of objects with types is a powerful way of 2532 describing data. The dates can be used to provide context. For 2533 example, to assign a classification to an object, that can done 2534 with an "isClassifiedAs" relationship, with the date meaning 2535 that that was the data that that classification was assigned. To 2536 show urls and the last visited data, this can be expressed as a 2537 "verifiedBy" relationship between the urls and the entity doing 2538 the verification, with the date interpreted as the verification 2539 date.""" 2540 subclass = None 2541 superclass = None 2542 def __init__(self, type_=None, id=None, source=None, target=None, timestamp=None): 2543 self.type_ = _cast(None, type_) 2544 self.id = _cast(None, id) 2545 self.source = source 2546 self.target = target 2547 self.timestamp = timestamp 2548 def factory(*args_, **kwargs_): 2549 if relationship.subclass: 2550 return relationship.subclass(*args_, **kwargs_) 2551 else: 2552 return relationship(*args_, **kwargs_) 2553 factory = staticmethod(factory) 2554 def get_source(self): return self.source 2555 def set_source(self, source): self.source = source 2556 def get_target(self): return self.target 2557 def set_target(self, target): self.target = target 2558 def get_timestamp(self): return self.timestamp 2559 def set_timestamp(self, timestamp): self.timestamp = timestamp 2560 def get_type(self): return self.type_ 2561 def set_type(self, type_): self.type_ = type_ 2562 def validate_RelationshipTypeEnum(self, value): 2563 # Validate type RelationshipTypeEnum, a restriction on xs:string. 2564 pass 2565 def get_id(self): return self.id 2566 def set_id(self, id): self.id = id 2567 def export(self, write, level, namespace_='', name_='relationship', namespacedef_=''): 2568 showIndent(write, level) 2569 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2570 already_processed = [] 2571 self.exportAttributes(write, level, already_processed, namespace_, name_='relationship') 2572 if self.hasContent_(): 2573 write('>\n') 2574 self.exportChildren(write, level + 1, namespace_, name_) 2575 showIndent(write, level) 2576 write('</%s%s>\n' % (namespace_, name_)) 2577 else: 2578 write('/>\n') 2579 def exportAttributes(self, write, level, already_processed, namespace_='', name_='relationship'): 2580 if self.type_ is not None and 'type_' not in already_processed: 2581 already_processed.append('type_') 2582 write(' type=%s' % (quote_attrib(self.type_), )) 2583 if self.id is not None and 'id' not in already_processed: 2584 already_processed.append('id') 2585 write(' id=%s' % (quote_attrib(self.id), )) 2586 def exportChildren(self, write, level, namespace_='', name_='relationship', fromsubclass_=False): 2587 if self.source is not None: 2588 self.source.export(write, level, namespace_, name_='source', ) 2589 if self.target is not None: 2590 self.target.export(write, level, namespace_, name_='target', ) 2591 if self.timestamp is not None: 2592 showIndent(write, level) 2593 write('<%stimestamp>%s</%stimestamp>\n' % (namespace_, quote_xml(self.timestamp), namespace_)) 2594 def hasContent_(self): 2595 if ( 2596 self.source is not None or 2597 self.target is not None or 2598 self.timestamp is not None 2599 ): 2600 return True 2601 else: 2602 return False 2603 def build(self, node): 2604 self.__sourcenode__ = node 2605 self.buildAttributes(node, node.attrib, []) 2606 for child in node: 2607 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2608 self.buildChildren(child, node, nodeName_) 2609 def buildAttributes(self, node, attrs, already_processed): 2610 value = find_attr_value_('type', node) 2611 if value is not None and 'type' not in already_processed: 2612 already_processed.append('type') 2613 self.type_ = value 2614 self.validate_RelationshipTypeEnum(self.type_) # validate type RelationshipTypeEnum 2615 value = find_attr_value_('id', node) 2616 if value is not None and 'id' not in already_processed: 2617 already_processed.append('id') 2618 self.id = value 2619 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2620 if nodeName_ == 'source': 2621 obj_ = source.factory() 2622 obj_.build(child_) 2623 self.set_source(obj_) 2624 elif nodeName_ == 'target': 2625 obj_ = target.factory() 2626 obj_.build(child_) 2627 self.set_target(obj_) 2628 elif nodeName_ == 'timestamp': 2629 timestamp_ = child_.text 2630 timestamp_ = self.gds_validate_string(timestamp_, node, 'timestamp') 2631 self.timestamp = timestamp_ 2632# end class relationship 2633 2634 2635class source(GeneratedsSuper): 2636 """References to objects at the parent end of the relationship.""" 2637 subclass = None 2638 superclass = None 2639 def __init__(self, ref=None): 2640 if ref is None: 2641 self.ref = [] 2642 else: 2643 self.ref = ref 2644 def factory(*args_, **kwargs_): 2645 if source.subclass: 2646 return source.subclass(*args_, **kwargs_) 2647 else: 2648 return source(*args_, **kwargs_) 2649 factory = staticmethod(factory) 2650 def get_ref(self): return self.ref 2651 def set_ref(self, ref): self.ref = ref 2652 def add_ref(self, value): self.ref.append(value) 2653 def insert_ref(self, index, value): self.ref[index] = value 2654 def export(self, write, level, namespace_='', name_='source', namespacedef_=''): 2655 showIndent(write, level) 2656 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2657 already_processed = [] 2658 self.exportAttributes(write, level, already_processed, namespace_, name_='source') 2659 if self.hasContent_(): 2660 write('>\n') 2661 self.exportChildren(write, level + 1, namespace_, name_) 2662 showIndent(write, level) 2663 write('</%s%s>\n' % (namespace_, name_)) 2664 else: 2665 write('/>\n') 2666 def exportAttributes(self, write, level, already_processed, namespace_='', name_='source'): 2667 pass 2668 def exportChildren(self, write, level, namespace_='', name_='source', fromsubclass_=False): 2669 for ref_ in self.ref: 2670 ref_.export(write, level, namespace_, name_='ref') 2671 def hasContent_(self): 2672 if ( 2673 self.ref 2674 ): 2675 return True 2676 else: 2677 return False 2678 def build(self, node): 2679 self.__sourcenode__ = node 2680 self.buildAttributes(node, node.attrib, []) 2681 for child in node: 2682 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2683 self.buildChildren(child, node, nodeName_) 2684 def buildAttributes(self, node, attrs, already_processed): 2685 pass 2686 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2687 if nodeName_ == 'ref': 2688 obj_ = reference.factory() 2689 obj_.build(child_) 2690 self.ref.append(obj_) 2691# end class source 2692 2693 2694class target(GeneratedsSuper): 2695 """References to objects at the child end of the relationship.""" 2696 subclass = None 2697 superclass = None 2698 def __init__(self, ref=None): 2699 if ref is None: 2700 self.ref = [] 2701 else: 2702 self.ref = ref 2703 def factory(*args_, **kwargs_): 2704 if target.subclass: 2705 return target.subclass(*args_, **kwargs_) 2706 else: 2707 return target(*args_, **kwargs_) 2708 factory = staticmethod(factory) 2709 def get_ref(self): return self.ref 2710 def set_ref(self, ref): self.ref = ref 2711 def add_ref(self, value): self.ref.append(value) 2712 def insert_ref(self, index, value): self.ref[index] = value 2713 def export(self, write, level, namespace_='', name_='target', namespacedef_=''): 2714 showIndent(write, level) 2715 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2716 already_processed = [] 2717 self.exportAttributes(write, level, already_processed, namespace_, name_='target') 2718 if self.hasContent_(): 2719 write('>\n') 2720 self.exportChildren(write, level + 1, namespace_, name_) 2721 showIndent(write, level) 2722 write('</%s%s>\n' % (namespace_, name_)) 2723 else: 2724 write('/>\n') 2725 def exportAttributes(self, write, level, already_processed, namespace_='', name_='target'): 2726 pass 2727 def exportChildren(self, write, level, namespace_='', name_='target', fromsubclass_=False): 2728 for ref_ in self.ref: 2729 ref_.export(write, level, namespace_, name_='ref') 2730 def hasContent_(self): 2731 if ( 2732 self.ref 2733 ): 2734 return True 2735 else: 2736 return False 2737 def build(self, node): 2738 self.__sourcenode__ = node 2739 self.buildAttributes(node, node.attrib, []) 2740 for child in node: 2741 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2742 self.buildChildren(child, node, nodeName_) 2743 def buildAttributes(self, node, attrs, already_processed): 2744 pass 2745 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2746 if nodeName_ == 'ref': 2747 obj_ = reference.factory() 2748 obj_.build(child_) 2749 self.ref.append(obj_) 2750# end class target 2751 2752 2753class softwarePackageObject(GeneratedsSuper): 2754 """Software package object, used to store information about a software 2755 package, such as the vendor and version. Intended primarily for 2756 the clean-file metadata sharing use case.""" 2757 subclass = None 2758 superclass = None 2759 def __init__(self, id=None, vendor=None, productgroup=None, product=None, version=None, update=None, edition=None, language=None, CPEname=None): 2760 self.id = _cast(None, id) 2761 self.vendor = vendor 2762 self.productgroup = productgroup 2763 self.product = product 2764 self.version = version 2765 self.update = update 2766 self.edition = edition 2767 self.language = language 2768 self.CPEname = CPEname 2769 def factory(*args_, **kwargs_): 2770 if softwarePackageObject.subclass: 2771 return softwarePackageObject.subclass(*args_, **kwargs_) 2772 else: 2773 return softwarePackageObject(*args_, **kwargs_) 2774 factory = staticmethod(factory) 2775 def get_vendor(self): return self.vendor 2776 def set_vendor(self, vendor): self.vendor = vendor 2777 def get_productgroup(self): return self.productgroup 2778 def set_productgroup(self, productgroup): self.productgroup = productgroup 2779 def get_product(self): return self.product 2780 def set_product(self, product): self.product = product 2781 def get_version(self): return self.version 2782 def set_version(self, version): self.version = version 2783 def get_update(self): return self.update 2784 def set_update(self, update): self.update = update 2785 def get_edition(self): return self.edition 2786 def set_edition(self, edition): self.edition = edition 2787 def get_language(self): return self.language 2788 def set_language(self, language): self.language = language 2789 def get_CPEname(self): return self.CPEname 2790 def set_CPEname(self, CPEname): self.CPEname = CPEname 2791 def get_id(self): return self.id 2792 def set_id(self, id): self.id = id 2793 def export(self, write, level, namespace_='', name_='softwarePackageObject', namespacedef_=''): 2794 showIndent(write, level) 2795 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2796 already_processed = [] 2797 self.exportAttributes(write, level, already_processed, namespace_, name_='softwarePackageObject') 2798 if self.hasContent_(): 2799 write('>\n') 2800 self.exportChildren(write, level + 1, namespace_, name_) 2801 showIndent(write, level) 2802 write('</%s%s>\n' % (namespace_, name_)) 2803 else: 2804 write('/>\n') 2805 def exportAttributes(self, write, level, already_processed, namespace_='', name_='softwarePackageObject'): 2806 if self.id is not None and 'id' not in already_processed: 2807 already_processed.append('id') 2808 write(' id=%s' % (quote_attrib(self.id))) 2809 def exportChildren(self, write, level, namespace_='', name_='softwarePackageObject', fromsubclass_=False): 2810 if self.vendor is not None: 2811 showIndent(write, level) 2812 write('<%svendor>%s</%svendor>\n' % (namespace_, quote_xml(self.vendor), namespace_)) 2813 if self.productgroup is not None: 2814 showIndent(write, level) 2815 write('<%sproductgroup>%s</%sproductgroup>\n' % (namespace_, quote_xml(self.productgroup), namespace_)) 2816 if self.product is not None: 2817 showIndent(write, level) 2818 write('<%sproduct>%s</%sproduct>\n' % (namespace_, quote_xml(self.product), namespace_)) 2819 if self.version is not None: 2820 showIndent(write, level) 2821 write('<%sversion>%s</%sversion>\n' % (namespace_, quote_xml(self.version), namespace_)) 2822 if self.update is not None: 2823 showIndent(write, level) 2824 write('<%supdate>%s</%supdate>\n' % (namespace_, quote_xml(self.update), namespace_)) 2825 if self.edition is not None: 2826 showIndent(write, level) 2827 write('<%sedition>%s</%sedition>\n' % (namespace_, quote_xml(self.edition), namespace_)) 2828 if self.language is not None: 2829 showIndent(write, level) 2830 write('<%slanguage>%s</%slanguage>\n' % (namespace_, quote_xml(self.language), namespace_)) 2831 if self.CPEname is not None: 2832 self.CPEname.export(write, level, namespace_, name_='CPEname') 2833 def hasContent_(self): 2834 if ( 2835 self.vendor is not None or 2836 self.productgroup is not None or 2837 self.product is not None or 2838 self.version is not None or 2839 self.update is not None or 2840 self.edition is not None or 2841 self.language is not None or 2842 self.CPEname is not None 2843 ): 2844 return True 2845 else: 2846 return False 2847 def build(self, node): 2848 self.__sourcenode__ = node 2849 self.buildAttributes(node, node.attrib, []) 2850 for child in node: 2851 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2852 self.buildChildren(child, node, nodeName_) 2853 def buildAttributes(self, node, attrs, already_processed): 2854 value = find_attr_value_('id', node) 2855 if value is not None and 'id' not in already_processed: 2856 already_processed.append('id') 2857 self.id = value 2858 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2859 if nodeName_ == 'vendor': 2860 vendor_ = child_.text 2861 vendor_ = self.gds_validate_string(vendor_, node, 'vendor') 2862 self.vendor = vendor_ 2863 elif nodeName_ == 'productgroup': 2864 productgroup_ = child_.text 2865 productgroup_ = self.gds_validate_string(productgroup_, node, 'productgroup') 2866 self.productgroup = productgroup_ 2867 elif nodeName_ == 'product': 2868 product_ = child_.text 2869 product_ = self.gds_validate_string(product_, node, 'product') 2870 self.product = product_ 2871 elif nodeName_ == 'version': 2872 version_ = child_.text 2873 version_ = self.gds_validate_string(version_, node, 'version') 2874 self.version = version_ 2875 elif nodeName_ == 'update': 2876 update_ = child_.text 2877 update_ = self.gds_validate_string(update_, node, 'update') 2878 self.update = update_ 2879 elif nodeName_ == 'edition': 2880 edition_ = child_.text 2881 edition_ = self.gds_validate_string(edition_, node, 'edition') 2882 self.edition = edition_ 2883 elif nodeName_ == 'language': 2884 language_ = child_.text 2885 language_ = self.gds_validate_string(language_, node, 'language') 2886 self.language = language_ 2887 elif nodeName_ == 'CPEname': 2888 obj_ = CPEname.factory() 2889 obj_.build(child_) 2890 self.set_CPEname(obj_) 2891# end class softwarePackageObject 2892 2893 2894class CPEname(GeneratedsSuper): 2895 """The Common Platform Enumeration, or CPE, name of the package if one 2896 exists. CPE is a structured naming scheme for IT systems, 2897 software, and packages. For more information on CPE see 2898 http://cpe.mitre.org. For the official CPE dictionary see 2899 http://nvd.nist.gov/cpe.cfm.The version of CPE that is used for 2900 the name in the CPEname element. As of 10/04/2011 this is 2.2.""" 2901 subclass = None 2902 superclass = None 2903 def __init__(self, cpeVersion=None, valueOf_=None): 2904 self.cpeVersion = _cast(None, cpeVersion) 2905 self.valueOf_ = valueOf_ 2906 def factory(*args_, **kwargs_): 2907 if CPEname.subclass: 2908 return CPEname.subclass(*args_, **kwargs_) 2909 else: 2910 return CPEname(*args_, **kwargs_) 2911 factory = staticmethod(factory) 2912 def get_cpeVersion(self): return self.cpeVersion 2913 def set_cpeVersion(self, cpeVersion): self.cpeVersion = cpeVersion 2914 def get_valueOf_(self): return self.valueOf_ 2915 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 2916 def export(self, write, level, namespace_='', name_='CPEname', namespacedef_=''): 2917 showIndent(write, level) 2918 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2919 already_processed = [] 2920 self.exportAttributes(write, level, already_processed, namespace_, name_='CPEname') 2921 if self.hasContent_(): 2922 write('>') 2923 write(quote_xml(self.valueOf_)) 2924 self.exportChildren(write, level + 1, namespace_, name_) 2925 write('</%s%s>\n' % (namespace_, name_)) 2926 else: 2927 write('/>\n') 2928 def exportAttributes(self, write, level, already_processed, namespace_='', name_='CPEname'): 2929 if self.cpeVersion is not None and 'cpeVersion' not in already_processed: 2930 already_processed.append('cpeVersion') 2931 write(' cpeVersion=%s' % (quote_attrib(self.cpeVersion))) 2932 def exportChildren(self, write, level, namespace_='', name_='CPEname', fromsubclass_=False): 2933 pass 2934 def hasContent_(self): 2935 if ( 2936 self.valueOf_ 2937 ): 2938 return True 2939 else: 2940 return False 2941 def build(self, node): 2942 self.__sourcenode__ = node 2943 self.buildAttributes(node, node.attrib, []) 2944 self.valueOf_ = get_all_text_(node) 2945 for child in node: 2946 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 2947 self.buildChildren(child, node, nodeName_) 2948 def buildAttributes(self, node, attrs, already_processed): 2949 value = find_attr_value_('cpeVersion', node) 2950 if value is not None and 'cpeVersion' not in already_processed: 2951 already_processed.append('cpeVersion') 2952 self.cpeVersion = value 2953 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 2954 pass 2955# end class CPEname 2956 2957 2958class digitalSignatureObject(GeneratedsSuper): 2959 """Digital signature object, used to hold information about digitally 2960 signed binaries with regards to the certificate used and its 2961 validity.""" 2962 subclass = None 2963 superclass = None 2964 def __init__(self, type_=None, id=None, certificateIssuer=None, certificateSubject=None, certificateValidity=None, certificateRevocationTimestamp=None, signingTimestamp=None): 2965 self.type_ = _cast(None, type_) 2966 self.id = _cast(None, id) 2967 self.certificateIssuer = certificateIssuer 2968 self.certificateSubject = certificateSubject 2969 self.certificateValidity = certificateValidity 2970 self.certificateRevocationTimestamp = certificateRevocationTimestamp 2971 self.signingTimestamp = signingTimestamp 2972 def factory(*args_, **kwargs_): 2973 if digitalSignatureObject.subclass: 2974 return digitalSignatureObject.subclass(*args_, **kwargs_) 2975 else: 2976 return digitalSignatureObject(*args_, **kwargs_) 2977 factory = staticmethod(factory) 2978 def get_certificateIssuer(self): return self.certificateIssuer 2979 def set_certificateIssuer(self, certificateIssuer): self.certificateIssuer = certificateIssuer 2980 def get_certificateSubject(self): return self.certificateSubject 2981 def set_certificateSubject(self, certificateSubject): self.certificateSubject = certificateSubject 2982 def get_certificateValidity(self): return self.certificateValidity 2983 def set_certificateValidity(self, certificateValidity): self.certificateValidity = certificateValidity 2984 def get_certificateRevocationTimestamp(self): return self.certificateRevocationTimestamp 2985 def set_certificateRevocationTimestamp(self, certificateRevocationTimestamp): self.certificateRevocationTimestamp = certificateRevocationTimestamp 2986 def get_signingTimestamp(self): return self.signingTimestamp 2987 def set_signingTimestamp(self, signingTimestamp): self.signingTimestamp = signingTimestamp 2988 def get_type(self): return self.type_ 2989 def set_type(self, type_): self.type_ = type_ 2990 def get_id(self): return self.id 2991 def set_id(self, id): self.id = id 2992 def export(self, write, level, namespace_='', name_='digitalSignatureObject', namespacedef_=''): 2993 showIndent(write, level) 2994 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 2995 already_processed = [] 2996 self.exportAttributes(write, level, already_processed, namespace_, name_='digitalSignatureObject') 2997 if self.hasContent_(): 2998 write('>\n') 2999 self.exportChildren(write, level + 1, namespace_, name_) 3000 showIndent(write, level) 3001 write('</%s%s>\n' % (namespace_, name_)) 3002 else: 3003 write('/>\n') 3004 def exportAttributes(self, write, level, already_processed, namespace_='', name_='digitalSignatureObject'): 3005 if self.type_ is not None and 'type_' not in already_processed: 3006 already_processed.append('type_') 3007 write(' type=%s' % (quote_attrib(self.type_))) 3008 if self.id is not None and 'id' not in already_processed: 3009 already_processed.append('id') 3010 write(' id=%s' % (quote_attrib(self.id))) 3011 def exportChildren(self, write, level, namespace_='', name_='digitalSignatureObject', fromsubclass_=False): 3012 if self.certificateIssuer is not None: 3013 showIndent(write, level) 3014 write('<%scertificateIssuer>%s</%scertificateIssuer>\n' % (namespace_, quote_xml(self.certificateIssuer), namespace_)) 3015 if self.certificateSubject is not None: 3016 showIndent(write, level) 3017 write('<%scertificateSubject>%s</%scertificateSubject>\n' % (namespace_, quote_xml(self.certificateSubject), namespace_)) 3018 if self.certificateValidity is not None: 3019 showIndent(write, level) 3020 write('<%scertificateValidity>%s</%scertificateValidity>\n' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.certificateValidity)), input_name='certificateValidity'), namespace_)) 3021 if self.certificateRevocationTimestamp is not None: 3022 showIndent(write, level) 3023 write('<%scertificateRevocationTimestamp>%s</%scertificateRevocationTimestamp>\n' % (namespace_, quote_xml(self.certificateRevocationTimestamp), namespace_)) 3024 if self.signingTimestamp is not None: 3025 self.signingTimestamp.export(write, level, namespace_, name_='signingTimestamp') 3026 def hasContent_(self): 3027 if ( 3028 self.certificateIssuer is not None or 3029 self.certificateSubject is not None or 3030 self.certificateValidity is not None or 3031 self.certificateRevocationTimestamp is not None or 3032 self.signingTimestamp is not None 3033 ): 3034 return True 3035 else: 3036 return False 3037 def build(self, node): 3038 self.__sourcenode__ = node 3039 self.buildAttributes(node, node.attrib, []) 3040 for child in node: 3041 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3042 self.buildChildren(child, node, nodeName_) 3043 def buildAttributes(self, node, attrs, already_processed): 3044 value = find_attr_value_('type', node) 3045 if value is not None and 'type' not in already_processed: 3046 already_processed.append('type') 3047 self.type_ = value 3048 value = find_attr_value_('id', node) 3049 if value is not None and 'id' not in already_processed: 3050 already_processed.append('id') 3051 self.id = value 3052 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3053 if nodeName_ == 'certificateIssuer': 3054 certificateIssuer_ = child_.text 3055 certificateIssuer_ = self.gds_validate_string(certificateIssuer_, node, 'certificateIssuer') 3056 self.certificateIssuer = certificateIssuer_ 3057 elif nodeName_ == 'certificateSubject': 3058 certificateSubject_ = child_.text 3059 certificateSubject_ = self.gds_validate_string(certificateSubject_, node, 'certificateSubject') 3060 self.certificateSubject = certificateSubject_ 3061 elif nodeName_ == 'certificateValidity': 3062 sval_ = child_.text 3063 if sval_ in ('true', '1'): 3064 ival_ = True 3065 elif sval_ in ('false', '0'): 3066 ival_ = False 3067 else: 3068 raise_parse_error(child_, 'requires boolean') 3069 ival_ = self.gds_validate_boolean(ival_, node, 'certificateValidity') 3070 self.certificateValidity = ival_ 3071 elif nodeName_ == 'certificateRevocationTimestamp': 3072 certificateRevocationTimestamp_ = child_.text 3073 certificateRevocationTimestamp_ = self.gds_validate_string(certificateRevocationTimestamp_, node, 'certificateRevocationTimestamp') 3074 self.certificateRevocationTimestamp = certificateRevocationTimestamp_ 3075 elif nodeName_ == 'signingTimestamp': 3076 obj_ = signingTimestamp.factory() 3077 obj_.build(child_) 3078 self.set_signingTimestamp(obj_) 3079# end class digitalSignatureObject 3080 3081 3082class signingTimestamp(GeneratedsSuper): 3083 subclass = None 3084 superclass = None 3085 def __init__(self, valid=None, valueOf_=None): 3086 self.valid = _cast(bool, valid) 3087 self.valueOf_ = valueOf_ 3088 def factory(*args_, **kwargs_): 3089 if signingTimestamp.subclass: 3090 return signingTimestamp.subclass(*args_, **kwargs_) 3091 else: 3092 return signingTimestamp(*args_, **kwargs_) 3093 factory = staticmethod(factory) 3094 def get_valid(self): return self.valid 3095 def set_valid(self, valid): self.valid = valid 3096 def get_valueOf_(self): return self.valueOf_ 3097 def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_ 3098 def export(self, write, level, namespace_='', name_='signingTimestamp', namespacedef_=''): 3099 showIndent(write, level) 3100 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3101 already_processed = [] 3102 self.exportAttributes(write, level, already_processed, namespace_, name_='signingTimestamp') 3103 if self.hasContent_(): 3104 write('>') 3105 write(quote_xml(self.valueOf_)) 3106 self.exportChildren(write, level + 1, namespace_, name_) 3107 write('</%s%s>\n' % (namespace_, name_)) 3108 else: 3109 write('/>\n') 3110 def exportAttributes(self, write, level, already_processed, namespace_='', name_='signingTimestamp'): 3111 if self.valid is not None and 'valid' not in already_processed: 3112 already_processed.append('valid') 3113 write(' valid="%s"' % self.gds_format_boolean(self.gds_str_lower(str(self.valid)), input_name='valid')) 3114 def exportChildren(self, write, level, namespace_='', name_='signingTimestamp', fromsubclass_=False): 3115 pass 3116 def hasContent_(self): 3117 if ( 3118 self.valueOf_ 3119 ): 3120 return True 3121 else: 3122 return False 3123 def build(self, node): 3124 self.__sourcenode__ = node 3125 self.buildAttributes(node, node.attrib, []) 3126 self.valueOf_ = get_all_text_(node) 3127 for child in node: 3128 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3129 self.buildChildren(child, node, nodeName_) 3130 def buildAttributes(self, node, attrs, already_processed): 3131 value = find_attr_value_('valid', node) 3132 if value is not None and 'valid' not in already_processed: 3133 already_processed.append('valid') 3134 if value in ('true', '1'): 3135 self.valid = True 3136 elif value in ('false', '0'): 3137 self.valid = False 3138 else: 3139 raise_parse_error(node, 'Bad boolean attribute') 3140 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3141 pass 3142# end class signingTimestamp 3143 3144 3145class taggantObject(GeneratedsSuper): 3146 """Taggant object, for use in characterizing the software taggant that 3147 may be associated with a file or multiple files. For more 3148 information on the taggant system or the IEEE Malware Working 3149 Group that created it, please see 3150 http://standards.ieee.org/develop/indconn/icsg/malware.html.""" 3151 subclass = None 3152 superclass = None 3153 def __init__(self, id=None, vendorID=None, taggantValidity=None, signingTimestamp=None): 3154 self.id = _cast(None, id) 3155 self.vendorID = vendorID 3156 self.taggantValidity = taggantValidity 3157 self.signingTimestamp = signingTimestamp 3158 def factory(*args_, **kwargs_): 3159 if taggantObject.subclass: 3160 return taggantObject.subclass(*args_, **kwargs_) 3161 else: 3162 return taggantObject(*args_, **kwargs_) 3163 factory = staticmethod(factory) 3164 def get_vendorID(self): return self.vendorID 3165 def set_vendorID(self, vendorID): self.vendorID = vendorID 3166 def get_taggantValidity(self): return self.taggantValidity 3167 def set_taggantValidity(self, taggantValidity): self.taggantValidity = taggantValidity 3168 def get_signingTimestamp(self): return self.signingTimestamp 3169 def set_signingTimestamp(self, signingTimestamp): self.signingTimestamp = signingTimestamp 3170 def get_id(self): return self.id 3171 def set_id(self, id): self.id = id 3172 def export(self, write, level, namespace_='', name_='taggantObject', namespacedef_=''): 3173 showIndent(write, level) 3174 write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) 3175 already_processed = [] 3176 self.exportAttributes(write, level, already_processed, namespace_, name_='taggantObject') 3177 if self.hasContent_(): 3178 write('>\n') 3179 self.exportChildren(write, level + 1, namespace_, name_) 3180 showIndent(write, level) 3181 write('</%s%s>\n' % (namespace_, name_)) 3182 else: 3183 write('/>\n') 3184 def exportAttributes(self, write, level, already_processed, namespace_='', name_='taggantObject'): 3185 if self.id is not None and 'id' not in already_processed: 3186 already_processed.append('id') 3187 write(' id=%s' % (quote_attrib(self.id))) 3188 def exportChildren(self, write, level, namespace_='', name_='taggantObject', fromsubclass_=False): 3189 if self.vendorID is not None: 3190 showIndent(write, level) 3191 write('<%svendorID>%s</%svendorID>\n' % (namespace_, quote_xml(self.vendorID), namespace_)) 3192 if self.taggantValidity is not None: 3193 showIndent(write, level) 3194 write('<%staggantValidity>%s</%staggantValidity>\n' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.taggantValidity)), input_name='taggantValidity'), namespace_)) 3195 if self.signingTimestamp is not None: 3196 self.signingTimestamp.export(write, level, namespace_, name_='signingTimestamp') 3197 def hasContent_(self): 3198 if ( 3199 self.vendorID is not None or 3200 self.taggantValidity is not None or 3201 self.signingTimestamp is not None 3202 ): 3203 return True 3204 else: 3205 return False 3206 def build(self, node): 3207 self.__sourcenode__ = node 3208 self.buildAttributes(node, node.attrib, []) 3209 for child in node: 3210 nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] 3211 self.buildChildren(child, node, nodeName_) 3212 def buildAttributes(self, node, attrs, already_processed): 3213 value = find_attr_value_('id', node) 3214 if value is not None and 'id' not in already_processed: 3215 already_processed.append('id') 3216 self.id = value 3217 def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): 3218 if nodeName_ == 'vendorID': 3219 vendorID_ = child_.text 3220 vendorID_ = self.gds_validate_string(vendorID_, node, 'vendorID') 3221 self.vendorID = vendorID_ 3222 elif nodeName_ == 'taggantValidity': 3223 sval_ = child_.text 3224 if sval_ in ('true', '1'): 3225 ival_ = True 3226 elif sval_ in ('false', '0'): 3227 ival_ = False 3228 else: 3229 raise_parse_error(child_, 'requires boolean') 3230 ival_ = self.gds_validate_boolean(ival_, node, 'taggantValidity') 3231 self.taggantValidity = ival_ 3232 elif nodeName_ == 'signingTimestamp': 3233 obj_ = signingTimestamp.factory() 3234 obj_.build(child_) 3235 self.set_signingTimestamp(obj_) 3236# end class taggantObject 3237 3238 3239USAGE_TEXT = """ 3240Usage: python <Parser>.py [ -s ] <in_xml_file> 3241""" 3242 3243def usage(): 3244 print(USAGE_TEXT) 3245 sys.exit(1) 3246 3247def parse(inFileName): 3248 doc = parsexml_(inFileName) 3249 rootNode = doc.getroot() 3250 rootTag, rootClass = get_root_tag(rootNode) 3251 if rootClass is None: 3252 rootTag = 'malwareMetaData' 3253 rootClass = malwareMetaData 3254 rootObj = rootClass.factory() 3255 rootObj.build(rootNode) 3256 # Enable Python to collect the space used by the DOM. 3257 doc = None 3258 sys.stdout.write('<?xml version="1.0" ?>\n') 3259 rootObj.export(sys.stdout, 0, name_=rootTag, 3260 namespacedef_='') 3261 return rootObj 3262 3263 3264def parseString(inString): 3265 from mixbox.vendor.six import StringIO 3266 doc = parsexml_(StringIO(inString)) 3267 rootNode = doc.getroot() 3268 rootTag, rootClass = get_root_tag(rootNode) 3269 if rootClass is None: 3270 rootTag = 'malwareMetaData' 3271 rootClass = malwareMetaData 3272 rootObj = rootClass.factory() 3273 rootObj.build(rootNode) 3274 # Enable Python to collect the space used by the DOM. 3275 doc = None 3276 sys.stdout.write('<?xml version="1.0" ?>\n') 3277 rootObj.export(sys.stdout, 0, name_="malwareMetaData", 3278 namespacedef_='') 3279 return rootObj 3280 3281 3282def parseLiteral(inFileName): 3283 doc = parsexml_(inFileName) 3284 rootNode = doc.getroot() 3285 rootTag, rootClass = get_root_tag(rootNode) 3286 if rootClass is None: 3287 rootTag = 'malwareMetaData' 3288 rootClass = malwareMetaData 3289 rootObj = rootClass.factory() 3290 rootObj.build(rootNode) 3291 # Enable Python to collect the space used by the DOM. 3292 doc = None 3293 sys.stdout.write('#from mmdef import *\n\n') 3294 sys.stdout.write('import mmdef as model_\n\n') 3295 sys.stdout.write('rootObj = model_.rootTag(\n') 3296 rootObj.exportLiteral(sys.stdout, 0, name_=rootTag) 3297 sys.stdout.write(')\n') 3298 return rootObj 3299 3300 3301def main(): 3302 args = sys.argv[1:] 3303 if len(args) == 1: 3304 parse(args[0]) 3305 else: 3306 usage() 3307 3308 3309if __name__ == '__main__': 3310 #import pdb; pdb.set_trace() 3311 main() 3312 3313 3314__all__ = [ 3315 "ASNObject", 3316 "CPEname", 3317 "IPAddress", 3318 "IPObject", 3319 "classificationDetails", 3320 "classificationObject", 3321 "digitalSignatureObject", 3322 "domainObject", 3323 "entityObject", 3324 "extraHash", 3325 "fieldData", 3326 "fieldDataEntry", 3327 "fileObject", 3328 "location", 3329 "malwareMetaData", 3330 "objectProperties", 3331 "objectProperty", 3332 "objects", 3333 "property", 3334 "reference", 3335 "references", 3336 "registryObject", 3337 "relationship", 3338 "relationships", 3339 "signingTimestamp", 3340 "softwarePackageObject", 3341 "source", 3342 "taggantObject", 3343 "target", 3344 "uriObject", 3345 "volume" 3346 ] 3347