Merge pull request #384 from oasis-open/365-versioned-classes

Validate custom type/property name formats

Author: clenk

stix2/__init__.py

@@ -23,7 +23,6 @@
 DEFAULT_VERSION = '2.0'  # Default version will always be the latest STIX 2.X version
 
 from .confidence import scales
-from .core import _collect_stix2_mappings, parse, parse_observable
 from .datastore import CompositeDataSource
 from .datastore.filesystem import (
     FileSystemSink, FileSystemSource, FileSystemStore,
@@ -38,6 +37,7 @@
     add_markings, clear_markings, get_markings, is_marked, remove_markings,
     set_markings,
 )
+from .parsing import _collect_stix2_mappings, parse, parse_observable
 from .patterns import (
     AndBooleanExpression, AndObservationExpression, BasicObjectPathComponent,
     BinaryConstant, BooleanConstant, EqualityComparisonExpression,

stix2/base.py

@@ -2,20 +2,25 @@
 
 import copy
 import datetime as dt
+import re
 import uuid
 
 import simplejson as json
 import six
 
+import stix2
 from stix2.canonicalization.Canonicalize import canonicalize
 
 from .exceptions import (
     AtLeastOnePropertyError, DependentPropertiesError, ExtraPropertiesError,
     ImmutableError, InvalidObjRefError, InvalidValueError,
     MissingPropertiesError, MutuallyExclusivePropertiesError,
 )
+from .markings import _MarkingsMixin
 from .markings.utils import validate
-from .utils import NOW, find_property_index, format_datetime, get_timestamp
+from .utils import (
+    NOW, PREFIX_21_REGEX, find_property_index, format_datetime, get_timestamp,
+)
 from .utils import new_version as _new_version
 from .utils import revoke as _revoke
 
@@ -157,12 +162,23 @@ def __init__(self, allow_custom=False, **kwargs):
         custom_props = kwargs.pop('custom_properties', {})
         if custom_props and not isinstance(custom_props, dict):
             raise ValueError("'custom_properties' must be a dictionary")
-        if not self._allow_custom:
-            extra_kwargs = list(set(kwargs) - set(self._properties))
-            if extra_kwargs:
-                raise ExtraPropertiesError(cls, extra_kwargs)
-        if custom_props:
+
+        extra_kwargs = list(set(kwargs) - set(self._properties))
+        if extra_kwargs and not self._allow_custom:
+            raise ExtraPropertiesError(cls, extra_kwargs)
+
+        # because allow_custom is true, any extra kwargs are custom
+        if custom_props or extra_kwargs:
             self._allow_custom = True
+            if isinstance(self, stix2.v21._STIXBase21):
+                all_custom_prop_names = extra_kwargs
+                all_custom_prop_names.extend(list(custom_props.keys()))
+                for prop_name in all_custom_prop_names:
+                    if not re.match(PREFIX_21_REGEX, prop_name):
+                        raise InvalidValueError(
+                            self.__class__, prop_name,
+                            reason="Property name '%s' must begin with an alpha character." % prop_name,
+                        )
 
         # Remove any keyword arguments whose value is None or [] (i.e. empty list)
         setting_kwargs = {}
@@ -305,6 +321,14 @@ def sort_by(element):
             return json.dumps(self, cls=STIXJSONEncoder, **kwargs)
 
 
+class _DomainObject(_STIXBase, _MarkingsMixin):
+    pass
+
+
+class _RelationshipObject(_STIXBase, _MarkingsMixin):
+    pass
+
+
 class _Observable(_STIXBase):
 
     def __init__(self, **kwargs):

stix2/custom.py

@@ -1,140 +1,91 @@
 from collections import OrderedDict
-import re
 
 import six
 
-from .base import _cls_init, _Extension, _Observable, _STIXBase
-from .core import (
-    STIXDomainObject, _register_marking, _register_object,
-    _register_observable, _register_observable_extension,
+from .base import _cls_init
+from .parsing import (
+    _register_marking, _register_object, _register_observable,
+    _register_observable_extension,
 )
-from .utils import TYPE_REGEX, get_class_hierarchy_names
 
 
-def _custom_object_builder(cls, type, properties, version):
-    class _CustomObject(cls, STIXDomainObject):
+def _get_properties_dict(properties):
+    try:
+        return OrderedDict(properties)
+    except TypeError as e:
+        six.raise_from(
+            ValueError(
+                "properties must be dict-like, e.g. a list "
+                "containing tuples.  For example, "
+                "[('property1', IntegerProperty())]",
+            ),
+            e,
+        )
 
-        if not re.match(TYPE_REGEX, type):
-            raise ValueError(
-                "Invalid type name '%s': must only contain the "
-                "characters a-z (lowercase ASCII), 0-9, and hyphen (-)." % type,
-            )
-        elif len(type) < 3 or len(type) > 250:
-            raise ValueError(
-                "Invalid type name '%s': must be between 3 and 250 characters." % type,
-            )
 
-        if not properties or not isinstance(properties, list):
-            raise ValueError("Must supply a list, containing tuples. For example, [('property1', IntegerProperty())]")
+def _custom_object_builder(cls, type, properties, version, base_class):
+    prop_dict = _get_properties_dict(properties)
+
+    class _CustomObject(cls, base_class):
 
         _type = type
-        _properties = OrderedDict(properties)
+        _properties = prop_dict
 
         def __init__(self, **kwargs):
-            _STIXBase.__init__(self, **kwargs)
+            base_class.__init__(self, **kwargs)
             _cls_init(cls, self, kwargs)
 
     _register_object(_CustomObject, version=version)
     return _CustomObject
 
 
-def _custom_marking_builder(cls, type, properties, version):
-    class _CustomMarking(cls, _STIXBase):
+def _custom_marking_builder(cls, type, properties, version, base_class):
+    prop_dict = _get_properties_dict(properties)
 
-        if not properties or not isinstance(properties, list):
-            raise ValueError("Must supply a list, containing tuples. For example, [('property1', IntegerProperty())]")
+    class _CustomMarking(cls, base_class):
 
         _type = type
-        _properties = OrderedDict(properties)
+        _properties = prop_dict
 
         def __init__(self, **kwargs):
-            _STIXBase.__init__(self, **kwargs)
+            base_class.__init__(self, **kwargs)
             _cls_init(cls, self, kwargs)
 
     _register_marking(_CustomMarking, version=version)
     return _CustomMarking
 
 
-def _custom_observable_builder(cls, type, properties, version, id_contrib_props=None):
+def _custom_observable_builder(cls, type, properties, version, base_class, id_contrib_props=None):
     if id_contrib_props is None:
         id_contrib_props = []
 
-    class _CustomObservable(cls, _Observable):
-
-        if not re.match(TYPE_REGEX, type):
-            raise ValueError(
-                "Invalid observable type name '%s': must only contain the "
-                "characters a-z (lowercase ASCII), 0-9, and hyphen (-)." % type,
-            )
-        elif len(type) < 3 or len(type) > 250:
-            raise ValueError("Invalid observable type name '%s': must be between 3 and 250 characters." % type)
-
-        if not properties or not isinstance(properties, list):
-            raise ValueError("Must supply a list, containing tuples. For example, [('property1', IntegerProperty())]")
-
-        if version == "2.0":
-            # If using STIX2.0, check properties ending in "_ref/s" are ObjectReferenceProperties
-            for prop_name, prop in properties:
-                if prop_name.endswith('_ref') and ('ObjectReferenceProperty' not in get_class_hierarchy_names(prop)):
-                    raise ValueError(
-                        "'%s' is named like an object reference property but "
-                        "is not an ObjectReferenceProperty." % prop_name,
-                    )
-                elif (prop_name.endswith('_refs') and ('ListProperty' not in get_class_hierarchy_names(prop) or
-                                                       'ObjectReferenceProperty' not in get_class_hierarchy_names(prop.contained))):
-                    raise ValueError(
-                        "'%s' is named like an object reference list property but "
-                        "is not a ListProperty containing ObjectReferenceProperty." % prop_name,
-                    )
-        else:
-            # If using STIX2.1 (or newer...), check properties ending in "_ref/s" are ReferenceProperties
-            for prop_name, prop in properties:
-                if prop_name.endswith('_ref') and ('ReferenceProperty' not in get_class_hierarchy_names(prop)):
-                    raise ValueError(
-                        "'%s' is named like a reference property but "
-                        "is not a ReferenceProperty." % prop_name,
-                    )
-                elif (prop_name.endswith('_refs') and ('ListProperty' not in get_class_hierarchy_names(prop) or
-                                                       'ReferenceProperty' not in get_class_hierarchy_names(prop.contained))):
-                    raise ValueError(
-                        "'%s' is named like a reference list property but "
-                        "is not a ListProperty containing ReferenceProperty." % prop_name,
-                    )
+    prop_dict = _get_properties_dict(properties)
+
+    class _CustomObservable(cls, base_class):
 
         _type = type
-        _properties = OrderedDict(properties)
+        _properties = prop_dict
         if version != '2.0':
             _id_contributing_properties = id_contrib_props
 
         def __init__(self, **kwargs):
-            _Observable.__init__(self, **kwargs)
+            base_class.__init__(self, **kwargs)
             _cls_init(cls, self, kwargs)
 
     _register_observable(_CustomObservable, version=version)
     return _CustomObservable
 
 
-def _custom_extension_builder(cls, observable, type, properties, version):
-
-    try:
-        prop_dict = OrderedDict(properties)
-    except TypeError as e:
-        six.raise_from(
-            ValueError(
-                "Extension properties must be dict-like, e.g. a list "
-                "containing tuples.  For example, "
-                "[('property1', IntegerProperty())]",
-            ),
-            e,
-        )
+def _custom_extension_builder(cls, observable, type, properties, version, base_class):
+    prop_dict = _get_properties_dict(properties)
 
-    class _CustomExtension(cls, _Extension):
+    class _CustomExtension(cls, base_class):
 
         _type = type
         _properties = prop_dict
 
         def __init__(self, **kwargs):
-            _Extension.__init__(self, **kwargs)
+            base_class.__init__(self, **kwargs)
             _cls_init(cls, self, kwargs)
 
     _register_observable_extension(observable, _CustomExtension, version=version)

stix2/datastore/filesystem.py

@@ -10,11 +10,11 @@
 
 from stix2 import v20, v21
 from stix2.base import _STIXBase
-from stix2.core import parse
 from stix2.datastore import (
     DataSink, DataSource, DataSourceError, DataStoreMixin,
 )
 from stix2.datastore.filters import Filter, FilterSet, apply_common_filters
+from stix2.parsing import parse
 from stix2.utils import format_datetime, get_type_from_id
 
 

stix2/datastore/memory.py

@@ -7,9 +7,9 @@
 
 from stix2 import v20, v21
 from stix2.base import _STIXBase
-from stix2.core import parse
 from stix2.datastore import DataSink, DataSource, DataStoreMixin
 from stix2.datastore.filters import FilterSet, apply_common_filters
+from stix2.parsing import parse
 
 
 def _add(store, stix_data, allow_custom=True, version=None):

stix2/datastore/taxii.py

@@ -4,11 +4,11 @@
 
 from stix2 import v20, v21
 from stix2.base import _STIXBase
-from stix2.core import parse
 from stix2.datastore import (
     DataSink, DataSource, DataSourceError, DataStoreMixin,
 )
 from stix2.datastore.filters import Filter, FilterSet, apply_common_filters
+from stix2.parsing import parse
 from stix2.utils import deduplicate
 
 try:

stix2/environment.py

@@ -4,8 +4,8 @@
 import logging
 import time
 
-from .core import parse as _parse
 from .datastore import CompositeDataSource, DataStoreMixin
+from .parsing import parse as _parse
 from .utils import STIXdatetime, parse_into_datetime
 
 logger = logging.getLogger(__name__)