pyasn1-alt-modules 0.4.5__py3-none-any.whl

pyasn1_alt_modules/rfc5697.py

@@ -0,0 +1,64 @@
+# This file is part of pyasn1-alt-modules software.
+#
+# Created by Russ Housley.
+# Modified by Russ Housley to import SCVP-related structures from RFC 5055,
+#   which did not exist at the time this module was first written.  Also,
+#   include the opentypemap manager.
+#
+# Copyright (c) 2019-2024, Vigil Security, LLC
+# License: http://vigilsec.com/pyasn1-alt-modules-license.txt
+#
+# Other Certificates Extension
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5697.txt
+
+from pyasn1.type import namedtype
+from pyasn1.type import univ
+
+from pyasn1_alt_modules import rfc5280
+from pyasn1_alt_modules import rfc4055
+from pyasn1_alt_modules import rfc5055
+from pyasn1_alt_modules import opentypemap
+
+certificateExtensionsMap = opentypemap.get('certificateExtensionsMap')
+
+
+# Imports from RFC 5280
+
+AlgorithmIdentifier = rfc5280.AlgorithmIdentifier
+
+CertificateSerialNumber = rfc5280.CertificateSerialNumber
+
+GeneralNames = rfc5280.GeneralNames
+
+
+# Imports from RFC 4055
+
+id_sha1 = rfc4055.id_sha1
+
+
+# Imports from RFC 5055
+
+SCVPIssuerSerial = rfc5055.SCVPIssuerSerial
+
+sha1_alg_id = rfc5055.algid_SHA1
+
+SCVPCertID = rfc5055.SCVPCertID
+
+
+# Other Certificates Extension
+
+id_pe_otherCerts = univ.ObjectIdentifier((1, 3, 6, 1, 5, 5, 7, 1, 19,))
+
+class OtherCertificates(univ.SequenceOf):
+    componentType = SCVPCertID()
+
+
+# Update the Certificate Extension Map
+
+_certificateExtensionsMapUpdate = {
+    id_pe_otherCerts: OtherCertificates(),
+}
+
+certificateExtensionsMap.update(_certificateExtensionsMapUpdate)

pyasn1_alt_modules/rfc5698.py

@@ -0,0 +1,159 @@
+# This file is part of pyasn1-alt-modules software.
+#
+# Created by Russ Housley with assistance from asn1ate v.0.6.0.
+#
+# Copyright (c) 2022-2024, Vigil Security, LLC
+# License: http://vigilsec.com/pyasn1-alt-modules-license.txt
+#
+# Data Structure for the Security Suitability of Cryptographic Algorithms
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5698.txt
+# https://www.rfc-editor.org/errata/eid6948
+
+from pyasn1.type import char
+from pyasn1.type import namedtype
+from pyasn1.type import namedval
+from pyasn1.type import opentype
+from pyasn1.type import tag
+from pyasn1.type import univ
+from pyasn1.type import useful
+
+from pyasn1_alt_modules import rfc5652
+from pyasn1_alt_modules import opentypemap
+
+cmsContentTypesMap = opentypemap.get('cmsContentTypesMap')
+
+dsscExtensionsMap = opentypemap.get('dsscExtensionsMap')
+
+
+# Import from RFC 5652
+
+ContentInfo = rfc5652.ContentInfo
+
+
+# DSSC
+
+class AlgID(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('name', char.UTF8String()),
+        namedtype.NamedType('oid', univ.SequenceOf(
+            componentType=univ.ObjectIdentifier()).subtype(implicitTag=tag.Tag(
+                tag.tagClassContext, tag.tagFormatSimple, 0))),
+        namedtype.OptionalNamedType('uri', univ.SequenceOf(
+            componentType=char.IA5String()).subtype(implicitTag=tag.Tag(
+                tag.tagClassContext, tag.tagFormatSimple, 1)))
+    )
+
+
+class Extension(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('extensionType', univ.ObjectIdentifier()),
+        namedtype.NamedType('extension', univ.Any(),
+            openType=opentype.OpenType('extensionType', dsscExtensionsMap)
+        )
+    )
+
+
+class Parameter(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('name', char.UTF8String()),
+        namedtype.OptionalNamedType('min', univ.Integer().subtype(
+            implicitTag=tag.Tag(tag.tagClassContext,
+                tag.tagFormatSimple, 0))),
+        namedtype.OptionalNamedType('max', univ.Integer().subtype(
+            implicitTag=tag.Tag(tag.tagClassContext,
+                tag.tagFormatSimple, 1))),
+        namedtype.OptionalNamedType('other', Extension().subtype(
+            implicitTag=tag.Tag(tag.tagClassContext,
+                tag.tagFormatConstructed, 2)))
+    )
+
+
+class Validity(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.OptionalNamedType('start', useful.GeneralizedTime().subtype(
+            implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+        namedtype.OptionalNamedType('end', useful.GeneralizedTime().subtype(
+            implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1)))
+    )
+
+
+class Evaluation(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.OptionalNamedType('parameters', univ.SequenceOf(
+            componentType=Parameter()).subtype(implicitTag=tag.Tag(
+                tag.tagClassContext, tag.tagFormatSimple, 0))),
+        namedtype.NamedType('validity',
+            Validity().subtype(implicitTag=tag.Tag(
+                tag.tagClassContext, tag.tagFormatConstructed, 1))),
+        namedtype.OptionalNamedType('other',
+            Extension().subtype(implicitTag=tag.Tag(
+                tag.tagClassContext, tag.tagFormatConstructed, 2)))
+    )
+
+
+class Algorithm(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('algorithmIdentifier', AlgID()),
+        namedtype.NamedType('evaluations',
+            univ.SequenceOf(componentType=Evaluation())),
+        namedtype.OptionalNamedType('information', univ.SequenceOf(
+            componentType=char.UTF8String()).subtype(implicitTag=tag.Tag(
+                tag.tagClassContext, tag.tagFormatSimple, 0))),
+        namedtype.OptionalNamedType('other', Extension().subtype(
+            implicitTag=tag.Tag(tag.tagClassContext,
+                tag.tagFormatConstructed, 1)))
+    )
+
+
+class PolicyName(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('name', char.UTF8String()),
+        namedtype.OptionalNamedType('oid', univ.ObjectIdentifier()),
+        namedtype.OptionalNamedType('uri', char.IA5String())
+    )
+
+
+class Publisher(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('name', char.UTF8String()),
+        namedtype.OptionalNamedType('address',
+            char.UTF8String().subtype(implicitTag=tag.Tag(
+                tag.tagClassContext, tag.tagFormatSimple, 0))),
+        namedtype.OptionalNamedType('uri',
+            char.IA5String().subtype(implicitTag=tag.Tag(
+                tag.tagClassContext, tag.tagFormatSimple, 1)))
+    )
+
+
+class SecuritySuitabilityPolicy(ContentInfo):
+    pass
+
+
+class TBSPolicy(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.DefaultedNamedType('version', univ.Integer(
+            namedValues=namedval.NamedValues(('v1', 1))).subtype(value='v1')),
+        namedtype.DefaultedNamedType('language',
+            char.UTF8String().subtype(value='en')),
+        namedtype.NamedType('policyName', PolicyName()),
+        namedtype.NamedType('publisher', Publisher()),
+        namedtype.NamedType('policyIssueDate', useful.GeneralizedTime()),
+        namedtype.OptionalNamedType('nextUpdate', useful.GeneralizedTime()),
+        namedtype.OptionalNamedType('usage', char.UTF8String()),
+        namedtype.NamedType('algorithms',
+            univ.SequenceOf(componentType=Algorithm()))
+    )
+
+
+id_ct_dssc = univ.ObjectIdentifier((1, 3, 6, 1, 5, 5, 11, 1, 6))
+
+
+# Update the CMS Content Type Map
+
+_cmsContentTypesMapUpdate = {
+    id_ct_dssc: TBSPolicy(),
+}
+
+cmsContentTypesMap.update(_cmsContentTypesMapUpdate)

pyasn1_alt_modules/rfc5751.py

@@ -0,0 +1,127 @@
+# This file is part of pyasn1-alt-modules software.
+#
+# Created by Russ Housley with assistance from asn1ate v.0.6.0.
+# Modified by Russ Housley to include the opentypemap manager.
+#
+# Copyright (c) 2019-2024, Vigil Security, LLC
+# License: http://vigilsec.com/pyasn1-alt-modules-license.txt
+#
+# S/MIME Version 3.2 Message Specification
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5751.txt
+
+from pyasn1.type import namedtype
+from pyasn1.type import opentype
+from pyasn1.type import tag
+from pyasn1.type import univ
+
+from pyasn1_alt_modules import rfc5652
+from pyasn1_alt_modules import rfc8018
+from pyasn1_alt_modules import opentypemap
+
+smimeCapabilityMap = opentypemap.get('smimeCapabilityMap')
+
+cmsAttributesMap = opentypemap.get('cmsAttributesMap')
+
+
+def _OID(*components):
+    output = []
+    for x in tuple(components):
+        if isinstance(x, univ.ObjectIdentifier):
+            output.extend(list(x))
+        else:
+            output.append(int(x))
+    return univ.ObjectIdentifier(output)
+
+
+# Imports from RFC 5652 and RFC 8018
+
+IssuerAndSerialNumber = rfc5652.IssuerAndSerialNumber
+
+RecipientKeyIdentifier = rfc5652.RecipientKeyIdentifier
+
+SubjectKeyIdentifier = rfc5652.SubjectKeyIdentifier
+
+rc2CBC = rfc8018.rc2CBC
+
+
+# S/MIME Capabilities Attribute
+
+smimeCapabilities = univ.ObjectIdentifier('1.2.840.113549.1.9.15')
+
+
+class SMIMECapability(univ.Sequence):
+    pass
+
+SMIMECapability.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('capabilityID', univ.ObjectIdentifier()),
+    namedtype.OptionalNamedType('parameters', univ.Any(),
+        openType=opentype.OpenType('capabilityID', smimeCapabilityMap))
+)
+
+
+class SMIMECapabilities(univ.SequenceOf):
+    pass
+
+SMIMECapabilities.componentType = SMIMECapability()
+
+
+class SMIMECapabilitiesParametersForRC2CBC(univ.Integer):
+    # which carries the RC2 Key Length (number of bits)
+    pass
+
+
+# S/MIME Encryption Key Preference Attribute
+
+id_smime = univ.ObjectIdentifier('1.2.840.113549.1.9.16')
+
+id_aa = _OID(id_smime, 2)
+
+id_aa_encrypKeyPref = _OID(id_aa, 11)
+
+
+class SMIMEEncryptionKeyPreference(univ.Choice):
+    pass
+
+SMIMEEncryptionKeyPreference.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('issuerAndSerialNumber',
+        IssuerAndSerialNumber().subtype(implicitTag=tag.Tag(
+            tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.NamedType('receipentKeyId',
+        # Yes, 'receipentKeyId' is spelled incorrectly, but kept
+        # this way for alignment with the ASN.1 module in the RFC.
+        RecipientKeyIdentifier().subtype(implicitTag=tag.Tag(
+            tag.tagClassContext, tag.tagFormatSimple, 1))),
+    namedtype.NamedType('subjectAltKeyIdentifier',
+        SubjectKeyIdentifier().subtype(implicitTag=tag.Tag(
+            tag.tagClassContext, tag.tagFormatSimple, 2)))
+)
+
+
+# The Prefer Binary Inside SMIMECapabilities attribute
+
+id_cap = _OID(id_smime, 11)
+
+id_cap_preferBinaryInside = _OID(id_cap, 1)
+
+
+# CMS Attribute Map
+
+_cmsAttributesMapUpdate = {
+    smimeCapabilities: SMIMECapabilities(),
+    id_aa_encrypKeyPref: SMIMEEncryptionKeyPreference(),
+}
+
+cmsAttributesMap.update(_cmsAttributesMapUpdate)
+
+
+# SMIMECapabilities Attribute Map
+#
+# Do not include OIDs in the dictionary when the parameters are absent.
+
+_smimeCapabilityMapUpdate = {
+    rc2CBC: SMIMECapabilitiesParametersForRC2CBC(),
+}
+
+smimeCapabilityMap.update(_smimeCapabilityMapUpdate)

pyasn1_alt_modules/rfc5752.py

@@ -0,0 +1,52 @@
+#
+# This file is part of pyasn1-alt-modules software.
+#
+# Created by Russ Housley with assistance from asn1ate v.0.6.0.
+# Modified by Russ Housley to include the opentypemap manager.
+#
+# Copyright (c) 2019-2024, Vigil Security, LLC
+# License: http://vigilsec.com/pyasn1-alt-modules-license.txt
+#
+# Multiple Signatures in Cryptographic Message Syntax (CMS)
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5752.txt
+# https://www.rfc-editor.org/errata/eid4444
+#
+
+from pyasn1.type import namedtype
+from pyasn1.type import univ
+
+from pyasn1_alt_modules import rfc5035
+from pyasn1_alt_modules import rfc5652
+from pyasn1_alt_modules import opentypemap
+
+cmsAttributesMap = opentypemap.get('cmsAttributesMap')
+
+
+class SignAttrsHash(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('algID', rfc5652.DigestAlgorithmIdentifier()),
+        namedtype.NamedType('hash', univ.OctetString())
+    )
+
+
+class MultipleSignatures(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('bodyHashAlg', rfc5652.DigestAlgorithmIdentifier()),
+        namedtype.NamedType('signAlg', rfc5652.SignatureAlgorithmIdentifier()),
+        namedtype.NamedType('signAttrsHash', SignAttrsHash()),
+        namedtype.OptionalNamedType('cert', rfc5035.ESSCertIDv2())
+    )
+
+
+id_aa_multipleSignatures = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.51')
+
+
+# Update the CMS Attribute Types Map
+
+_cmsAttributesMapUpdate = {
+    id_aa_multipleSignatures: MultipleSignatures(),
+}
+
+cmsAttributesMap.update(_cmsAttributesMapUpdate)

pyasn1_alt_modules/rfc5753.py

@@ -0,0 +1,163 @@
+#
+# This file is part of pyasn1-alt-modules software.
+#
+# Created by Russ Housley with assistance from asn1ate v.0.6.0.
+# Modified by Russ Housley to include the opentypemap manager.
+#
+# Copyright (c) 2019-2024, Vigil Security, LLC
+# License: http://vigilsec.com/pyasn1-alt-modules-license.txt
+#
+# Elliptic Curve Cryptography (ECC) Algorithms in the CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5753.txt
+#
+
+from pyasn1.type import namedtype
+from pyasn1.type import tag
+from pyasn1.type import univ
+
+from pyasn1_alt_modules import rfc5280
+from pyasn1_alt_modules import rfc5480
+from pyasn1_alt_modules import rfc5652
+from pyasn1_alt_modules import rfc8018
+from pyasn1_alt_modules import opentypemap
+
+algorithmIdentifierMap = opentypemap.get('algorithmIdentifierMap')
+
+smimeCapabilityMap = opentypemap.get('smimeCapabilityMap')
+
+
+# Imports from RFC 5280
+
+AlgorithmIdentifier = rfc5280.AlgorithmIdentifier
+
+
+# Imports from RFC 5652
+
+OriginatorPublicKey = rfc5652.OriginatorPublicKey
+
+UserKeyingMaterial = rfc5652.UserKeyingMaterial
+
+
+# Imports from RFC 5480
+
+ECDSA_Sig_Value = rfc5480.ECDSA_Sig_Value
+
+ECParameters = rfc5480.ECParameters
+
+ECPoint = rfc5480.ECPoint
+
+id_ecPublicKey = rfc5480.id_ecPublicKey
+
+
+# Imports from RFC 8018
+
+id_hmacWithSHA224 = rfc8018.id_hmacWithSHA224
+
+id_hmacWithSHA256 = rfc8018.id_hmacWithSHA256
+
+id_hmacWithSHA384 = rfc8018.id_hmacWithSHA384
+
+id_hmacWithSHA512 = rfc8018.id_hmacWithSHA512
+
+
+# Object Identifier arcs
+
+x9_63_scheme = univ.ObjectIdentifier('1.3.133.16.840.63.0')
+
+secg_scheme = univ.ObjectIdentifier('1.3.132.1')
+
+
+# Object Identifiers for the algorithms
+
+dhSinglePass_cofactorDH_sha1kdf_scheme = x9_63_scheme + (3, )
+
+dhSinglePass_cofactorDH_sha224kdf_scheme = secg_scheme + (14, 0, )
+
+dhSinglePass_cofactorDH_sha256kdf_scheme = secg_scheme + (14, 1, )
+
+dhSinglePass_cofactorDH_sha384kdf_scheme = secg_scheme + (14, 2, )
+
+dhSinglePass_cofactorDH_sha512kdf_scheme = secg_scheme + (14, 3, )
+
+dhSinglePass_stdDH_sha1kdf_scheme = x9_63_scheme + (2, )
+
+dhSinglePass_stdDH_sha224kdf_scheme = secg_scheme + (11, 0, )
+
+dhSinglePass_stdDH_sha256kdf_scheme = secg_scheme + (11, 1, )
+
+dhSinglePass_stdDH_sha384kdf_scheme = secg_scheme + (11, 2, )
+
+dhSinglePass_stdDH_sha512kdf_scheme = secg_scheme + (11, 3, )
+
+mqvSinglePass_sha1kdf_scheme = x9_63_scheme + (16, )
+
+mqvSinglePass_sha224kdf_scheme = secg_scheme + (15, 0, )
+
+mqvSinglePass_sha256kdf_scheme = secg_scheme + (15, 1, )
+
+mqvSinglePass_sha384kdf_scheme = secg_scheme + (15, 2, )
+
+mqvSinglePass_sha512kdf_scheme = secg_scheme + (15, 3, )
+
+
+# Structures for parameters and key derivation
+
+class IV(univ.OctetString):
+    # Exactly 8 octets
+    pass
+
+
+class CBCParameter(IV):
+    pass
+
+
+class KeyWrapAlgorithm(AlgorithmIdentifier):
+    pass
+
+
+class ECC_CMS_SharedInfo(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('keyInfo', KeyWrapAlgorithm()),
+        namedtype.OptionalNamedType('entityUInfo',
+            univ.OctetString().subtype(explicitTag=tag.Tag(
+                tag.tagClassContext, tag.tagFormatSimple, 0))),
+        namedtype.NamedType('suppPubInfo',
+            univ.OctetString().subtype(explicitTag=tag.Tag(
+                tag.tagClassContext, tag.tagFormatSimple, 2)))
+    )
+
+
+class MQVuserKeyingMaterial(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('ephemeralPublicKey', OriginatorPublicKey()),
+        namedtype.OptionalNamedType('addedukm',
+            UserKeyingMaterial().subtype(explicitTag=tag.Tag(
+                tag.tagClassContext, tag.tagFormatSimple, 0)))
+    )
+
+
+# Update the Algorithm Identifiers Map and S/MIME Capability Map
+
+_algorithmIdentifierMapUpdate = {
+    dhSinglePass_stdDH_sha1kdf_scheme: KeyWrapAlgorithm(),
+    dhSinglePass_stdDH_sha224kdf_scheme: KeyWrapAlgorithm(),
+    dhSinglePass_stdDH_sha256kdf_scheme: KeyWrapAlgorithm(),
+    dhSinglePass_stdDH_sha384kdf_scheme: KeyWrapAlgorithm(),
+    dhSinglePass_stdDH_sha512kdf_scheme: KeyWrapAlgorithm(),
+    dhSinglePass_cofactorDH_sha1kdf_scheme: KeyWrapAlgorithm(),
+    dhSinglePass_cofactorDH_sha224kdf_scheme: KeyWrapAlgorithm(),
+    dhSinglePass_cofactorDH_sha256kdf_scheme: KeyWrapAlgorithm(),
+    dhSinglePass_cofactorDH_sha384kdf_scheme: KeyWrapAlgorithm(),
+    dhSinglePass_cofactorDH_sha512kdf_scheme: KeyWrapAlgorithm(),
+    mqvSinglePass_sha1kdf_scheme: KeyWrapAlgorithm(),
+    mqvSinglePass_sha224kdf_scheme: KeyWrapAlgorithm(),
+    mqvSinglePass_sha256kdf_scheme: KeyWrapAlgorithm(),
+    mqvSinglePass_sha384kdf_scheme: KeyWrapAlgorithm(),
+    mqvSinglePass_sha512kdf_scheme: KeyWrapAlgorithm(),
+}
+
+algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)
+
+smimeCapabilityMap.update(_algorithmIdentifierMapUpdate)