<h2>Editing File: /usr/lib64/python3.6/site-packages/cryptography/x509/extensions.py</h2><form method='post'><textarea name='content' class='file-edit'># This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

from __future__ import absolute_import, division, print_function

import abc
import datetime
import hashlib
import ipaddress
from enum import Enum

import six

from cryptography import utils
from cryptography.hazmat._der import (
    BIT_STRING,
    DERReader,
    OBJECT_IDENTIFIER,
    SEQUENCE,
)
from cryptography.hazmat.primitives import constant_time, serialization
from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePublicKey
from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicKey
from cryptography.x509.certificate_transparency import (
    SignedCertificateTimestamp,
)
from cryptography.x509.general_name import GeneralName, IPAddress, OtherName
from cryptography.x509.name import RelativeDistinguishedName
from cryptography.x509.oid import (
    CRLEntryExtensionOID,
    ExtensionOID,
    OCSPExtensionOID,
    ObjectIdentifier,
)


def _key_identifier_from_public_key(public_key):
    if isinstance(public_key, RSAPublicKey):
        data = public_key.public_bytes(
            serialization.Encoding.DER,
            serialization.PublicFormat.PKCS1,
        )
    elif isinstance(public_key, EllipticCurvePublicKey):
        data = public_key.public_bytes(
            serialization.Encoding.X962,
            serialization.PublicFormat.UncompressedPoint,
        )
    else:
        # This is a very slow way to do this.
        serialized = public_key.public_bytes(
            serialization.Encoding.DER,
            serialization.PublicFormat.SubjectPublicKeyInfo,
        )

        reader = DERReader(serialized)
        with reader.read_single_element(SEQUENCE) as public_key_info:
            algorithm = public_key_info.read_element(SEQUENCE)
            public_key = public_key_info.read_element(BIT_STRING)

        # Double-check the algorithm structure.
        with algorithm:
            algorithm.read_element(OBJECT_IDENTIFIER)
            if not algorithm.is_empty():
                # Skip the optional parameters field.
                algorithm.read_any_element()

        # BIT STRING contents begin with the number of padding bytes added. It
        # must be zero for SubjectPublicKeyInfo structures.
        if public_key.read_byte() != 0:
            raise ValueError(&quot;Invalid public key encoding&quot;)

        data = public_key.data

    return hashlib.sha1(data).digest()


def _make_sequence_methods(field_name):
    def len_method(self):
        return len(getattr(self, field_name))

    def iter_method(self):
        return iter(getattr(self, field_name))

    def getitem_method(self, idx):
        return getattr(self, field_name)[idx]

    return len_method, iter_method, getitem_method


class DuplicateExtension(Exception):
    def __init__(self, msg, oid):
        super(DuplicateExtension, self).__init__(msg)
        self.oid = oid


class ExtensionNotFound(Exception):
    def __init__(self, msg, oid):
        super(ExtensionNotFound, self).__init__(msg)
        self.oid = oid


@six.add_metaclass(abc.ABCMeta)
class ExtensionType(object):
    @abc.abstractproperty
    def oid(self):
        &quot;&quot;&quot;
        Returns the oid associated with the given extension type.
        &quot;&quot;&quot;


class Extensions(object):
    def __init__(self, extensions):
        self._extensions = extensions

    def get_extension_for_oid(self, oid):
        for ext in self:
            if ext.oid == oid:
                return ext

        raise ExtensionNotFound(&quot;No {} extension was found&quot;.format(oid), oid)

    def get_extension_for_class(self, extclass):
        if extclass is UnrecognizedExtension:
            raise TypeError(
                &quot;UnrecognizedExtension can't be used with &quot;
                &quot;get_extension_for_class because more than one instance of the&quot;
                &quot; class may be present.&quot;
            )

        for ext in self:
            if isinstance(ext.value, extclass):
                return ext

        raise ExtensionNotFound(
            &quot;No {} extension was found&quot;.format(extclass), extclass.oid
        )

    __len__, __iter__, __getitem__ = _make_sequence_methods(&quot;_extensions&quot;)

    def __repr__(self):
        return &quot;&lt;Extensions({})&gt;&quot;.format(self._extensions)


@utils.register_interface(ExtensionType)
class CRLNumber(object):
    oid = ExtensionOID.CRL_NUMBER

    def __init__(self, crl_number):
        if not isinstance(crl_number, six.integer_types):
            raise TypeError(&quot;crl_number must be an integer&quot;)

        self._crl_number = crl_number

    def __eq__(self, other):
        if not isinstance(other, CRLNumber):
            return NotImplemented

        return self.crl_number == other.crl_number

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.crl_number)

    def __repr__(self):
        return &quot;&lt;CRLNumber({})&gt;&quot;.format(self.crl_number)

    crl_number = utils.read_only_property(&quot;_crl_number&quot;)


@utils.register_interface(ExtensionType)
class AuthorityKeyIdentifier(object):
    oid = ExtensionOID.AUTHORITY_KEY_IDENTIFIER

    def __init__(
        self,
        key_identifier,
        authority_cert_issuer,
        authority_cert_serial_number,
    ):
        if (authority_cert_issuer is None) != (
            authority_cert_serial_number is None
        ):
            raise ValueError(
                &quot;authority_cert_issuer and authority_cert_serial_number &quot;
                &quot;must both be present or both None&quot;
            )

        if authority_cert_issuer is not None:
            authority_cert_issuer = list(authority_cert_issuer)
            if not all(
                isinstance(x, GeneralName) for x in authority_cert_issuer
            ):
                raise TypeError(
                    &quot;authority_cert_issuer must be a list of GeneralName &quot;
                    &quot;objects&quot;
                )

        if authority_cert_serial_number is not None and not isinstance(
            authority_cert_serial_number, six.integer_types
        ):
            raise TypeError(&quot;authority_cert_serial_number must be an integer&quot;)

        self._key_identifier = key_identifier
        self._authority_cert_issuer = authority_cert_issuer
        self._authority_cert_serial_number = authority_cert_serial_number

    @classmethod
    def from_issuer_public_key(cls, public_key):
        digest = _key_identifier_from_public_key(public_key)
        return cls(
            key_identifier=digest,
            authority_cert_issuer=None,
            authority_cert_serial_number=None,
        )

    @classmethod
    def from_issuer_subject_key_identifier(cls, ski):
        if isinstance(ski, SubjectKeyIdentifier):
            digest = ski.digest
        else:
            digest = ski.value.digest
        return cls(
            key_identifier=digest,
            authority_cert_issuer=None,
            authority_cert_serial_number=None,
        )

    def __repr__(self):
        return (
            &quot;&lt;AuthorityKeyIdentifier(key_identifier={0.key_identifier!r}, &quot;
            &quot;authority_cert_issuer={0.authority_cert_issuer}, &quot;
            &quot;authority_cert_serial_number={0.authority_cert_serial_number}&quot;
            &quot;)&gt;&quot;.format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, AuthorityKeyIdentifier):
            return NotImplemented

        return (
            self.key_identifier == other.key_identifier
            and self.authority_cert_issuer == other.authority_cert_issuer
            and self.authority_cert_serial_number
            == other.authority_cert_serial_number
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        if self.authority_cert_issuer is None:
            aci = None
        else:
            aci = tuple(self.authority_cert_issuer)
        return hash(
            (self.key_identifier, aci, self.authority_cert_serial_number)
        )

    key_identifier = utils.read_only_property(&quot;_key_identifier&quot;)
    authority_cert_issuer = utils.read_only_property(&quot;_authority_cert_issuer&quot;)
    authority_cert_serial_number = utils.read_only_property(
        &quot;_authority_cert_serial_number&quot;
    )


@utils.register_interface(ExtensionType)
class SubjectKeyIdentifier(object):
    oid = ExtensionOID.SUBJECT_KEY_IDENTIFIER

    def __init__(self, digest):
        self._digest = digest

    @classmethod
    def from_public_key(cls, public_key):
        return cls(_key_identifier_from_public_key(public_key))

    digest = utils.read_only_property(&quot;_digest&quot;)

    def __repr__(self):
        return &quot;&lt;SubjectKeyIdentifier(digest={0!r})&gt;&quot;.format(self.digest)

    def __eq__(self, other):
        if not isinstance(other, SubjectKeyIdentifier):
            return NotImplemented

        return constant_time.bytes_eq(self.digest, other.digest)

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.digest)


@utils.register_interface(ExtensionType)
class AuthorityInformationAccess(object):
    oid = ExtensionOID.AUTHORITY_INFORMATION_ACCESS

    def __init__(self, descriptions):
        descriptions = list(descriptions)
        if not all(isinstance(x, AccessDescription) for x in descriptions):
            raise TypeError(
                &quot;Every item in the descriptions list must be an &quot;
                &quot;AccessDescription&quot;
            )

        self._descriptions = descriptions

    __len__, __iter__, __getitem__ = _make_sequence_methods(&quot;_descriptions&quot;)

    def __repr__(self):
        return &quot;&lt;AuthorityInformationAccess({})&gt;&quot;.format(self._descriptions)

    def __eq__(self, other):
        if not isinstance(other, AuthorityInformationAccess):
            return NotImplemented

        return self._descriptions == other._descriptions

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(tuple(self._descriptions))


@utils.register_interface(ExtensionType)
class SubjectInformationAccess(object):
    oid = ExtensionOID.SUBJECT_INFORMATION_ACCESS

    def __init__(self, descriptions):
        descriptions = list(descriptions)
        if not all(isinstance(x, AccessDescription) for x in descriptions):
            raise TypeError(
                &quot;Every item in the descriptions list must be an &quot;
                &quot;AccessDescription&quot;
            )

        self._descriptions = descriptions

    __len__, __iter__, __getitem__ = _make_sequence_methods(&quot;_descriptions&quot;)

    def __repr__(self):
        return &quot;&lt;SubjectInformationAccess({})&gt;&quot;.format(self._descriptions)

    def __eq__(self, other):
        if not isinstance(other, SubjectInformationAccess):
            return NotImplemented

        return self._descriptions == other._descriptions

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(tuple(self._descriptions))


class AccessDescription(object):
    def __init__(self, access_method, access_location):
        if not isinstance(access_method, ObjectIdentifier):
            raise TypeError(&quot;access_method must be an ObjectIdentifier&quot;)

        if not isinstance(access_location, GeneralName):
            raise TypeError(&quot;access_location must be a GeneralName&quot;)

        self._access_method = access_method
        self._access_location = access_location

    def __repr__(self):
        return (
            &quot;&lt;AccessDescription(access_method={0.access_method}, access_locati&quot;
            &quot;on={0.access_location})&gt;&quot;.format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, AccessDescription):
            return NotImplemented

        return (
            self.access_method == other.access_method
            and self.access_location == other.access_location
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.access_method, self.access_location))

    access_method = utils.read_only_property(&quot;_access_method&quot;)
    access_location = utils.read_only_property(&quot;_access_location&quot;)


@utils.register_interface(ExtensionType)
class BasicConstraints(object):
    oid = ExtensionOID.BASIC_CONSTRAINTS

    def __init__(self, ca, path_length):
        if not isinstance(ca, bool):
            raise TypeError(&quot;ca must be a boolean value&quot;)

        if path_length is not None and not ca:
            raise ValueError(&quot;path_length must be None when ca is False&quot;)

        if path_length is not None and (
            not isinstance(path_length, six.integer_types) or path_length &lt; 0
        ):
            raise TypeError(
                &quot;path_length must be a non-negative integer or None&quot;
            )

        self._ca = ca
        self._path_length = path_length

    ca = utils.read_only_property(&quot;_ca&quot;)
    path_length = utils.read_only_property(&quot;_path_length&quot;)

    def __repr__(self):
        return (
            &quot;&lt;BasicConstraints(ca={0.ca}, &quot; &quot;path_length={0.path_length})&gt;&quot;
        ).format(self)

    def __eq__(self, other):
        if not isinstance(other, BasicConstraints):
            return NotImplemented

        return self.ca == other.ca and self.path_length == other.path_length

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.ca, self.path_length))


@utils.register_interface(ExtensionType)
class DeltaCRLIndicator(object):
    oid = ExtensionOID.DELTA_CRL_INDICATOR

    def __init__(self, crl_number):
        if not isinstance(crl_number, six.integer_types):
            raise TypeError(&quot;crl_number must be an integer&quot;)

        self._crl_number = crl_number

    crl_number = utils.read_only_property(&quot;_crl_number&quot;)

    def __eq__(self, other):
        if not isinstance(other, DeltaCRLIndicator):
            return NotImplemented

        return self.crl_number == other.crl_number

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.crl_number)

    def __repr__(self):
        return &quot;&lt;DeltaCRLIndicator(crl_number={0.crl_number})&gt;&quot;.format(self)


@utils.register_interface(ExtensionType)
class CRLDistributionPoints(object):
    oid = ExtensionOID.CRL_DISTRIBUTION_POINTS

    def __init__(self, distribution_points):
        distribution_points = list(distribution_points)
        if not all(
            isinstance(x, DistributionPoint) for x in distribution_points
        ):
            raise TypeError(
                &quot;distribution_points must be a list of DistributionPoint &quot;
                &quot;objects&quot;
            )

        self._distribution_points = distribution_points

    __len__, __iter__, __getitem__ = _make_sequence_methods(
        &quot;_distribution_points&quot;
    )

    def __repr__(self):
        return &quot;&lt;CRLDistributionPoints({})&gt;&quot;.format(self._distribution_points)

    def __eq__(self, other):
        if not isinstance(other, CRLDistributionPoints):
            return NotImplemented

        return self._distribution_points == other._distribution_points

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(tuple(self._distribution_points))


@utils.register_interface(ExtensionType)
class FreshestCRL(object):
    oid = ExtensionOID.FRESHEST_CRL

    def __init__(self, distribution_points):
        distribution_points = list(distribution_points)
        if not all(
            isinstance(x, DistributionPoint) for x in distribution_points
        ):
            raise TypeError(
                &quot;distribution_points must be a list of DistributionPoint &quot;
                &quot;objects&quot;
            )

        self._distribution_points = distribution_points

    __len__, __iter__, __getitem__ = _make_sequence_methods(
        &quot;_distribution_points&quot;
    )

    def __repr__(self):
        return &quot;&lt;FreshestCRL({})&gt;&quot;.format(self._distribution_points)

    def __eq__(self, other):
        if not isinstance(other, FreshestCRL):
            return NotImplemented

        return self._distribution_points == other._distribution_points

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(tuple(self._distribution_points))


class DistributionPoint(object):
    def __init__(self, full_name, relative_name, reasons, crl_issuer):
        if full_name and relative_name:
            raise ValueError(
                &quot;You cannot provide both full_name and relative_name, at &quot;
                &quot;least one must be None.&quot;
            )

        if full_name:
            full_name = list(full_name)
            if not all(isinstance(x, GeneralName) for x in full_name):
                raise TypeError(
                    &quot;full_name must be a list of GeneralName objects&quot;
                )

        if relative_name:
            if not isinstance(relative_name, RelativeDistinguishedName):
                raise TypeError(
                    &quot;relative_name must be a RelativeDistinguishedName&quot;
                )

        if crl_issuer:
            crl_issuer = list(crl_issuer)
            if not all(isinstance(x, GeneralName) for x in crl_issuer):
                raise TypeError(
                    &quot;crl_issuer must be None or a list of general names&quot;
                )

        if reasons and (
            not isinstance(reasons, frozenset)
            or not all(isinstance(x, ReasonFlags) for x in reasons)
        ):
            raise TypeError(&quot;reasons must be None or frozenset of ReasonFlags&quot;)

        if reasons and (
            ReasonFlags.unspecified in reasons
            or ReasonFlags.remove_from_crl in reasons
        ):
            raise ValueError(
                &quot;unspecified and remove_from_crl are not valid reasons in a &quot;
                &quot;DistributionPoint&quot;
            )

        if reasons and not crl_issuer and not (full_name or relative_name):
            raise ValueError(
                &quot;You must supply crl_issuer, full_name, or relative_name when &quot;
                &quot;reasons is not None&quot;
            )

        self._full_name = full_name
        self._relative_name = relative_name
        self._reasons = reasons
        self._crl_issuer = crl_issuer

    def __repr__(self):
        return (
            &quot;&lt;DistributionPoint(full_name={0.full_name}, relative_name={0.rela&quot;
            &quot;tive_name}, reasons={0.reasons}, &quot;
            &quot;crl_issuer={0.crl_issuer})&gt;&quot;.format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, DistributionPoint):
            return NotImplemented

        return (
            self.full_name == other.full_name
            and self.relative_name == other.relative_name
            and self.reasons == other.reasons
            and self.crl_issuer == other.crl_issuer
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        if self.full_name is not None:
            fn = tuple(self.full_name)
        else:
            fn = None

        if self.crl_issuer is not None:
            crl_issuer = tuple(self.crl_issuer)
        else:
            crl_issuer = None

        return hash((fn, self.relative_name, self.reasons, crl_issuer))

    full_name = utils.read_only_property(&quot;_full_name&quot;)
    relative_name = utils.read_only_property(&quot;_relative_name&quot;)
    reasons = utils.read_only_property(&quot;_reasons&quot;)
    crl_issuer = utils.read_only_property(&quot;_crl_issuer&quot;)


class ReasonFlags(Enum):
    unspecified = &quot;unspecified&quot;
    key_compromise = &quot;keyCompromise&quot;
    ca_compromise = &quot;cACompromise&quot;
    affiliation_changed = &quot;affiliationChanged&quot;
    superseded = &quot;superseded&quot;
    cessation_of_operation = &quot;cessationOfOperation&quot;
    certificate_hold = &quot;certificateHold&quot;
    privilege_withdrawn = &quot;privilegeWithdrawn&quot;
    aa_compromise = &quot;aACompromise&quot;
    remove_from_crl = &quot;removeFromCRL&quot;


@utils.register_interface(ExtensionType)
class PolicyConstraints(object):
    oid = ExtensionOID.POLICY_CONSTRAINTS

    def __init__(self, require_explicit_policy, inhibit_policy_mapping):
        if require_explicit_policy is not None and not isinstance(
            require_explicit_policy, six.integer_types
        ):
            raise TypeError(
                &quot;require_explicit_policy must be a non-negative integer or &quot;
                &quot;None&quot;
            )

        if inhibit_policy_mapping is not None and not isinstance(
            inhibit_policy_mapping, six.integer_types
        ):
            raise TypeError(
                &quot;inhibit_policy_mapping must be a non-negative integer or None&quot;
            )

        if inhibit_policy_mapping is None and require_explicit_policy is None:
            raise ValueError(
                &quot;At least one of require_explicit_policy and &quot;
                &quot;inhibit_policy_mapping must not be None&quot;
            )

        self._require_explicit_policy = require_explicit_policy
        self._inhibit_policy_mapping = inhibit_policy_mapping

    def __repr__(self):
        return (
            u&quot;&lt;PolicyConstraints(require_explicit_policy={0.require_explicit&quot;
            u&quot;_policy}, inhibit_policy_mapping={0.inhibit_policy_&quot;
            u&quot;mapping})&gt;&quot;.format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, PolicyConstraints):
            return NotImplemented

        return (
            self.require_explicit_policy == other.require_explicit_policy
            and self.inhibit_policy_mapping == other.inhibit_policy_mapping
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(
            (self.require_explicit_policy, self.inhibit_policy_mapping)
        )

    require_explicit_policy = utils.read_only_property(
        &quot;_require_explicit_policy&quot;
    )
    inhibit_policy_mapping = utils.read_only_property(
        &quot;_inhibit_policy_mapping&quot;
    )


@utils.register_interface(ExtensionType)
class CertificatePolicies(object):
    oid = ExtensionOID.CERTIFICATE_POLICIES

    def __init__(self, policies):
        policies = list(policies)
        if not all(isinstance(x, PolicyInformation) for x in policies):
            raise TypeError(
                &quot;Every item in the policies list must be a &quot;
                &quot;PolicyInformation&quot;
            )

        self._policies = policies

    __len__, __iter__, __getitem__ = _make_sequence_methods(&quot;_policies&quot;)

    def __repr__(self):
        return &quot;&lt;CertificatePolicies({})&gt;&quot;.format(self._policies)

    def __eq__(self, other):
        if not isinstance(other, CertificatePolicies):
            return NotImplemented

        return self._policies == other._policies

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(tuple(self._policies))


class PolicyInformation(object):
    def __init__(self, policy_identifier, policy_qualifiers):
        if not isinstance(policy_identifier, ObjectIdentifier):
            raise TypeError(&quot;policy_identifier must be an ObjectIdentifier&quot;)

        self._policy_identifier = policy_identifier

        if policy_qualifiers:
            policy_qualifiers = list(policy_qualifiers)
            if not all(
                isinstance(x, (six.text_type, UserNotice))
                for x in policy_qualifiers
            ):
                raise TypeError(
                    &quot;policy_qualifiers must be a list of strings and/or &quot;
                    &quot;UserNotice objects or None&quot;
                )

        self._policy_qualifiers = policy_qualifiers

    def __repr__(self):
        return (
            &quot;&lt;PolicyInformation(policy_identifier={0.policy_identifier}, polic&quot;
            &quot;y_qualifiers={0.policy_qualifiers})&gt;&quot;.format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, PolicyInformation):
            return NotImplemented

        return (
            self.policy_identifier == other.policy_identifier
            and self.policy_qualifiers == other.policy_qualifiers
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        if self.policy_qualifiers is not None:
            pq = tuple(self.policy_qualifiers)
        else:
            pq = None

        return hash((self.policy_identifier, pq))

    policy_identifier = utils.read_only_property(&quot;_policy_identifier&quot;)
    policy_qualifiers = utils.read_only_property(&quot;_policy_qualifiers&quot;)


class UserNotice(object):
    def __init__(self, notice_reference, explicit_text):
        if notice_reference and not isinstance(
            notice_reference, NoticeReference
        ):
            raise TypeError(
                &quot;notice_reference must be None or a NoticeReference&quot;
            )

        self._notice_reference = notice_reference
        self._explicit_text = explicit_text

    def __repr__(self):
        return (
            &quot;&lt;UserNotice(notice_reference={0.notice_reference}, explicit_text=&quot;
            &quot;{0.explicit_text!r})&gt;&quot;.format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, UserNotice):
            return NotImplemented

        return (
            self.notice_reference == other.notice_reference
            and self.explicit_text == other.explicit_text
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.notice_reference, self.explicit_text))

    notice_reference = utils.read_only_property(&quot;_notice_reference&quot;)
    explicit_text = utils.read_only_property(&quot;_explicit_text&quot;)


class NoticeReference(object):
    def __init__(self, organization, notice_numbers):
        self._organization = organization
        notice_numbers = list(notice_numbers)
        if not all(isinstance(x, int) for x in notice_numbers):
            raise TypeError(&quot;notice_numbers must be a list of integers&quot;)

        self._notice_numbers = notice_numbers

    def __repr__(self):
        return (
            &quot;&lt;NoticeReference(organization={0.organization!r}, notice_numbers=&quot;
            &quot;{0.notice_numbers})&gt;&quot;.format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, NoticeReference):
            return NotImplemented

        return (
            self.organization == other.organization
            and self.notice_numbers == other.notice_numbers
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.organization, tuple(self.notice_numbers)))

    organization = utils.read_only_property(&quot;_organization&quot;)
    notice_numbers = utils.read_only_property(&quot;_notice_numbers&quot;)


@utils.register_interface(ExtensionType)
class ExtendedKeyUsage(object):
    oid = ExtensionOID.EXTENDED_KEY_USAGE

    def __init__(self, usages):
        usages = list(usages)
        if not all(isinstance(x, ObjectIdentifier) for x in usages):
            raise TypeError(
                &quot;Every item in the usages list must be an ObjectIdentifier&quot;
            )

        self._usages = usages

    __len__, __iter__, __getitem__ = _make_sequence_methods(&quot;_usages&quot;)

    def __repr__(self):
        return &quot;&lt;ExtendedKeyUsage({})&gt;&quot;.format(self._usages)

    def __eq__(self, other):
        if not isinstance(other, ExtendedKeyUsage):
            return NotImplemented

        return self._usages == other._usages

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(tuple(self._usages))


@utils.register_interface(ExtensionType)
class OCSPNoCheck(object):
    oid = ExtensionOID.OCSP_NO_CHECK

    def __eq__(self, other):
        if not isinstance(other, OCSPNoCheck):
            return NotImplemented

        return True

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(OCSPNoCheck)

    def __repr__(self):
        return &quot;&lt;OCSPNoCheck()&gt;&quot;


@utils.register_interface(ExtensionType)
class PrecertPoison(object):
    oid = ExtensionOID.PRECERT_POISON

    def __eq__(self, other):
        if not isinstance(other, PrecertPoison):
            return NotImplemented

        return True

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(PrecertPoison)

    def __repr__(self):
        return &quot;&lt;PrecertPoison()&gt;&quot;


@utils.register_interface(ExtensionType)
class TLSFeature(object):
    oid = ExtensionOID.TLS_FEATURE

    def __init__(self, features):
        features = list(features)
        if (
            not all(isinstance(x, TLSFeatureType) for x in features)
            or len(features) == 0
        ):
            raise TypeError(
                &quot;features must be a list of elements from the TLSFeatureType &quot;
                &quot;enum&quot;
            )

        self._features = features

    __len__, __iter__, __getitem__ = _make_sequence_methods(&quot;_features&quot;)

    def __repr__(self):
        return &quot;&lt;TLSFeature(features={0._features})&gt;&quot;.format(self)

    def __eq__(self, other):
        if not isinstance(other, TLSFeature):
            return NotImplemented

        return self._features == other._features

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(tuple(self._features))


class TLSFeatureType(Enum):
    # status_request is defined in RFC 6066 and is used for what is commonly
    # called OCSP Must-Staple when present in the TLS Feature extension in an
    # X.509 certificate.
    status_request = 5
    # status_request_v2 is defined in RFC 6961 and allows multiple OCSP
    # responses to be provided. It is not currently in use by clients or
    # servers.
    status_request_v2 = 17


_TLS_FEATURE_TYPE_TO_ENUM = {x.value: x for x in TLSFeatureType}


@utils.register_interface(ExtensionType)
class InhibitAnyPolicy(object):
    oid = ExtensionOID.INHIBIT_ANY_POLICY

    def __init__(self, skip_certs):
        if not isinstance(skip_certs, six.integer_types):
            raise TypeError(&quot;skip_certs must be an integer&quot;)

        if skip_certs &lt; 0:
            raise ValueError(&quot;skip_certs must be a non-negative integer&quot;)

        self._skip_certs = skip_certs

    def __repr__(self):
        return &quot;&lt;InhibitAnyPolicy(skip_certs={0.skip_certs})&gt;&quot;.format(self)

    def __eq__(self, other):
        if not isinstance(other, InhibitAnyPolicy):
            return NotImplemented

        return self.skip_certs == other.skip_certs

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.skip_certs)

    skip_certs = utils.read_only_property(&quot;_skip_certs&quot;)


@utils.register_interface(ExtensionType)
class KeyUsage(object):
    oid = ExtensionOID.KEY_USAGE

    def __init__(
        self,
        digital_signature,
        content_commitment,
        key_encipherment,
        data_encipherment,
        key_agreement,
        key_cert_sign,
        crl_sign,
        encipher_only,
        decipher_only,
    ):
        if not key_agreement and (encipher_only or decipher_only):
            raise ValueError(
                &quot;encipher_only and decipher_only can only be true when &quot;
                &quot;key_agreement is true&quot;
            )

        self._digital_signature = digital_signature
        self._content_commitment = content_commitment
        self._key_encipherment = key_encipherment
        self._data_encipherment = data_encipherment
        self._key_agreement = key_agreement
        self._key_cert_sign = key_cert_sign
        self._crl_sign = crl_sign
        self._encipher_only = encipher_only
        self._decipher_only = decipher_only

    digital_signature = utils.read_only_property(&quot;_digital_signature&quot;)
    content_commitment = utils.read_only_property(&quot;_content_commitment&quot;)
    key_encipherment = utils.read_only_property(&quot;_key_encipherment&quot;)
    data_encipherment = utils.read_only_property(&quot;_data_encipherment&quot;)
    key_agreement = utils.read_only_property(&quot;_key_agreement&quot;)
    key_cert_sign = utils.read_only_property(&quot;_key_cert_sign&quot;)
    crl_sign = utils.read_only_property(&quot;_crl_sign&quot;)

    @property
    def encipher_only(self):
        if not self.key_agreement:
            raise ValueError(
                &quot;encipher_only is undefined unless key_agreement is true&quot;
            )
        else:
            return self._encipher_only

    @property
    def decipher_only(self):
        if not self.key_agreement:
            raise ValueError(
                &quot;decipher_only is undefined unless key_agreement is true&quot;
            )
        else:
            return self._decipher_only

    def __repr__(self):
        try:
            encipher_only = self.encipher_only
            decipher_only = self.decipher_only
        except ValueError:
            # Users found None confusing because even though encipher/decipher
            # have no meaning unless key_agreement is true, to construct an
            # instance of the class you still need to pass False.
            encipher_only = False
            decipher_only = False

        return (
            &quot;&lt;KeyUsage(digital_signature={0.digital_signature}, &quot;
            &quot;content_commitment={0.content_commitment}, &quot;
            &quot;key_encipherment={0.key_encipherment}, &quot;
            &quot;data_encipherment={0.data_encipherment}, &quot;
            &quot;key_agreement={0.key_agreement}, &quot;
            &quot;key_cert_sign={0.key_cert_sign}, crl_sign={0.crl_sign}, &quot;
            &quot;encipher_only={1}, decipher_only={2})&gt;&quot;
        ).format(self, encipher_only, decipher_only)

    def __eq__(self, other):
        if not isinstance(other, KeyUsage):
            return NotImplemented

        return (
            self.digital_signature == other.digital_signature
            and self.content_commitment == other.content_commitment
            and self.key_encipherment == other.key_encipherment
            and self.data_encipherment == other.data_encipherment
            and self.key_agreement == other.key_agreement
            and self.key_cert_sign == other.key_cert_sign
            and self.crl_sign == other.crl_sign
            and self._encipher_only == other._encipher_only
            and self._decipher_only == other._decipher_only
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(
            (
                self.digital_signature,
                self.content_commitment,
                self.key_encipherment,
                self.data_encipherment,
                self.key_agreement,
                self.key_cert_sign,
                self.crl_sign,
                self._encipher_only,
                self._decipher_only,
            )
        )


@utils.register_interface(ExtensionType)
class NameConstraints(object):
    oid = ExtensionOID.NAME_CONSTRAINTS

    def __init__(self, permitted_subtrees, excluded_subtrees):
        if permitted_subtrees is not None:
            permitted_subtrees = list(permitted_subtrees)
            if not all(isinstance(x, GeneralName) for x in permitted_subtrees):
                raise TypeError(
                    &quot;permitted_subtrees must be a list of GeneralName objects &quot;
                    &quot;or None&quot;
                )

            self._validate_ip_name(permitted_subtrees)

        if excluded_subtrees is not None:
            excluded_subtrees = list(excluded_subtrees)
            if not all(isinstance(x, GeneralName) for x in excluded_subtrees):
                raise TypeError(
                    &quot;excluded_subtrees must be a list of GeneralName objects &quot;
                    &quot;or None&quot;
                )

            self._validate_ip_name(excluded_subtrees)

        if permitted_subtrees is None and excluded_subtrees is None:
            raise ValueError(
                &quot;At least one of permitted_subtrees and excluded_subtrees &quot;
                &quot;must not be None&quot;
            )

        self._permitted_subtrees = permitted_subtrees
        self._excluded_subtrees = excluded_subtrees

    def __eq__(self, other):
        if not isinstance(other, NameConstraints):
            return NotImplemented

        return (
            self.excluded_subtrees == other.excluded_subtrees
            and self.permitted_subtrees == other.permitted_subtrees
        )

    def __ne__(self, other):
        return not self == other

    def _validate_ip_name(self, tree):
        if any(
            isinstance(name, IPAddress)
            and not isinstance(
                name.value, (ipaddress.IPv4Network, ipaddress.IPv6Network)
            )
            for name in tree
        ):
            raise TypeError(
                &quot;IPAddress name constraints must be an IPv4Network or&quot;
                &quot; IPv6Network object&quot;
            )

    def __repr__(self):
        return (
            u&quot;&lt;NameConstraints(permitted_subtrees={0.permitted_subtrees}, &quot;
            u&quot;excluded_subtrees={0.excluded_subtrees})&gt;&quot;.format(self)
        )

    def __hash__(self):
        if self.permitted_subtrees is not None:
            ps = tuple(self.permitted_subtrees)
        else:
            ps = None

        if self.excluded_subtrees is not None:
            es = tuple(self.excluded_subtrees)
        else:
            es = None

        return hash((ps, es))

    permitted_subtrees = utils.read_only_property(&quot;_permitted_subtrees&quot;)
    excluded_subtrees = utils.read_only_property(&quot;_excluded_subtrees&quot;)


class Extension(object):
    def __init__(self, oid, critical, value):
        if not isinstance(oid, ObjectIdentifier):
            raise TypeError(
                &quot;oid argument must be an ObjectIdentifier instance.&quot;
            )

        if not isinstance(critical, bool):
            raise TypeError(&quot;critical must be a boolean value&quot;)

        self._oid = oid
        self._critical = critical
        self._value = value

    oid = utils.read_only_property(&quot;_oid&quot;)
    critical = utils.read_only_property(&quot;_critical&quot;)
    value = utils.read_only_property(&quot;_value&quot;)

    def __repr__(self):
        return (
            &quot;&lt;Extension(oid={0.oid}, critical={0.critical}, &quot;
            &quot;value={0.value})&gt;&quot;
        ).format(self)

    def __eq__(self, other):
        if not isinstance(other, Extension):
            return NotImplemented

        return (
            self.oid == other.oid
            and self.critical == other.critical
            and self.value == other.value
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.oid, self.critical, self.value))


class GeneralNames(object):
    def __init__(self, general_names):
        general_names = list(general_names)
        if not all(isinstance(x, GeneralName) for x in general_names):
            raise TypeError(
                &quot;Every item in the general_names list must be an &quot;
                &quot;object conforming to the GeneralName interface&quot;
            )

        self._general_names = general_names

    __len__, __iter__, __getitem__ = _make_sequence_methods(&quot;_general_names&quot;)

    def get_values_for_type(self, type):
        # Return the value of each GeneralName, except for OtherName instances
        # which we return directly because it has two important properties not
        # just one value.
        objs = (i for i in self if isinstance(i, type))
        if type != OtherName:
            objs = (i.value for i in objs)
        return list(objs)

    def __repr__(self):
        return &quot;&lt;GeneralNames({})&gt;&quot;.format(self._general_names)

    def __eq__(self, other):
        if not isinstance(other, GeneralNames):
            return NotImplemented

        return self._general_names == other._general_names

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(tuple(self._general_names))


@utils.register_interface(ExtensionType)
class SubjectAlternativeName(object):
    oid = ExtensionOID.SUBJECT_ALTERNATIVE_NAME

    def __init__(self, general_names):
        self._general_names = GeneralNames(general_names)

    __len__, __iter__, __getitem__ = _make_sequence_methods(&quot;_general_names&quot;)

    def get_values_for_type(self, type):
        return self._general_names.get_values_for_type(type)

    def __repr__(self):
        return &quot;&lt;SubjectAlternativeName({})&gt;&quot;.format(self._general_names)

    def __eq__(self, other):
        if not isinstance(other, SubjectAlternativeName):
            return NotImplemented

        return self._general_names == other._general_names

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self._general_names)


@utils.register_interface(ExtensionType)
class IssuerAlternativeName(object):
    oid = ExtensionOID.ISSUER_ALTERNATIVE_NAME

    def __init__(self, general_names):
        self._general_names = GeneralNames(general_names)

    __len__, __iter__, __getitem__ = _make_sequence_methods(&quot;_general_names&quot;)

    def get_values_for_type(self, type):
        return self._general_names.get_values_for_type(type)

    def __repr__(self):
        return &quot;&lt;IssuerAlternativeName({})&gt;&quot;.format(self._general_names)

    def __eq__(self, other):
        if not isinstance(other, IssuerAlternativeName):
            return NotImplemented

        return self._general_names == other._general_names

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self._general_names)


@utils.register_interface(ExtensionType)
class CertificateIssuer(object):
    oid = CRLEntryExtensionOID.CERTIFICATE_ISSUER

    def __init__(self, general_names):
        self._general_names = GeneralNames(general_names)

    __len__, __iter__, __getitem__ = _make_sequence_methods(&quot;_general_names&quot;)

    def get_values_for_type(self, type):
        return self._general_names.get_values_for_type(type)

    def __repr__(self):
        return &quot;&lt;CertificateIssuer({})&gt;&quot;.format(self._general_names)

    def __eq__(self, other):
        if not isinstance(other, CertificateIssuer):
            return NotImplemented

        return self._general_names == other._general_names

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self._general_names)


@utils.register_interface(ExtensionType)
class CRLReason(object):
    oid = CRLEntryExtensionOID.CRL_REASON

    def __init__(self, reason):
        if not isinstance(reason, ReasonFlags):
            raise TypeError(&quot;reason must be an element from ReasonFlags&quot;)

        self._reason = reason

    def __repr__(self):
        return &quot;&lt;CRLReason(reason={})&gt;&quot;.format(self._reason)

    def __eq__(self, other):
        if not isinstance(other, CRLReason):
            return NotImplemented

        return self.reason == other.reason

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.reason)

    reason = utils.read_only_property(&quot;_reason&quot;)


@utils.register_interface(ExtensionType)
class InvalidityDate(object):
    oid = CRLEntryExtensionOID.INVALIDITY_DATE

    def __init__(self, invalidity_date):
        if not isinstance(invalidity_date, datetime.datetime):
            raise TypeError(&quot;invalidity_date must be a datetime.datetime&quot;)

        self._invalidity_date = invalidity_date

    def __repr__(self):
        return &quot;&lt;InvalidityDate(invalidity_date={})&gt;&quot;.format(
            self._invalidity_date
        )

    def __eq__(self, other):
        if not isinstance(other, InvalidityDate):
            return NotImplemented

        return self.invalidity_date == other.invalidity_date

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.invalidity_date)

    invalidity_date = utils.read_only_property(&quot;_invalidity_date&quot;)


@utils.register_interface(ExtensionType)
class PrecertificateSignedCertificateTimestamps(object):
    oid = ExtensionOID.PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS

    def __init__(self, signed_certificate_timestamps):
        signed_certificate_timestamps = list(signed_certificate_timestamps)
        if not all(
            isinstance(sct, SignedCertificateTimestamp)
            for sct in signed_certificate_timestamps
        ):
            raise TypeError(
                &quot;Every item in the signed_certificate_timestamps list must be &quot;
                &quot;a SignedCertificateTimestamp&quot;
            )
        self._signed_certificate_timestamps = signed_certificate_timestamps

    __len__, __iter__, __getitem__ = _make_sequence_methods(
        &quot;_signed_certificate_timestamps&quot;
    )

    def __repr__(self):
        return &quot;&lt;PrecertificateSignedCertificateTimestamps({})&gt;&quot;.format(
            list(self)
        )

    def __hash__(self):
        return hash(tuple(self._signed_certificate_timestamps))

    def __eq__(self, other):
        if not isinstance(other, PrecertificateSignedCertificateTimestamps):
            return NotImplemented

        return (
            self._signed_certificate_timestamps
            == other._signed_certificate_timestamps
        )

    def __ne__(self, other):
        return not self == other


@utils.register_interface(ExtensionType)
class SignedCertificateTimestamps(object):
    oid = ExtensionOID.SIGNED_CERTIFICATE_TIMESTAMPS

    def __init__(self, signed_certificate_timestamps):
        signed_certificate_timestamps = list(signed_certificate_timestamps)
        if not all(
            isinstance(sct, SignedCertificateTimestamp)
            for sct in signed_certificate_timestamps
        ):
            raise TypeError(
                &quot;Every item in the signed_certificate_timestamps list must be &quot;
                &quot;a SignedCertificateTimestamp&quot;
            )
        self._signed_certificate_timestamps = signed_certificate_timestamps

    __len__, __iter__, __getitem__ = _make_sequence_methods(
        &quot;_signed_certificate_timestamps&quot;
    )

    def __repr__(self):
        return &quot;&lt;SignedCertificateTimestamps({})&gt;&quot;.format(list(self))

    def __hash__(self):
        return hash(tuple(self._signed_certificate_timestamps))

    def __eq__(self, other):
        if not isinstance(other, SignedCertificateTimestamps):
            return NotImplemented

        return (
            self._signed_certificate_timestamps
            == other._signed_certificate_timestamps
        )

    def __ne__(self, other):
        return not self == other


@utils.register_interface(ExtensionType)
class OCSPNonce(object):
    oid = OCSPExtensionOID.NONCE

    def __init__(self, nonce):
        if not isinstance(nonce, bytes):
            raise TypeError(&quot;nonce must be bytes&quot;)

        self._nonce = nonce

    def __eq__(self, other):
        if not isinstance(other, OCSPNonce):
            return NotImplemented

        return self.nonce == other.nonce

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(self.nonce)

    def __repr__(self):
        return &quot;&lt;OCSPNonce(nonce={0.nonce!r})&gt;&quot;.format(self)

    nonce = utils.read_only_property(&quot;_nonce&quot;)


@utils.register_interface(ExtensionType)
class IssuingDistributionPoint(object):
    oid = ExtensionOID.ISSUING_DISTRIBUTION_POINT

    def __init__(
        self,
        full_name,
        relative_name,
        only_contains_user_certs,
        only_contains_ca_certs,
        only_some_reasons,
        indirect_crl,
        only_contains_attribute_certs,
    ):
        if only_some_reasons and (
            not isinstance(only_some_reasons, frozenset)
            or not all(isinstance(x, ReasonFlags) for x in only_some_reasons)
        ):
            raise TypeError(
                &quot;only_some_reasons must be None or frozenset of ReasonFlags&quot;
            )

        if only_some_reasons and (
            ReasonFlags.unspecified in only_some_reasons
            or ReasonFlags.remove_from_crl in only_some_reasons
        ):
            raise ValueError(
                &quot;unspecified and remove_from_crl are not valid reasons in an &quot;
                &quot;IssuingDistributionPoint&quot;
            )

        if not (
            isinstance(only_contains_user_certs, bool)
            and isinstance(only_contains_ca_certs, bool)
            and isinstance(indirect_crl, bool)
            and isinstance(only_contains_attribute_certs, bool)
        ):
            raise TypeError(
                &quot;only_contains_user_certs, only_contains_ca_certs, &quot;
                &quot;indirect_crl and only_contains_attribute_certs &quot;
                &quot;must all be boolean.&quot;
            )

        crl_constraints = [
            only_contains_user_certs,
            only_contains_ca_certs,
            indirect_crl,
            only_contains_attribute_certs,
        ]

        if len([x for x in crl_constraints if x]) &gt; 1:
            raise ValueError(
                &quot;Only one of the following can be set to True: &quot;
                &quot;only_contains_user_certs, only_contains_ca_certs, &quot;
                &quot;indirect_crl, only_contains_attribute_certs&quot;
            )

        if not any(
            [
                only_contains_user_certs,
                only_contains_ca_certs,
                indirect_crl,
                only_contains_attribute_certs,
                full_name,
                relative_name,
                only_some_reasons,
            ]
        ):
            raise ValueError(
                &quot;Cannot create empty extension: &quot;
                &quot;if only_contains_user_certs, only_contains_ca_certs, &quot;
                &quot;indirect_crl, and only_contains_attribute_certs are all False&quot;
                &quot;, then either full_name, relative_name, or only_some_reasons &quot;
                &quot;must have a value.&quot;
            )

        self._only_contains_user_certs = only_contains_user_certs
        self._only_contains_ca_certs = only_contains_ca_certs
        self._indirect_crl = indirect_crl
        self._only_contains_attribute_certs = only_contains_attribute_certs
        self._only_some_reasons = only_some_reasons
        self._full_name = full_name
        self._relative_name = relative_name

    def __repr__(self):
        return (
            &quot;&lt;IssuingDistributionPoint(full_name={0.full_name}, &quot;
            &quot;relative_name={0.relative_name}, &quot;
            &quot;only_contains_user_certs={0.only_contains_user_certs}, &quot;
            &quot;only_contains_ca_certs={0.only_contains_ca_certs}, &quot;
            &quot;only_some_reasons={0.only_some_reasons}, &quot;
            &quot;indirect_crl={0.indirect_crl}, &quot;
            &quot;only_contains_attribute_certs=&quot;
            &quot;{0.only_contains_attribute_certs})&gt;&quot;.format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, IssuingDistributionPoint):
            return NotImplemented

        return (
            self.full_name == other.full_name
            and self.relative_name == other.relative_name
            and self.only_contains_user_certs == other.only_contains_user_certs
            and self.only_contains_ca_certs == other.only_contains_ca_certs
            and self.only_some_reasons == other.only_some_reasons
            and self.indirect_crl == other.indirect_crl
            and self.only_contains_attribute_certs
            == other.only_contains_attribute_certs
        )

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash(
            (
                self.full_name,
                self.relative_name,
                self.only_contains_user_certs,
                self.only_contains_ca_certs,
                self.only_some_reasons,
                self.indirect_crl,
                self.only_contains_attribute_certs,
            )
        )

    full_name = utils.read_only_property(&quot;_full_name&quot;)
    relative_name = utils.read_only_property(&quot;_relative_name&quot;)
    only_contains_user_certs = utils.read_only_property(
        &quot;_only_contains_user_certs&quot;
    )
    only_contains_ca_certs = utils.read_only_property(
        &quot;_only_contains_ca_certs&quot;
    )
    only_some_reasons = utils.read_only_property(&quot;_only_some_reasons&quot;)
    indirect_crl = utils.read_only_property(&quot;_indirect_crl&quot;)
    only_contains_attribute_certs = utils.read_only_property(
        &quot;_only_contains_attribute_certs&quot;
    )


@utils.register_interface(ExtensionType)
class UnrecognizedExtension(object):
    def __init__(self, oid, value):
        if not isinstance(oid, ObjectIdentifier):
            raise TypeError(&quot;oid must be an ObjectIdentifier&quot;)
        self._oid = oid
        self._value = value

    oid = utils.read_only_property(&quot;_oid&quot;)
    value = utils.read_only_property(&quot;_value&quot;)

    def __repr__(self):
        return (
            &quot;&lt;UnrecognizedExtension(oid={0.oid}, &quot;
            &quot;value={0.value!r})&gt;&quot;.format(self)
        )

    def __eq__(self, other):
        if not isinstance(other, UnrecognizedExtension):
            return NotImplemented

        return self.oid == other.oid and self.value == other.value

    def __ne__(self, other):
        return not self == other

    def __hash__(self):
        return hash((self.oid, self.value))
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib64%2Fpython3.6%2Fsite-packages%2Fcryptography%2Fx509'>Back to Directory</a>