CryptoDataHub 0.12.6__py3-none-any.whl

cryptodatahub/common/entity.json

@@ -0,0 +1,269 @@
+{
+    "AKAMAI": {
+        "name": "ANSI",
+        "long_name": "American National Standards Institute",
+        "type": "NONPROFIT_ORG",
+        "activities": [
+            "STANDARD_DEVELOPER"
+        ]
+    },
+    "ANSI": {
+        "name": "Akamai Technologies",
+        "long_name": "Akamai Technologies, Inc.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "APPLE": {
+        "name": "Apple",
+        "long_name": "Apple Inc.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CA_TRUST_STORE_OWNER"
+        ]
+    },
+    "ASF": {
+        "name": "Apache Software Foundation",
+        "long_name": null,
+        "type": "NOT_FOR_PROFIT_ORG",
+        "activities": [
+            "SERVER_DEVELOPER"
+        ]
+    },
+    "BEIJING_PUCHUANGSIDA_TECHNOLOGY_LTD": {
+        "name": "Beijing PuChuangSiDa Technology Ltd.",
+        "long_name": null,
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "CERTICOM": {
+        "name": "Certicom",
+        "long_name": "Certicom Corp.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "STANDARD_DEVELOPER"
+        ]
+    },
+    "CERTLY": {
+        "name": "Certly",
+        "long_name": "Certly VOF",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "CLOUDFLARE": {
+        "name": "Cloudflare",
+        "long_name": "Cloudflare, Inc.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "CNNIC": {
+        "name": "CNNIC",
+        "long_name": "China Internet Network Information Center",
+        "type": "GOV_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "DIGICERT": {
+        "name": "DigiCert",
+        "long_name": "DigiCert, Inc.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "F5": {
+        "name": "F5",
+        "long_name": "F5, Inc.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "SERVER_DEVELOPER"
+        ]
+    },
+    "GDCA": {
+        "name": "Guangdong CA",
+        "long_name": "Digital Security Times Technology Co., Ltd.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "GOOGLE": {
+        "name": "Google",
+        "long_name": "Google LLC",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CA_TRUST_STORE_OWNER",
+            "CT_LOG_OPERATOR",
+            "CLIENT_DEVELOPER"
+        ]
+    },
+    "IETF": {
+        "name": "IETF",
+        "long_name": "Internet Engineering Task Force",
+        "type": "NONPROFIT_ORG",
+        "activities": [
+            "STANDARD_DEVELOPER"
+        ]
+    },
+    "IZENPE": {
+        "name": "Izenpe SA",
+        "long_name": null,
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "LETS_ENCRYPT": {
+        "name": "Let's Encrypt",
+        "long_name": null,
+        "type": "NONPROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "MATT_PALMER": {
+        "name": "Matt Palmer",
+        "long_name": null,
+        "type": "PRIV_PERSON",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "MICROSOFT": {
+        "name": "Microsoft",
+        "long_name": "Microsoft Corporation",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CA_TRUST_STORE_OWNER"
+        ]
+    },
+    "MOZILLA": {
+        "name": "Mozilla",
+        "long_name": "Mozilla Foundation",
+        "type": "NONPROFIT_ORG",
+        "activities": [
+            "CA_TRUST_STORE_OWNER",
+            "CLIENT_DEVELOPER"
+        ]
+    },
+    "NIST": {
+        "name": "NIST",
+        "long_name": "National Institute of Standards and Technology",
+        "type": "NOT_FOR_PROFIT_ORG",
+        "activities": [
+            "STANDARD_DEVELOPER"
+        ]
+    },
+    "NORDUNET": {
+        "name": "NORDUnet",
+        "long_name": "Arctic Gateway for Research & Education",
+        "type": "NOT_FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "OPERA": {
+        "name": "Opera",
+        "long_name": "Opera, Ltd.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CLIENT_DEVELOPER"
+        ]
+    },
+    "QIHOO_360": {
+        "name": "Qihoo 360",
+        "long_name": "360 Security Technology Inc.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "SECTIGO": {
+        "name": "Sectigo",
+        "long_name": null,
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "SHECA": {
+        "name": "Shanghai CA",
+        "long_name": "Shanghai Digital Certificate Certification Center Co., Ltd.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "STARTCOM": {
+        "name": "StartCom",
+        "long_name": "StartCom Ltd.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "TRUSTASIA": {
+        "name": "TrustAsia",
+        "long_name": "TrustAsia Technologies, Inc.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "UP_IN_THE_AIR_CONSULTING": {
+        "name": "Up In The Air Consulting",
+        "long_name": null,
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "VENAFI": {
+        "name": "Venafi",
+        "long_name": "Venafi, Inc.",
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "FILIPPO_VALSORDA": {
+        "name": "Filippo Valsorda",
+        "long_name": null,
+        "type": "PRIV_PERSON",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "WAP_FORUM": {
+        "name": "WAP Forum",
+        "long_name": "Wireless Application Protocol Forum Ltd.",
+        "type": "NONPROFIT_ORG",
+        "activities": [
+            "STANDARD_DEVELOPER"
+        ]
+    },
+    "WIETSE_VENEMA": {
+        "name": "Wietse Venema",
+        "long_name": "Wietse Zweitze Venema",
+        "type": "PRIV_PERSON",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    },
+    "WOSIGN": {
+        "name": "WoSign",
+        "long_name": null,
+        "type": "FOR_PROFIT_ORG",
+        "activities": [
+            "CT_LOG_OPERATOR"
+        ]
+    }
+}

cryptodatahub/common/entity.py

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+
+import enum
+
+import attr
+
+from cryptodatahub.common.types import CryptoDataEnumBase, CryptoDataParamsNamed, convert_enum, convert_iterable
+
+
+class EntityType(enum.Enum):
+    FOR_PROFIT_ORG = 'for-profit organization'
+    GOV_ORG = 'governmental organization'
+    NONPROFIT_ORG = 'nonprofit organization'
+    NOT_FOR_PROFIT_ORG = 'not-for-profit organization'
+    PRIV_PERSON = 'private person'
+
+
+class EntityRole(enum.Enum):
+    CA_TRUST_STORE_OWNER = 'CA trust store owner'
+    CLIENT_DEVELOPER = 'client developer'
+    CT_LOG_OPERATOR = 'certificate transparency log operator'
+    SERVER_DEVELOPER = 'server developer'
+    STANDARD_DEVELOPER = 'standard developer'
+
+
+@attr.s(frozen=True)
+class EntityParams(CryptoDataParamsNamed):
+    type = attr.ib(
+        converter=convert_enum(EntityType),
+        validator=attr.validators.instance_of(EntityType)
+    )
+    activities = attr.ib(
+        converter=convert_iterable(convert_enum(EntityRole)),
+        validator=attr.validators.deep_iterable(attr.validators.instance_of(EntityRole))
+    )
+
+
+class EntityBase(CryptoDataEnumBase):
+    @classmethod
+    def get_items_by_role(cls, role):
+        if not hasattr(cls, '_ITEMS_BY_ROLE'):
+            items_by_role = {}
+
+            for activity in EntityRole:
+                items_by_role[activity] = []
+
+            for entity in cls:
+                for activity in entity.value.activities:
+                    items_by_role[activity].append(entity)
+
+            cls._ITEMS_BY_ROLE = {
+                role: tuple(activities)
+                for role, activities in items_by_role.items()
+            }
+
+        return cls._ITEMS_BY_ROLE[role]
+
+
+Entity = EntityBase('Entity', EntityBase.get_json_records(EntityParams))
+
+
+class ClientType(enum.Enum):
+    CT_LOG_OPERATOR = 'certificate transparency log operator'
+    WEB_BROWSER = 'web browser'
+
+
+@attr.s(frozen=True)
+class ClientParams(CryptoDataParamsNamed):
+    type = attr.ib(
+        converter=convert_enum(ClientType),
+        validator=attr.validators.instance_of(ClientType)
+    )
+    developer = attr.ib(
+        converter=convert_enum(Entity),
+        validator=attr.validators.instance_of(Entity)
+    )
+
+    def __str__(self):
+        return '{} {}'.format(self.developer.value.name, self.name)
+
+
+Client = CryptoDataEnumBase('Client', CryptoDataEnumBase.get_json_records(ClientParams))
+
+
+class ServerType(enum.Enum):
+    FTP_SERVER = 'ftp server'
+    MAIL_SERVER = 'mail server'
+    WEB_SERVER = 'web server'
+    TCP_SERVER = 'tcp server'
+
+
+@attr.s(frozen=True)
+class ServerParams(CryptoDataParamsNamed):
+    types = attr.ib(
+        converter=convert_iterable(convert_enum(ServerType)),
+        validator=attr.validators.deep_iterable(attr.validators.instance_of(ServerType))
+    )
+    developers = attr.ib(
+        converter=convert_iterable(convert_enum(Entity)),
+        validator=attr.validators.deep_iterable(attr.validators.instance_of(Entity))
+    )
+
+    def __str__(self):
+        server_str = self.name
+        if self.developers:
+            server_str += ' ({})'.format(','.join(map(lambda developer: developer.value.name, self.developers)))
+        return server_str
+
+
+Server = CryptoDataEnumBase('Server', CryptoDataEnumBase.get_json_records(ServerParams))

cryptodatahub/common/exception.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+import enum
+import six
+
+import attr
+
+
+@attr.s(init=False)
+class InvalidValue(Exception):
+    value = attr.ib()
+
+    def __init__(self, value, type_class, class_member=None):
+        if isinstance(value, enum.IntEnum):
+            message = hex(value.value)
+        elif isinstance(value, int):
+            message = hex(value)
+        else:
+            message = value
+        message = hex(value) if isinstance(value, int) else repr(value)
+        type_name = type_class.__name__ if hasattr(type_class, '__name__') else str(type(type_class))
+        message = six.ensure_text('{} is not a valid {}').format(message, type_name)
+        if class_member is not None:
+            message = six.ensure_text('{} {} value').format(message, class_member)
+
+        super(InvalidValue, self).__init__(message)
+
+        self.value = value

cryptodatahub/common/grade.py

@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+
+import abc
+import enum
+import functools
+
+import six
+
+import attr
+
+from cryptodatahub.common.types import (
+    CryptoDataEnumBase,
+    CryptoDataEnumOIDBase,
+    CryptoDataParamsNamed,
+    convert_enum,
+    convert_iterable,
+    convert_dict_to_object,
+)
+
+
+@functools.total_ordering
+@attr.s(frozen=True, order=False, eq=False, hash=True)
+class GradeTypeParams(CryptoDataParamsNamed):
+    _numeric = attr.ib(validator=attr.validators.instance_of(six.integer_types))
+
+    def __eq__(self, other):
+        return self._numeric == other._numeric
+
+    def __lt__(self, other):
+        return self._numeric < other._numeric
+
+
+class Grade(enum.Enum):
+    SECURE = GradeTypeParams(
+        name='secure',
+        long_name=None,
+        numeric=0,
+    )
+    DEPRECATED = GradeTypeParams(
+        name='deprecated',
+        long_name=None,
+        numeric=-1,
+    )
+    WEAK = GradeTypeParams(
+        name='weak',
+        long_name=None,
+        numeric=-2,
+    )
+    INSECURE = GradeTypeParams(
+        name='insecure',
+        long_name=None,
+        numeric=-3,
+    )
+
+
+@attr.s(frozen=True)
+class AttackTypeParams(CryptoDataParamsNamed):
+    pass
+
+
+AttackType = CryptoDataEnumOIDBase('AttackType', CryptoDataEnumBase.get_json_records(AttackTypeParams))
+
+
+@attr.s(frozen=True)
+class AttackNamedParams(CryptoDataParamsNamed):
+    grade = attr.ib(
+        converter=convert_enum(Grade),
+        validator=attr.validators.instance_of(Grade)
+    )
+    attack_type = attr.ib(
+        converter=convert_enum(AttackType),
+        validator=attr.validators.optional(attr.validators.instance_of(AttackType))
+    )
+
+
+AttackNamed = CryptoDataEnumOIDBase('AttackNamed', CryptoDataEnumBase.get_json_records(AttackNamedParams))
+
+
+@attr.s(frozen=True, eq=False)
+class Gradeable(object):
+    @staticmethod
+    def _get_vulnerbilities(obj):
+        if obj is None:
+            return [None]
+
+        if isinstance(obj, Vulnerability):
+            return [obj]
+
+        if isinstance(obj, (list, tuple)):
+            result = []
+            for gradeable in obj:
+                if isinstance(gradeable, GradeableComplex):
+                    result.append(Gradeable._get_vulnerbilities(gradeable.gradeables))
+                elif isinstance(gradeable, GradeableVulnerabilities):
+                    result.append(gradeable.vulnerabilities)
+                else:
+                    result.append(Gradeable._get_vulnerbilities(gradeable))
+
+            return result
+
+        raise NotImplementedError(type(obj))
+
+    @staticmethod
+    def _flatten_vulnerabilities(vulnerabilities):
+        if not vulnerabilities:
+            return vulnerabilities
+
+        if isinstance(vulnerabilities[0], list):
+            return (
+                Gradeable._flatten_vulnerabilities(vulnerabilities[0]) +
+                Gradeable._flatten_vulnerabilities(vulnerabilities[1:])
+            )
+        return vulnerabilities[:1] + Gradeable._flatten_vulnerabilities(vulnerabilities[1:])
+
+    @staticmethod
+    def get_min_grade(vulnerabilities):
+        vulnerabilities = Gradeable._flatten_vulnerabilities((Gradeable._get_vulnerbilities(vulnerabilities)))
+        if not vulnerabilities:
+            return Grade.SECURE
+
+        grades = set(
+            vulnerability.grade
+            for vulnerability in vulnerabilities
+            if vulnerability is not None
+        )
+        if grades:
+            return min(grades, key=lambda grade: grade.value)
+
+        return None
+
+    @property
+    @abc.abstractmethod
+    def min_grade(self):
+        raise NotImplementedError()
+
+
+@attr.s(frozen=True)
+class Vulnerability(object):
+    attack_type = attr.ib(
+        converter=convert_enum(AttackType),
+        validator=attr.validators.optional(attr.validators.instance_of(AttackType))
+    )
+    grade = attr.ib(
+        converter=convert_enum(Grade),
+        validator=attr.validators.instance_of(Grade)
+    )
+    named = attr.ib(
+        converter=convert_enum(AttackNamed),
+        validator=attr.validators.optional(attr.validators.instance_of(AttackNamed))
+    )
+
+
+@attr.s(frozen=True, eq=False)
+class GradeableSimple(Gradeable):
+    @property
+    @abc.abstractmethod
+    def grade(self):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def __str__(self):
+        raise NotImplementedError()
+
+    @property
+    def min_grade(self):
+        return self.grade
+
+
+@attr.s(frozen=True, eq=False)
+class GradeableVulnerabilities(Gradeable):
+    vulnerabilities = attr.ib(
+        converter=convert_iterable(convert_dict_to_object(Vulnerability)),
+        validator=attr.validators.optional(
+            validator=attr.validators.deep_iterable(member_validator=attr.validators.instance_of(Vulnerability))
+        )
+    )
+
+    @classmethod
+    @abc.abstractmethod
+    def get_gradeable_name(cls):
+        raise NotImplementedError()
+
+    @property
+    def min_grade(self):
+        return self.get_min_grade(self.vulnerabilities)
+
+
+@attr.s(eq=False)
+class GradeableComplex(Gradeable):
+    gradeables = attr.ib(
+        init=False,
+        default=None,
+        validator=attr.validators.optional(attr.validators.deep_iterable(
+            member_validator=attr.validators.optional(attr.validators.instance_of(Gradeable))
+        ))
+    )
+
+    @property
+    def min_grade(self):
+        return self.get_min_grade(self.gradeables)