Hello community,
here is the log from the commit of package python-pyasn1-modules for
openSUSE:Factory checked in at 2019-05-27 08:37:33
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-pyasn1-modules (Old)
and /work/SRC/openSUSE:Factory/.python-pyasn1-modules.new.5148 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-pyasn1-modules"
Mon May 27 08:37:33 2019 rev:23 rq:705395 version:0.2.5
Changes:
--------
---
/work/SRC/openSUSE:Factory/python-pyasn1-modules/python-pyasn1-modules.changes
2019-02-02 21:45:26.836178420 +0100
+++
/work/SRC/openSUSE:Factory/.python-pyasn1-modules.new.5148/python-pyasn1-modules.changes
2019-05-27 08:37:34.751089831 +0200
@@ -1,0 +2,20 @@
+Sat May 25 09:39:16 UTC 2019 - Tomáš Chvátal <[email protected]>
+
+- Update to 0.2.5:
+ - Added RFC3560 providing RSAES-OAEP Key Transport Algorithm
+ in CMS
+ - Added RFC6019 providing BinaryTime - an alternate format
+ for representing Date and Time
+ - RFC3565 superseded by RFC5649
+ - Added RFC5480 providng Elliptic Curve Cryptography Subject
+ Public Key Information
+ - Added RFC8520 providing X.509 Extensions for MUD URL and
+ MUD Signer
+ - Added RFC3161 providing Time-Stamp Protocol support
+ - Added RFC3709 providing Logotypes in X.509 Certificates
+ - Added RFC3274 providing CMS Compressed Data Content Type
+ - Added RFC4073 providing Multiple Contents protection
+ with CMS
+- Execute testsuite
+
+-------------------------------------------------------------------
Old:
----
pyasn1-modules-0.2.4.tar.gz
New:
----
pyasn1-modules-0.2.5.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-pyasn1-modules.spec ++++++
--- /var/tmp/diff_new_pack.33dpmN/_old 2019-05-27 08:37:35.275089627 +0200
+++ /var/tmp/diff_new_pack.33dpmN/_new 2019-05-27 08:37:35.287089622 +0200
@@ -1,7 +1,7 @@
#
# spec file for package python-pyasn1-modules
#
-# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany.
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -12,25 +12,26 @@
# license that conforms to the Open Source Definition (Version 1.9)
# published by the Open Source Initiative.
-# Please submit bugfixes or comments via http://bugs.opensuse.org/
+# Please submit bugfixes or comments via https://bugs.opensuse.org/
#
%{?!python_module:%define python_module() python-%{**} python3-%{**}}
Name: python-pyasn1-modules
-Version: 0.2.4
+Version: 0.2.5
Release: 0
-Url: https://github.com/etingof/pyasn1-modules
Summary: Collection of protocols modules written in ASN.1 language
License: BSD-3-Clause
Group: Development/Languages/Python
-Source:
https://pypi.io/packages/source/p/pyasn1-modules/pyasn1-modules-%{version}.tar.gz
-BuildRoot: %{_tmppath}/%{name}-%{version}-build
+URL: https://github.com/etingof/pyasn1-modules
+Source:
https://files.pythonhosted.org/packages/source/p/pyasn1-modules/pyasn1-modules-%{version}.tar.gz
+BuildRequires: %{python_module pyasn1 >= 0.3.4}
+BuildRequires: %{python_module pytest}
BuildRequires: %{python_module setuptools}
+BuildRequires: fdupes
BuildRequires: python-rpm-macros
Requires: python-pyasn1 >= 0.3.4
BuildArch: noarch
-
%python_subpackages
%description
@@ -47,10 +48,14 @@
%install
%python_install
+%python_expand %fdupes %{buildroot}%{$python_sitelib}
+
+%check
+%pytest
-%files %python_files
-%defattr(-,root,root,-)
-%doc CHANGES.txt LICENSE.txt README.md
+%files %{python_files}
+%license LICENSE.txt
+%doc CHANGES.txt README.md
%{python_sitelib}/*
%changelog
++++++ pyasn1-modules-0.2.4.tar.gz -> pyasn1-modules-0.2.5.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/CHANGES.txt
new/pyasn1-modules-0.2.5/CHANGES.txt
--- old/pyasn1-modules-0.2.4/CHANGES.txt 2019-01-26 18:53:16.000000000
+0100
+++ new/pyasn1-modules-0.2.5/CHANGES.txt 2019-04-24 06:40:45.000000000
+0200
@@ -1,4 +1,24 @@
+Revision 0.2.5, released 24-04-2019
+-----------------------------------
+
+- Added module RFC5958 providing Asymmetric Key Packages,
+ which is essentially version 2 of the PrivateKeyInfo
+ structure in PKCS#8 in RFC 5208
+- Added module RFC8410 providing algorithm Identifiers for
+ Ed25519, Ed448, X25519, and X448
+- Added module RFC8418 providing Elliptic Curve Diffie-Hellman
+ (ECDH) Key Agreement Algorithm with X25519 and X448
+- Added module RFC3565 providing Elliptic Curve Diffie-Hellman
+ Key Agreement Algorithm use with X25519 and X448 in the
+ Cryptographic Message Syntax (CMS)
+- Added module RFC4108 providing CMS Firmware Wrapper
+- Added module RFC3779 providing X.509 Extensions for IP
+ Addresses and AS Identifiers
+- Added module RFC4055 providing additional Algorithms and
+ Identifiers for RSA Cryptography for use in Certificates
+ and CRLs
+
Revision 0.2.4, released 26-01-2018
-----------------------------------
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/PKG-INFO
new/pyasn1-modules-0.2.5/PKG-INFO
--- old/pyasn1-modules-0.2.4/PKG-INFO 2019-01-26 18:54:25.000000000 +0100
+++ new/pyasn1-modules-0.2.5/PKG-INFO 2019-04-24 06:42:13.000000000 +0200
@@ -1,6 +1,6 @@
Metadata-Version: 1.1
Name: pyasn1-modules
-Version: 0.2.4
+Version: 0.2.5
Summary: A collection of ASN.1-based protocols modules.
Home-page: https://github.com/etingof/pyasn1-modules
Author: Ilya Etingof <[email protected]>
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/pyasn1_modules/__init__.py
new/pyasn1-modules-0.2.5/pyasn1_modules/__init__.py
--- old/pyasn1-modules-0.2.4/pyasn1_modules/__init__.py 2019-01-26
18:53:16.000000000 +0100
+++ new/pyasn1-modules-0.2.5/pyasn1_modules/__init__.py 2019-04-24
06:40:45.000000000 +0200
@@ -1,2 +1,2 @@
# http://www.python.org/dev/peps/pep-0396/
-__version__ = '0.2.4'
+__version__ = '0.2.5'
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/pyasn1_modules/rfc3565.py
new/pyasn1-modules-0.2.5/pyasn1_modules/rfc3565.py
--- old/pyasn1-modules-0.2.4/pyasn1_modules/rfc3565.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/pyasn1_modules/rfc3565.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,41 @@
+# This file is being contributed to pyasn1-modules software.
+#
+# Created by Russ Housley.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Use of the Elliptic Curve Diffie-Hellman Key Agreement Algorithm
+# with X25519 and X448 in the Cryptographic Message Syntax (CMS)
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc3565.txt
+
+
+from pyasn1.type import univ, constraint
+
+from pyasn1_modules import rfc5280
+
+
+class AlgorithmIdentifier(rfc5280.AlgorithmIdentifier):
+ pass
+
+
+class AES_IV(univ.OctetString):
+ pass
+
+AES_IV.subtypeSpec = constraint.ValueSizeConstraint(16, 16)
+
+
+id_aes128_CBC = univ.ObjectIdentifier('2.16.840.1.101.3.4.1.2')
+
+id_aes192_CBC = univ.ObjectIdentifier('2.16.840.1.101.3.4.1.22')
+
+id_aes256_CBC = univ.ObjectIdentifier('2.16.840.1.101.3.4.1.42')
+
+
+id_aes128_wrap = univ.ObjectIdentifier('2.16.840.1.101.3.4.1.5')
+
+id_aes192_wrap = univ.ObjectIdentifier('2.16.840.1.101.3.4.1.25')
+
+id_aes256_wrap = univ.ObjectIdentifier('2.16.840.1.101.3.4.1.45')
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/pyasn1_modules/rfc3779.py
new/pyasn1-modules-0.2.5/pyasn1_modules/rfc3779.py
--- old/pyasn1-modules-0.2.4/pyasn1_modules/rfc3779.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/pyasn1_modules/rfc3779.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,112 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley with assistance from asn1ate v.0.6.0.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# X.509 Extensions for IP Addresses and AS Identifiers
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc3779.txt
+#
+
+
+from pyasn1.type import univ, char, namedtype, namedval, tag, constraint,
useful
+
+
+# IP Address Delegation Extension
+
+id_pe_ipAddrBlocks = univ.ObjectIdentifier('1.3.6.1.5.5.7.1.7')
+
+
+class IPAddress(univ.BitString):
+ pass
+
+
+class IPAddressRange(univ.Sequence):
+ pass
+
+IPAddressRange.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('min', IPAddress()),
+ namedtype.NamedType('max', IPAddress())
+)
+
+
+class IPAddressOrRange(univ.Choice):
+ pass
+
+IPAddressOrRange.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('addressPrefix', IPAddress()),
+ namedtype.NamedType('addressRange', IPAddressRange())
+)
+
+
+class IPAddressChoice(univ.Choice):
+ pass
+
+IPAddressChoice.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('inherit', univ.Null()),
+ namedtype.NamedType('addressesOrRanges',
univ.SequenceOf(componentType=IPAddressOrRange()))
+)
+
+
+class IPAddressFamily(univ.Sequence):
+ pass
+
+IPAddressFamily.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('addressFamily',
univ.OctetString().subtype(subtypeSpec=constraint.ValueSizeConstraint(2, 3))),
+ namedtype.NamedType('ipAddressChoice', IPAddressChoice())
+)
+
+
+class IPAddrBlocks(univ.SequenceOf):
+ pass
+
+IPAddrBlocks.componentType = IPAddressFamily()
+
+
+# Autonomous System Identifier Delegation Extension
+
+id_pe_autonomousSysIds = univ.ObjectIdentifier('1.3.6.1.5.5.7.1.8')
+
+
+class ASId(univ.Integer):
+ pass
+
+
+class ASRange(univ.Sequence):
+ pass
+
+ASRange.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('min', ASId()),
+ namedtype.NamedType('max', ASId())
+)
+
+
+class ASIdOrRange(univ.Choice):
+ pass
+
+ASIdOrRange.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('id', ASId()),
+ namedtype.NamedType('range', ASRange())
+)
+
+
+class ASIdentifierChoice(univ.Choice):
+ pass
+
+ASIdentifierChoice.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('inherit', univ.Null()),
+ namedtype.NamedType('asIdsOrRanges',
univ.SequenceOf(componentType=ASIdOrRange()))
+)
+
+
+class ASIdentifiers(univ.Sequence):
+ pass
+
+ASIdentifiers.componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('asnum',
ASIdentifierChoice().subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 0))),
+ namedtype.OptionalNamedType('rdi',
ASIdentifierChoice().subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 1)))
+)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/pyasn1_modules/rfc4055.py
new/pyasn1-modules-0.2.5/pyasn1_modules/rfc4055.py
--- old/pyasn1-modules-0.2.4/pyasn1_modules/rfc4055.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/pyasn1_modules/rfc4055.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,249 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley with a very small amount of assistance from
+# asn1ate v.0.6.0.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Additional Algorithms and Identifiers for RSA Cryptography
+# for use in Certificates and CRLs
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc4055.txt
+#
+
+from pyasn1.type import univ, char, namedtype, namedval, tag, constraint,
useful
+from pyasn1_modules import rfc5280
+
+
+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)
+
+
+id_sha1 = _OID(1, 3, 14, 3, 2, 26)
+
+
+id_sha256 = _OID(2, 16, 840, 1, 101, 3, 4, 2, 1)
+
+
+id_sha384 = _OID(2, 16, 840, 1, 101, 3, 4, 2, 2)
+
+
+id_sha512 = _OID(2, 16, 840, 1, 101, 3, 4, 2, 3)
+
+
+id_sha224 = _OID(2, 16, 840, 1, 101, 3, 4, 2, 4)
+
+
+rsaEncryption = _OID(1, 2, 840, 113549, 1, 1, 1)
+
+
+id_mgf1 = _OID(1, 2, 840, 113549, 1, 1, 8)
+
+
+id_RSAES_OAEP = _OID(1, 2, 840, 113549, 1, 1, 7)
+
+
+id_pSpecified = _OID(1, 2, 840, 113549, 1, 1, 9)
+
+
+id_RSASSA_PSS = _OID(1, 2, 840, 113549, 1, 1, 10)
+
+
+sha256WithRSAEncryption = _OID(1, 2, 840, 113549, 1, 1, 11)
+
+
+sha384WithRSAEncryption = _OID(1, 2, 840, 113549, 1, 1, 12)
+
+
+sha512WithRSAEncryption = _OID(1, 2, 840, 113549, 1, 1, 13)
+
+
+sha224WithRSAEncryption = _OID(1, 2, 840, 113549, 1, 1, 14)
+
+
+sha1Identifier = rfc5280.AlgorithmIdentifier()
+sha1Identifier['algorithm'] = id_sha1
+sha1Identifier['parameters'] = univ.Null("")
+
+
+sha224Identifier = rfc5280.AlgorithmIdentifier()
+sha224Identifier['algorithm'] = id_sha224
+sha224Identifier['parameters'] = univ.Null("")
+
+
+sha256Identifier = rfc5280.AlgorithmIdentifier()
+sha256Identifier['algorithm'] = id_sha256
+sha256Identifier['parameters'] = univ.Null("")
+
+
+sha384Identifier = rfc5280.AlgorithmIdentifier()
+sha384Identifier['algorithm'] = id_sha384
+sha384Identifier['parameters'] = univ.Null("")
+
+
+sha512Identifier = rfc5280.AlgorithmIdentifier()
+sha512Identifier['algorithm'] = id_sha512
+sha512Identifier['parameters'] = univ.Null("")
+
+
+mgf1SHA1Identifier = rfc5280.AlgorithmIdentifier()
+mgf1SHA1Identifier['algorithm'] = id_mgf1
+mgf1SHA1Identifier['parameters'] = sha1Identifier
+
+
+mgf1SHA224Identifier = rfc5280.AlgorithmIdentifier()
+mgf1SHA224Identifier['algorithm'] = id_mgf1
+mgf1SHA224Identifier['parameters'] = sha224Identifier
+
+
+mgf1SHA256Identifier = rfc5280.AlgorithmIdentifier()
+mgf1SHA256Identifier['algorithm'] = id_mgf1
+mgf1SHA256Identifier['parameters'] = sha256Identifier
+
+
+mgf1SHA384Identifier = rfc5280.AlgorithmIdentifier()
+mgf1SHA384Identifier['algorithm'] = id_mgf1
+mgf1SHA384Identifier['parameters'] = sha384Identifier
+
+
+mgf1SHA512Identifier = rfc5280.AlgorithmIdentifier()
+mgf1SHA512Identifier['algorithm'] = id_mgf1
+mgf1SHA512Identifier['parameters'] = sha512Identifier
+
+
+pSpecifiedEmptyIdentifier = rfc5280.AlgorithmIdentifier()
+pSpecifiedEmptyIdentifier['algorithm'] = id_pSpecified
+pSpecifiedEmptyIdentifier['parameters'] = univ.OctetString(value='')
+
+
+class RSAPublicKey(univ.Sequence):
+ pass
+
+RSAPublicKey.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('modulus', univ.Integer()),
+ namedtype.NamedType('publicExponent', univ.Integer())
+)
+
+
+class HashAlgorithm(rfc5280.AlgorithmIdentifier):
+ pass
+
+
+class MaskGenAlgorithm(rfc5280.AlgorithmIdentifier):
+ pass
+
+
+class RSAES_OAEP_params(univ.Sequence):
+ pass
+
+RSAES_OAEP_params.componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('hashFunc',
rfc5280.AlgorithmIdentifier().subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 0))),
+ namedtype.OptionalNamedType('maskGenFunc',
rfc5280.AlgorithmIdentifier().subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 1))),
+ namedtype.OptionalNamedType('pSourceFunc',
rfc5280.AlgorithmIdentifier().subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 2)))
+)
+
+
+rSAES_OAEP_Default_Params = RSAES_OAEP_params()
+
+rSAES_OAEP_Default_Identifier = rfc5280.AlgorithmIdentifier()
+rSAES_OAEP_Default_Identifier['algorithm'] = id_RSAES_OAEP
+rSAES_OAEP_Default_Identifier['parameters'] = rSAES_OAEP_Default_Params
+
+
+rSAES_OAEP_SHA224_Params = RSAES_OAEP_params()
+rSAES_OAEP_SHA224_Params['hashFunc'] =
sha224Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 0), cloneValueFlag=True)
+rSAES_OAEP_SHA224_Params['maskGenFunc'] =
mgf1SHA224Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 1), cloneValueFlag=True)
+
+rSAES_OAEP_SHA224_Identifier = rfc5280.AlgorithmIdentifier()
+rSAES_OAEP_SHA224_Identifier['algorithm'] = id_RSAES_OAEP
+rSAES_OAEP_SHA224_Identifier['parameters'] = rSAES_OAEP_SHA224_Params
+
+
+rSAES_OAEP_SHA256_Params = RSAES_OAEP_params()
+rSAES_OAEP_SHA256_Params['hashFunc'] =
sha256Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 0), cloneValueFlag=True)
+rSAES_OAEP_SHA256_Params['maskGenFunc'] =
mgf1SHA256Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 1), cloneValueFlag=True)
+
+rSAES_OAEP_SHA256_Identifier = rfc5280.AlgorithmIdentifier()
+rSAES_OAEP_SHA256_Identifier['algorithm'] = id_RSAES_OAEP
+rSAES_OAEP_SHA256_Identifier['parameters'] = rSAES_OAEP_SHA256_Params
+
+
+rSAES_OAEP_SHA384_Params = RSAES_OAEP_params()
+rSAES_OAEP_SHA384_Params['hashFunc'] =
sha384Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 0), cloneValueFlag=True)
+rSAES_OAEP_SHA384_Params['maskGenFunc'] =
mgf1SHA384Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 1), cloneValueFlag=True)
+
+rSAES_OAEP_SHA384_Identifier = rfc5280.AlgorithmIdentifier()
+rSAES_OAEP_SHA384_Identifier['algorithm'] = id_RSAES_OAEP
+rSAES_OAEP_SHA384_Identifier['parameters'] = rSAES_OAEP_SHA384_Params
+
+
+rSAES_OAEP_SHA512_Params = RSAES_OAEP_params()
+rSAES_OAEP_SHA512_Params['hashFunc'] =
sha512Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 0), cloneValueFlag=True)
+rSAES_OAEP_SHA512_Params['maskGenFunc'] =
mgf1SHA512Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 1), cloneValueFlag=True)
+
+rSAES_OAEP_SHA512_Identifier = rfc5280.AlgorithmIdentifier()
+rSAES_OAEP_SHA512_Identifier['algorithm'] = id_RSAES_OAEP
+rSAES_OAEP_SHA512_Identifier['parameters'] = rSAES_OAEP_SHA512_Params
+
+
+class RSASSA_PSS_params(univ.Sequence):
+ pass
+
+RSASSA_PSS_params.componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('hashAlgorithm',
rfc5280.AlgorithmIdentifier().subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 0))),
+ namedtype.OptionalNamedType('maskGenAlgorithm',
rfc5280.AlgorithmIdentifier().subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 1))),
+ namedtype.DefaultedNamedType('saltLength',
univ.Integer(value=20).subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatSimple, 2))),
+ namedtype.DefaultedNamedType('trailerField',
univ.Integer(value=1).subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatSimple, 3)))
+)
+
+
+rSASSA_PSS_Default_Params = RSASSA_PSS_params()
+
+rSASSA_PSS_Default_Identifier = rfc5280.AlgorithmIdentifier()
+rSASSA_PSS_Default_Identifier['algorithm'] = id_RSASSA_PSS
+rSASSA_PSS_Default_Identifier['parameters'] = rSASSA_PSS_Default_Params
+
+
+rSASSA_PSS_SHA224_Params = RSASSA_PSS_params()
+rSASSA_PSS_SHA224_Params['hashAlgorithm'] =
sha224Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 0), cloneValueFlag=True)
+rSASSA_PSS_SHA224_Params['maskGenAlgorithm'] =
mgf1SHA224Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 1), cloneValueFlag=True)
+
+rSASSA_PSS_SHA224_Identifier = rfc5280.AlgorithmIdentifier()
+rSASSA_PSS_SHA224_Identifier['algorithm'] = id_RSASSA_PSS
+rSASSA_PSS_SHA224_Identifier['parameters'] = rSASSA_PSS_SHA224_Params
+
+
+rSASSA_PSS_SHA256_Params = RSASSA_PSS_params()
+rSASSA_PSS_SHA256_Params['hashAlgorithm'] =
sha256Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 0), cloneValueFlag=True)
+rSASSA_PSS_SHA256_Params['maskGenAlgorithm'] =
mgf1SHA256Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 1), cloneValueFlag=True)
+
+rSASSA_PSS_SHA256_Identifier = rfc5280.AlgorithmIdentifier()
+rSASSA_PSS_SHA256_Identifier['algorithm'] = id_RSASSA_PSS
+rSASSA_PSS_SHA256_Identifier['parameters'] = rSASSA_PSS_SHA256_Params
+
+
+rSASSA_PSS_SHA384_Params = RSASSA_PSS_params()
+rSASSA_PSS_SHA384_Params['hashAlgorithm'] =
sha384Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 0), cloneValueFlag=True)
+rSASSA_PSS_SHA384_Params['maskGenAlgorithm'] =
mgf1SHA384Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 1), cloneValueFlag=True)
+
+rSASSA_PSS_SHA384_Identifier = rfc5280.AlgorithmIdentifier()
+rSASSA_PSS_SHA384_Identifier['algorithm'] = id_RSASSA_PSS
+rSASSA_PSS_SHA384_Identifier['parameters'] = rSASSA_PSS_SHA384_Params
+
+
+rSASSA_PSS_SHA512_Params = RSASSA_PSS_params()
+rSASSA_PSS_SHA512_Params['hashAlgorithm'] =
sha512Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 0), cloneValueFlag=True)
+rSASSA_PSS_SHA512_Params['maskGenAlgorithm'] =
mgf1SHA512Identifier.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 1), cloneValueFlag=True)
+
+rSASSA_PSS_SHA512_Identifier = rfc5280.AlgorithmIdentifier()
+rSASSA_PSS_SHA512_Identifier['algorithm'] = id_RSASSA_PSS
+rSASSA_PSS_SHA512_Identifier['parameters'] = rSASSA_PSS_SHA512_Params
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/pyasn1_modules/rfc4108.py
new/pyasn1-modules-0.2.5/pyasn1_modules/rfc4108.py
--- old/pyasn1-modules-0.2.4/pyasn1_modules/rfc4108.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/pyasn1_modules/rfc4108.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,294 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley with assistance from asn1ate v.0.6.0.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# CMS Firmware Wrapper
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc4108.txt
+#
+
+
+from pyasn1.type import univ, char, namedtype, namedval, tag, constraint,
useful
+
+from pyasn1_modules import rfc5652
+
+MAX = float('inf')
+
+
+class HardwareSerialEntry(univ.Choice):
+ pass
+
+HardwareSerialEntry.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('all', univ.Null()),
+ namedtype.NamedType('single', univ.OctetString()),
+ namedtype.NamedType('block',
univ.Sequence(componentType=namedtype.NamedTypes(
+ namedtype.NamedType('low', univ.OctetString()),
+ namedtype.NamedType('high', univ.OctetString())
+ ))
+ )
+)
+
+
+class HardwareModules(univ.Sequence):
+ pass
+
+HardwareModules.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('hwType', univ.ObjectIdentifier()),
+ namedtype.NamedType('hwSerialEntries',
univ.SequenceOf(componentType=HardwareSerialEntry()))
+)
+
+
+class CommunityIdentifier(univ.Choice):
+ pass
+
+CommunityIdentifier.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('communityOID', univ.ObjectIdentifier()),
+ namedtype.NamedType('hwModuleList', HardwareModules())
+)
+
+
+
+class PreferredPackageIdentifier(univ.Sequence):
+ pass
+
+PreferredPackageIdentifier.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('fwPkgID', univ.ObjectIdentifier()),
+ namedtype.NamedType('verNum',
univ.Integer().subtype(subtypeSpec=constraint.ValueRangeConstraint(0, MAX)))
+)
+
+
+class PreferredOrLegacyPackageIdentifier(univ.Choice):
+ pass
+
+PreferredOrLegacyPackageIdentifier.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('preferred', PreferredPackageIdentifier()),
+ namedtype.NamedType('legacy', univ.OctetString())
+)
+
+
+class CurrentFWConfig(univ.Sequence):
+ pass
+
+CurrentFWConfig.componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('fwPkgType', univ.Integer()),
+ namedtype.NamedType('fwPkgName', PreferredOrLegacyPackageIdentifier())
+)
+
+
+class PreferredOrLegacyStalePackageIdentifier(univ.Choice):
+ pass
+
+PreferredOrLegacyStalePackageIdentifier.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('preferredStaleVerNum',
univ.Integer().subtype(subtypeSpec=constraint.ValueRangeConstraint(0, MAX))),
+ namedtype.NamedType('legacyStaleVersion', univ.OctetString())
+)
+
+
+class FirmwarePackageLoadErrorCode(univ.Enumerated):
+ pass
+
+FirmwarePackageLoadErrorCode.namedValues = namedval.NamedValues(
+ ('decodeFailure', 1),
+ ('badContentInfo', 2),
+ ('badSignedData', 3),
+ ('badEncapContent', 4),
+ ('badCertificate', 5),
+ ('badSignerInfo', 6),
+ ('badSignedAttrs', 7),
+ ('badUnsignedAttrs', 8),
+ ('missingContent', 9),
+ ('noTrustAnchor', 10),
+ ('notAuthorized', 11),
+ ('badDigestAlgorithm', 12),
+ ('badSignatureAlgorithm', 13),
+ ('unsupportedKeySize', 14),
+ ('signatureFailure', 15),
+ ('contentTypeMismatch', 16),
+ ('badEncryptedData', 17),
+ ('unprotectedAttrsPresent', 18),
+ ('badEncryptContent', 19),
+ ('badEncryptAlgorithm', 20),
+ ('missingCiphertext', 21),
+ ('noDecryptKey', 22),
+ ('decryptFailure', 23),
+ ('badCompressAlgorithm', 24),
+ ('missingCompressedContent', 25),
+ ('decompressFailure', 26),
+ ('wrongHardware', 27),
+ ('stalePackage', 28),
+ ('notInCommunity', 29),
+ ('unsupportedPackageType', 30),
+ ('missingDependency', 31),
+ ('wrongDependencyVersion', 32),
+ ('insufficientMemory', 33),
+ ('badFirmware', 34),
+ ('unsupportedParameters', 35),
+ ('breaksDependency', 36),
+ ('otherError', 99)
+)
+
+
+class VendorLoadErrorCode(univ.Integer):
+ pass
+
+
+
+# Wrapped Firmware Key Unsigned Attribute and Object Identifiers
+
+id_aa_wrappedFirmwareKey = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.39')
+
+class WrappedFirmwareKey(rfc5652.EnvelopedData):
+ pass
+
+
+# Firmware Package Information Signed Attribute and Object Identifier
+
+id_aa_firmwarePackageInfo = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.42')
+
+class FirmwarePackageInfo(univ.Sequence):
+ pass
+
+FirmwarePackageInfo.componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('fwPkgType', univ.Integer()),
+ namedtype.OptionalNamedType('dependencies',
univ.SequenceOf(componentType=PreferredOrLegacyPackageIdentifier()))
+)
+
+FirmwarePackageInfo.sizeSpec = univ.Sequence.sizeSpec +
constraint.ValueSizeConstraint(1, 2)
+
+
+# Community Identifiers Signed Attribute and Object Identifier
+
+id_aa_communityIdentifiers =
univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.40')
+
+class CommunityIdentifiers(univ.SequenceOf):
+ pass
+
+CommunityIdentifiers.componentType = CommunityIdentifier()
+
+
+# Implemented Compression Algorithms Signed Attribute and Object Identifier
+
+id_aa_implCompressAlgs = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.43')
+
+class ImplementedCompressAlgorithms(univ.SequenceOf):
+ pass
+
+ImplementedCompressAlgorithms.componentType = univ.ObjectIdentifier()
+
+
+# Implemented Cryptographic Algorithms Signed Attribute and Object Identifier
+
+id_aa_implCryptoAlgs = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.38')
+
+class ImplementedCryptoAlgorithms(univ.SequenceOf):
+ pass
+
+ImplementedCryptoAlgorithms.componentType = univ.ObjectIdentifier()
+
+
+# Decrypt Key Identifier Signed Attribute and Object Identifier
+
+id_aa_decryptKeyID = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.37')
+
+class DecryptKeyIdentifier(univ.OctetString):
+ pass
+
+
+# Target Hardware Identifier Signed Attribute and Object Identifier
+
+id_aa_targetHardwareIDs = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.36')
+
+class TargetHardwareIdentifiers(univ.SequenceOf):
+ pass
+
+TargetHardwareIdentifiers.componentType = univ.ObjectIdentifier()
+
+
+# Firmware Package Identifier Signed Attribute and Object Identifier
+
+id_aa_firmwarePackageID = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.35')
+
+class FirmwarePackageIdentifier(univ.Sequence):
+ pass
+
+FirmwarePackageIdentifier.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('name', PreferredOrLegacyPackageIdentifier()),
+ namedtype.OptionalNamedType('stale',
PreferredOrLegacyStalePackageIdentifier())
+)
+
+
+# Firmware Package Load Error Report Content Type and Object Identifier
+
+class FWErrorVersion(univ.Integer):
+ pass
+
+FWErrorVersion.namedValues = namedval.NamedValues(
+ ('v1', 1)
+)
+
+
+id_ct_firmwareLoadError = univ.ObjectIdentifier('1.2.840.113549.1.9.16.1.18')
+
+class FirmwarePackageLoadError(univ.Sequence):
+ pass
+
+FirmwarePackageLoadError.componentType = namedtype.NamedTypes(
+ namedtype.DefaultedNamedType('version',
FWErrorVersion().subtype(value='v1')),
+ namedtype.NamedType('hwType', univ.ObjectIdentifier()),
+ namedtype.NamedType('hwSerialNum', univ.OctetString()),
+ namedtype.NamedType('errorCode', FirmwarePackageLoadErrorCode()),
+ namedtype.OptionalNamedType('vendorErrorCode', VendorLoadErrorCode()),
+ namedtype.OptionalNamedType('fwPkgName',
PreferredOrLegacyPackageIdentifier()),
+ namedtype.OptionalNamedType('config',
univ.SequenceOf(componentType=CurrentFWConfig()).subtype(implicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatSimple, 1)))
+)
+
+
+# Firmware Package Load Receipt Content Type and Object Identifier
+
+class FWReceiptVersion(univ.Integer):
+ pass
+
+FWReceiptVersion.namedValues = namedval.NamedValues(
+ ('v1', 1)
+)
+
+
+id_ct_firmwareLoadReceipt = univ.ObjectIdentifier('1.2.840.113549.1.9.16.1.17')
+
+class FirmwarePackageLoadReceipt(univ.Sequence):
+ pass
+
+FirmwarePackageLoadReceipt.componentType = namedtype.NamedTypes(
+ namedtype.DefaultedNamedType('version',
FWReceiptVersion().subtype(value='v1')),
+ namedtype.NamedType('hwType', univ.ObjectIdentifier()),
+ namedtype.NamedType('hwSerialNum', univ.OctetString()),
+ namedtype.NamedType('fwPkgName', PreferredOrLegacyPackageIdentifier()),
+ namedtype.OptionalNamedType('trustAnchorKeyID', univ.OctetString()),
+ namedtype.OptionalNamedType('decryptKeyID',
univ.OctetString().subtype(implicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatSimple, 1)))
+)
+
+
+# Firmware Package Content Type and Object Identifier
+
+id_ct_firmwarePackage = univ.ObjectIdentifier('1.2.840.113549.1.9.16.1.16')
+
+class FirmwarePkgData(univ.OctetString):
+ pass
+
+
+# Other Name syntax for Hardware Module Name
+
+id_on_hardwareModuleName = univ.ObjectIdentifier('1.3.6.1.5.5.7.8.4')
+
+class HardwareModuleName(univ.Sequence):
+ pass
+
+HardwareModuleName.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('hwType', univ.ObjectIdentifier()),
+ namedtype.NamedType('hwSerialNum', univ.OctetString())
+)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/pyasn1_modules/rfc5958.py
new/pyasn1-modules-0.2.5/pyasn1_modules/rfc5958.py
--- old/pyasn1-modules-0.2.4/pyasn1_modules/rfc5958.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/pyasn1_modules/rfc5958.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,87 @@
+#
+# This file is being contributed to pyasn1-modules software.
+#
+# Created by Russ Housley.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Asymmetric Key Packages, which is essentially version 2 of
+# the PrivateKeyInfo structure in PKCS#8 in RFC 5208
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc8418.txt
+
+from pyasn1.type import univ, constraint, namedtype, namedval, tag
+
+from pyasn1_modules import rfc5280
+
+
+MAX = float('inf')
+
+
+class KeyEncryptionAlgorithmIdentifier(rfc5280.AlgorithmIdentifier):
+ pass
+
+
+class PrivateKeyAlgorithmIdentifier(rfc5280.AlgorithmIdentifier):
+ pass
+
+
+class EncryptedData(univ.OctetString):
+ pass
+
+
+class EncryptedPrivateKeyInfo(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('encryptionAlgorithm',
KeyEncryptionAlgorithmIdentifier()),
+ namedtype.NamedType('encryptedData', EncryptedData())
+ )
+
+
+class Version(univ.Integer):
+ namedValues = namedval.NamedValues(('v1', 0), ('v2', 1))
+
+
+class PrivateKey(univ.OctetString):
+ pass
+
+
+class Attributes(univ.SetOf):
+ componentType = rfc5280.Attribute()
+
+
+class PublicKey(univ.BitString):
+ pass
+
+
+# OneAsymmetricKey is essentially version 2 of PrivateKeyInfo.
+# If publicKey is present, then the version must be v2;
+# otherwise, the version should be v1.
+
+class OneAsymmetricKey(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('version', Version()),
+ namedtype.NamedType('privateKeyAlgorithm',
PrivateKeyAlgorithmIdentifier()),
+ namedtype.NamedType('privateKey', PrivateKey()),
+ namedtype.OptionalNamedType('attributes', Attributes().subtype(
+ implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed,
0))),
+ namedtype.OptionalNamedType('publicKey', PublicKey().subtype(
+ implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed,
1)))
+ )
+
+
+class PrivateKeyInfo(OneAsymmetricKey):
+ pass
+
+
+# The CMS AsymmetricKeyPackage Content Type
+
+id_ct_KP_aKeyPackage = univ.ObjectIdentifier('2.16.840.1.101.2.1.2.78.5')
+
+class AsymmetricKeyPackage(univ.SequenceOf):
+ pass
+
+AsymmetricKeyPackage.componentType = OneAsymmetricKey()
+AsymmetricKeyPackage.subtypeSpec=constraint.ValueSizeConstraint(1, MAX)
+
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/pyasn1_modules/rfc8410.py
new/pyasn1-modules-0.2.5/pyasn1_modules/rfc8410.py
--- old/pyasn1-modules-0.2.4/pyasn1_modules/rfc8410.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/pyasn1_modules/rfc8410.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,47 @@
+# This file is being contributed to pyasn1-modules software.
+#
+# Created by Russ Housley.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Algorithm Identifiers for Ed25519, Ed448, X25519, and X448
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc8410.txt
+
+
+from pyasn1.type import univ
+from pyasn1_modules import rfc3565
+from pyasn1_modules import rfc4055
+from pyasn1_modules import rfc5280
+
+
+class SignatureAlgorithmIdentifier(rfc5280.AlgorithmIdentifier):
+ pass
+
+
+class KeyEncryptionAlgorithmIdentifier(rfc5280.AlgorithmIdentifier):
+ pass
+
+
+class CurvePrivateKey(univ.OctetString):
+ pass
+
+
+id_X25519 = univ.ObjectIdentifier('1.3.101.110')
+
+id_X448 = univ.ObjectIdentifier('1.3.101.111')
+
+
+id_Ed25519 = univ.ObjectIdentifier('1.3.101.112')
+
+id_Ed448 = univ.ObjectIdentifier('1.3.101.113')
+
+
+id_sha512 = rfc4055.id_sha512
+
+
+id_aes128_wrap = rfc3565.id_aes128_wrap
+
+id_aes256_wrap = rfc3565.id_aes256_wrap
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/pyasn1_modules/rfc8418.py
new/pyasn1-modules-0.2.5/pyasn1_modules/rfc8418.py
--- old/pyasn1-modules-0.2.4/pyasn1_modules/rfc8418.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/pyasn1_modules/rfc8418.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,37 @@
+# This file is being contributed to pyasn1-modules software.
+#
+# Created by Russ Housley.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Elliptic Curve Diffie-Hellman (ECDH) Key Agreement Algorithm
+# with X25519 and X448
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc8418.txt
+
+from pyasn1.type import univ
+from pyasn1_modules import rfc5280
+
+
+class KeyEncryptionAlgorithmIdentifier(rfc5280.AlgorithmIdentifier):
+ pass
+
+
+class KeyWrapAlgorithmIdentifier(rfc5280.AlgorithmIdentifier):
+ pass
+
+
+dhSinglePass_stdDH_sha256kdf_scheme =
univ.ObjectIdentifier('1.3.133.16.840.63.0.11.1')
+
+dhSinglePass_stdDH_sha384kdf_scheme =
univ.ObjectIdentifier('1.3.133.16.840.63.0.11.2')
+
+dhSinglePass_stdDH_sha512kdf_scheme =
univ.ObjectIdentifier('1.3.133.16.840.63.0.11.3')
+
+
+dhSinglePass_stdDH_hkdf_sha256_scheme =
univ.ObjectIdentifier('1.2.840.113549.1.9.16.3.19')
+
+dhSinglePass_stdDH_hkdf_sha384_scheme =
univ.ObjectIdentifier('1.2.840.113549.1.9.16.3.20')
+
+dhSinglePass_stdDH_hkdf_sha512_scheme =
univ.ObjectIdentifier('1.2.840.113549.1.9.16.3.21')
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/pyasn1-modules-0.2.4/pyasn1_modules.egg-info/PKG-INFO
new/pyasn1-modules-0.2.5/pyasn1_modules.egg-info/PKG-INFO
--- old/pyasn1-modules-0.2.4/pyasn1_modules.egg-info/PKG-INFO 2019-01-26
18:54:25.000000000 +0100
+++ new/pyasn1-modules-0.2.5/pyasn1_modules.egg-info/PKG-INFO 2019-04-24
06:42:12.000000000 +0200
@@ -1,6 +1,6 @@
Metadata-Version: 1.1
Name: pyasn1-modules
-Version: 0.2.4
+Version: 0.2.5
Summary: A collection of ASN.1-based protocols modules.
Home-page: https://github.com/etingof/pyasn1-modules
Author: Ilya Etingof <[email protected]>
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/pyasn1-modules-0.2.4/pyasn1_modules.egg-info/SOURCES.txt
new/pyasn1-modules-0.2.5/pyasn1_modules.egg-info/SOURCES.txt
--- old/pyasn1-modules-0.2.4/pyasn1_modules.egg-info/SOURCES.txt
2019-01-26 18:54:25.000000000 +0100
+++ new/pyasn1-modules-0.2.5/pyasn1_modules.egg-info/SOURCES.txt
2019-04-24 06:42:13.000000000 +0200
@@ -26,7 +26,11 @@
pyasn1_modules/rfc3412.py
pyasn1_modules/rfc3414.py
pyasn1_modules/rfc3447.py
+pyasn1_modules/rfc3565.py
+pyasn1_modules/rfc3779.py
pyasn1_modules/rfc3852.py
+pyasn1_modules/rfc4055.py
+pyasn1_modules/rfc4108.py
pyasn1_modules/rfc4210.py
pyasn1_modules/rfc4211.py
pyasn1_modules/rfc5083.py
@@ -34,9 +38,12 @@
pyasn1_modules/rfc5208.py
pyasn1_modules/rfc5280.py
pyasn1_modules/rfc5652.py
+pyasn1_modules/rfc5958.py
pyasn1_modules/rfc6402.py
pyasn1_modules/rfc8103.py
pyasn1_modules/rfc8226.py
+pyasn1_modules/rfc8410.py
+pyasn1_modules/rfc8418.py
pyasn1_modules.egg-info/PKG-INFO
pyasn1_modules.egg-info/SOURCES.txt
pyasn1_modules.egg-info/dependency_links.txt
@@ -52,14 +59,21 @@
tests/test_rfc2511.py
tests/test_rfc2560.py
tests/test_rfc2986.py
+tests/test_rfc3565.py
+tests/test_rfc3779.py
+tests/test_rfc4055.py
+tests/test_rfc4108.py
tests/test_rfc4210.py
tests/test_rfc5083.py
tests/test_rfc5084.py
tests/test_rfc5208.py
tests/test_rfc5280.py
tests/test_rfc5652.py
+tests/test_rfc5958.py
tests/test_rfc8103.py
tests/test_rfc8226.py
+tests/test_rfc8410.py
+tests/test_rfc8418.py
tools/cmcdump.py
tools/cmpdump.py
tools/crldump.py
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/tests/__main__.py
new/pyasn1-modules-0.2.5/tests/__main__.py
--- old/pyasn1-modules-0.2.4/tests/__main__.py 2019-01-26 18:53:16.000000000
+0100
+++ new/pyasn1-modules-0.2.5/tests/__main__.py 2019-04-24 06:40:45.000000000
+0200
@@ -18,11 +18,21 @@
'tests.test_rfc2511.suite',
'tests.test_rfc2560.suite',
'tests.test_rfc2986.suite',
+ 'tests.test_rfc3565.suite',
+ 'tests.test_rfc3779.suite',
+ 'tests.test_rfc4055.suite'
+ 'tests.test_rfc4108.suite'
'tests.test_rfc4210.suite',
+ 'tests.test_rfc5083.suite'
+ 'tests.test_rfc5084.suite'
'tests.test_rfc5208.suite',
'tests.test_rfc5280.suite',
'tests.test_rfc5652.suite',
- 'tests.test_rfc8226.suite']
+ 'tests.test_rfc5958.suite'
+ 'tests.test_rfc8103.suite'
+ 'tests.test_rfc8226.suite',
+ 'tests.test_rfc8410.suite'
+ 'tests.test_rfc8418.suite']
)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/tests/test_rfc3565.py
new/pyasn1-modules-0.2.5/tests/test_rfc3565.py
--- old/pyasn1-modules-0.2.4/tests/test_rfc3565.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/tests/test_rfc3565.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,57 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+
+import sys
+
+from pyasn1.codec.der import decoder as der_decoder
+from pyasn1.codec.der import encoder as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc3565
+
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+
+
+class AESKeyWrapTestCase(unittest.TestCase):
+ kw_alg_id_pem_text = "MAsGCWCGSAFlAwQBLQ=="
+
+ def setUp(self):
+ self.asn1Spec = rfc3565.AlgorithmIdentifier()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.kw_alg_id_pem_text)
+ asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec)
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert asn1Object[0] == rfc3565.id_aes256_wrap
+ assert der_encoder.encode(asn1Object) == substrate
+
+
+class AESCBCTestCase(unittest.TestCase):
+ aes_alg_id_pem_text = "MB0GCWCGSAFlAwQBKgQQEImWuoUOPwM5mTu1h4oONw=="
+
+ def setUp(self):
+ self.asn1Spec = rfc3565.AlgorithmIdentifier()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.aes_alg_id_pem_text)
+ asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec)
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert asn1Object[0] == rfc3565.id_aes256_CBC
+ assert asn1Object[1].isValue
+ assert der_encoder.encode(asn1Object) == substrate
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ unittest.TextTestRunner(verbosity=2).run(suite)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/tests/test_rfc3779.py
new/pyasn1-modules-0.2.5/tests/test_rfc3779.py
--- old/pyasn1-modules-0.2.4/tests/test_rfc3779.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/tests/test_rfc3779.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,81 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+
+from pyasn1.codec.der import decoder as der_decoder
+from pyasn1.codec.der import encoder as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc3779
+
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+
+
+class CertificateExtnTestCase(unittest.TestCase):
+ pem_text = """\
+MIIECjCCAvKgAwIBAgICAMkwDQYJKoZIhvcNAQELBQAwFjEUMBIGA1UEAxMLcmlw
+ZS1uY2MtdGEwIBcNMTcxMTI4MTQzOTU1WhgPMjExNzExMjgxNDM5NTVaMBYxFDAS
+BgNVBAMTC3JpcGUtbmNjLXRhMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEA0URYSGqUz2myBsOzeW1jQ6NsxNvlLMyhWknvnl8NiBCs/T/S2XuNKQNZ+wBZ
+xIgPPV2pFBFeQAvoH/WK83HwA26V2siwm/MY2nKZ+Olw+wlpzlZ1p3Ipj2eNcKrm
+it8BwBC8xImzuCGaV0jkRB0GZ0hoH6Ml03umLprRsn6v0xOP0+l6Qc1ZHMFVFb38
+5IQ7FQQTcVIxrdeMsoyJq9eMkE6DoclHhF/NlSllXubASQ9KUWqJ0+Ot3QCXr4LX
+ECMfkpkVR2TZT+v5v658bHVs6ZxRD1b6Uk1uQKAyHUbn/tXvP8lrjAibGzVsXDT2
+L0x4Edx+QdixPgOji3gBMyL2VwIDAQABo4IBXjCCAVowHQYDVR0OBBYEFOhVKx/W
+0aT35ATG2OVoDR68Fj/DMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEG
+MIGxBggrBgEFBQcBCwSBpDCBoTA8BggrBgEFBQcwCoYwcnN5bmM6Ly9ycGtpLnJp
+cGUubmV0L3JlcG9zaXRvcnkvcmlwZS1uY2MtdGEubWZ0MDIGCCsGAQUFBzANhiZo
+dHRwczovL3JyZHAucmlwZS5uZXQvbm90aWZpY2F0aW9uLnhtbDAtBggrBgEFBQcw
+BYYhcnN5bmM6Ly9ycGtpLnJpcGUubmV0L3JlcG9zaXRvcnkvMBgGA1UdIAEB/wQO
+MAwwCgYIKwYBBQUHDgIwJwYIKwYBBQUHAQcBAf8EGDAWMAkEAgABMAMDAQAwCQQC
+AAIwAwMBADAhBggrBgEFBQcBCAEB/wQSMBCgDjAMMAoCAQACBQD/////MA0GCSqG
+SIb3DQEBCwUAA4IBAQAVgJjrZ3wFppC8Yk8D2xgzwSeWVT2vtYq96CQQsjaKb8nb
+eVz3DwcS3a7RIsevrNVGo43k3AGymg1ki+AWJjvHvJ+tSzCbn5+X6Z7AfYTf2g37
+xINVDHru0PTQUargSMBAz/MBNpFG8KThtT7WbJrK4+f/lvx0m8QOlYm2a17iXS3A
+GQJ6RHcq9ADscqGdumxmMMDjwED26bGaYdmru1hNIpwF//jVM/eRjBFoPHKFlx0k
+Ld/yoCQNmx1kW+xANx4uyWxi/DYgSV7Oynq+C60OucW+d8tIhkblh8+YfrmukJds
+V+vo2L72yerdbsP9xjqvhZrLKfsLZjYK4SdYYthi
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.Certificate()
+
+ def testDerCodec(self):
+
+ substrate = pem.readBase64fromText(self.pem_text)
+
+ asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec)
+
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert der_encoder.encode(asn1Object) == substrate
+
+ for extn in asn1Object['tbsCertificate']['extensions']:
+
+ if extn['extnID'] == rfc3779.id_pe_ipAddrBlocks:
+ s = extn['extnValue']
+ addr_blocks, rest = der_decoder.decode(s,
rfc3779.IPAddrBlocks())
+ assert not rest
+ assert addr_blocks.prettyPrint()
+ assert der_encoder.encode(addr_blocks) == s
+
+ if extn['extnID'] == rfc3779.id_pe_autonomousSysIds:
+ s = extn['extnValue']
+ as_ids, rest = der_decoder.decode(s, rfc3779.ASIdentifiers())
+ assert not rest
+ assert as_ids.prettyPrint()
+ assert der_encoder.encode(as_ids) == s
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ unittest.TextTestRunner(verbosity=2).run(suite)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/tests/test_rfc4055.py
new/pyasn1-modules-0.2.5/tests/test_rfc4055.py
--- old/pyasn1-modules-0.2.4/tests/test_rfc4055.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/tests/test_rfc4055.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,107 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+
+import sys
+
+from pyasn1.codec.der import decoder as der_decoder
+from pyasn1.codec.der import encoder as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc4055
+
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+
+
+class PSSDefautTestCase(unittest.TestCase):
+ pss_default_pem_text = "MAsGCSqGSIb3DQEBCg=="
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.AlgorithmIdentifier()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pss_default_pem_text)
+ asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec)
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert asn1Object[0] == rfc4055.id_RSASSA_PSS
+ assert der_encoder.encode(asn1Object) == substrate
+ assert substrate == der_encoder.encode(asn1Object)
+
+
+class PSSSHA512TestCase(unittest.TestCase):
+ pss_sha512_pem_text =
"MDwGCSqGSIb3DQEBCjAvoA8wDQYJYIZIAWUDBAIDBQChHDAaBgkqhkiG9w0BAQgwDQYJYIZIAWUDBAIDBQA="
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.AlgorithmIdentifier()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pss_sha512_pem_text)
+ asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec)
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert asn1Object[0] == rfc4055.id_RSASSA_PSS
+ assert der_encoder.encode(asn1Object) == substrate
+ assert substrate == der_encoder.encode(asn1Object)
+
+
+class OAEPDefautTestCase(unittest.TestCase):
+ oaep_default_pem_text = "MAsGCSqGSIb3DQEBBw=="
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.AlgorithmIdentifier()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.oaep_default_pem_text)
+ asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec)
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert asn1Object[0] == rfc4055.id_RSAES_OAEP
+ assert der_encoder.encode(asn1Object) == substrate
+ assert substrate == der_encoder.encode(asn1Object)
+
+
+class OAEPSHA256TestCase(unittest.TestCase):
+ oaep_sha256_pem_text =
"MDwGCSqGSIb3DQEBBzAvoA8wDQYJYIZIAWUDBAIBBQChHDAaBgkqhkiG9w0BAQgwDQYJYIZIAWUDBAIBBQA="
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.AlgorithmIdentifier()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.oaep_sha256_pem_text)
+ asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec)
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert asn1Object[0] == rfc4055.id_RSAES_OAEP
+ assert der_encoder.encode(asn1Object) == substrate
+ assert substrate == der_encoder.encode(asn1Object)
+
+
+class OAEPFullTestCase(unittest.TestCase):
+ oaep_full_pem_text =
"MFMGCSqGSIb3DQEBBzBGoA8wDQYJYIZIAWUDBAICBQChHDAaBgkqhkiG9w0BAQgwDQYJYIZIAWUDBAICBQCiFTATBgkqhkiG9w0BAQkEBmZvb2Jhcg=="
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.AlgorithmIdentifier()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.oaep_full_pem_text)
+ asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec)
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert asn1Object[0] == rfc4055.id_RSAES_OAEP
+ assert der_encoder.encode(asn1Object) == substrate
+ assert substrate == der_encoder.encode(asn1Object)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ unittest.TextTestRunner(verbosity=2).run(suite)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/tests/test_rfc4108.py
new/pyasn1-modules-0.2.5/tests/test_rfc4108.py
--- old/pyasn1-modules-0.2.4/tests/test_rfc4108.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/tests/test_rfc4108.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,80 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+
+from pyasn1.codec.der.decoder import decode as der_decode
+from pyasn1.codec.der.encoder import encode as der_encode
+
+from pyasn1.type import univ
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc4108
+
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+
+
+class CMSFirmwareWrapperTestCase(unittest.TestCase):
+ pem_text = """\
+MIIEdwYJKoZIhvcNAQcCoIIEaDCCBGQCAQExDTALBglghkgBZQMEAgEwggIVBgsq
+hkiG9w0BCRABEKCCAgQEggIA3ntqPr5kDpx+//pgWGfHCH/Ht4pbenGwXv80txyE
+Y0I2mT9BUGz8ILkbhD7Xz89pBS5KhEJpthxH8WREJtvS+wL4BqYLt23wjWoZy5Gt
+5dPzWgaNlV/aQ5AdfAY9ljmnNYnK8D8r8ur7bQM4cKUdxry+QA0nqXHMAOSpx4Um
+8impCc0BICXaFfL3zBrNxyPubbFO9ofbYOAWaNmmIAhzthXf12vDrLostIqmYrP4
+LMRCjTr4LeYaVrAWfKtbUbByN6IuBef3Qt5cJaChr74udz3JvbYFsUvCpl64kpRq
+g2CT6R+xE4trO/pViJlI15dvJVz04BBYQ2jQsutJwChi97/DDcjIv03VBmrwRE0k
+RJNFP9vpDM8CxJIqcobC5Kuv8b0GqGfGl6ouuQKEVMfBcrupgjk3oc3KL1iVdSr1
++74amb1vDtTMWNm6vWRqh+Kk17NGEi2mNvYkkZUTIHNGH7OgiDclFU8dSMZd1fun
+/D9dmiFiErDB3Fzr4+8Qz0aKedNE/1uvM+dhu9qjuRdkDzZ4S7txTfk6y9pG9iyk
+aEeTV2kElKXblgi+Cf0Ut4f5he8rt6jveHdMo9X36YiUQVvevj2cgN7lFivEnFYV
+QY0xugpP7lvEFDfsi2+0ozgP8EKOLYaCUKpuvttlYJ+vdtUFEijizEZ4cx02RsXm
+EesxggI1MIICMQIBA4AUnutnybladNRNLxY5ZoDoAbXLpJwwCwYJYIZIAWUDBAIB
+oHgwGgYJKoZIhvcNAQkDMQ0GCyqGSIb3DQEJEAEQMCkGCyqGSIb3DQEJEAIkMRoG
+CysGAQQBjb9BAQEqBgsrBgEEAY2/QQEBMDAvBgkqhkiG9w0BCQQxIgQgAJfvuasB
+4P6WDLOkOyvj33YPgZW4olHbidzyh1EKP9YwCwYJKoZIhvcNAQELBIIBgDn0y+4B
+cCX7ICovWcyWf0IxNXx7+1VlYneAZ8pMBaKu+6q7jRFZ+QsQFFbQ1yPO/3Pr2wVb
+UJSJAL4QCJDurJ42LdPQIOGIV2aWq70vl6B9yt6svEdjxJ3XkopwcCBXLcB1Hp9b
+6wYZzSFCujOlsABJiz2gMD6wUT4lq7RJO31LEPxx/Va4Ftp1F4okmgL8VpMemihU
+atRXpIhedfli+TWEtMmoxcX3paLcU7MmJFUAwkHmb8rSRF5VBy5QWcNgzzskof0W
+mCR/8bZjqR/g3VlFPyz7zOCxG/wIdZVAb4O/QP8fC0GhyHNE+NX6d+GI8RPpRyMf
+5RfCCsHwbApCv8+tpFslYzwvUTIFx0y9zVrnkz/UrDjZtrKxLC0oRJlnlnKR1unm
+lbolB9c2p60/mZHwQhLM5CjeYcMX3mMVJo4jqag+8o48CibW50h8y21usKaeA9b0
+9EMxfG3KaaP5mMEOZMpeGdUKQSJYweDstxlrY5ajPbeOycdMv7tRNoLpyw==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+
+ asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
+
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert der_encode(asn1Object) == substrate
+
+ assert asn1Object['contentType'] == rfc5652.id_signedData
+ inner, rest = der_decode(asn1Object['content'],
asn1Spec=rfc5652.SignedData())
+
+ assert inner['encapContentInfo']['eContentType'] ==
rfc4108.id_ct_firmwarePackage
+ assert inner['encapContentInfo']['eContent']
+
+ found_target_hardware_identifier_attribute = False
+ for attr in inner['signerInfos'][0]['signedAttrs']:
+ if attr['attrType'] == rfc4108.id_aa_targetHardwareIDs:
+ found_target_hardware_identifier_attribute = True
+ assert found_target_hardware_identifier_attribute
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ unittest.TextTestRunner(verbosity=2).run(suite)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/tests/test_rfc5958.py
new/pyasn1-modules-0.2.5/tests/test_rfc5958.py
--- old/pyasn1-modules-0.2.4/tests/test_rfc5958.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/tests/test_rfc5958.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,50 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+
+import sys
+
+from pyasn1.codec.der import decoder as der_decoder
+from pyasn1.codec.der import encoder as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5958
+from pyasn1_modules import rfc8410
+
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+
+
+class PrivateKeyTestCase(unittest.TestCase):
+ priv_key_pem_text = """\
+MHICAQEwBQYDK2VwBCIEINTuctv5E1hK1bbY8fdp+K06/nwoy/HU++CXqI9EdVhC
+oB8wHQYKKoZIhvcNAQkJFDEPDA1DdXJkbGUgQ2hhaXJzgSEAGb9ECWmEzf6FQbrB
+Z9w7lshQhqowtrbLDFw4rXAxZuE=
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5958.PrivateKeyInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.priv_key_pem_text)
+ asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec)
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert asn1Object['privateKeyAlgorithm']['algorithm'] ==
rfc8410.id_Ed25519
+ assert asn1Object['privateKey'].isValue
+ assert asn1Object['privateKey'].prettyPrint()[0:10] == "0x0420d4ee"
+ assert asn1Object['publicKey'].isValue
+ assert asn1Object['publicKey'].prettyPrint()[0:10] == "1164575857"
+ assert der_encoder.encode(asn1Object) == substrate
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ unittest.TextTestRunner(verbosity=2).run(suite)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/tests/test_rfc8410.py
new/pyasn1-modules-0.2.5/tests/test_rfc8410.py
--- old/pyasn1-modules-0.2.4/tests/test_rfc8410.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/tests/test_rfc8410.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,44 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+
+import sys
+
+from pyasn1.codec.der import decoder as der_decoder
+from pyasn1.codec.der import encoder as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5208
+from pyasn1_modules import rfc8410
+
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+
+
+class PrivateKeyTestCase(unittest.TestCase):
+ no_pub_key_pem_text =
"MC4CAQAwBQYDK2VwBCIEINTuctv5E1hK1bbY8fdp+K06/nwoy/HU++CXqI9EdVhC"
+
+ def setUp(self):
+ self.asn1Spec = rfc5208.PrivateKeyInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.no_pub_key_pem_text)
+ asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec)
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert asn1Object['privateKeyAlgorithm']['algorithm'] ==
rfc8410.id_Ed25519
+ assert asn1Object['privateKey'].isValue
+ assert asn1Object['privateKey'].prettyPrint()[0:10] == "0x0420d4ee"
+ assert der_encoder.encode(asn1Object) == substrate
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ unittest.TextTestRunner(verbosity=2).run(suite)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyasn1-modules-0.2.4/tests/test_rfc8418.py
new/pyasn1-modules-0.2.5/tests/test_rfc8418.py
--- old/pyasn1-modules-0.2.4/tests/test_rfc8418.py 1970-01-01
01:00:00.000000000 +0100
+++ new/pyasn1-modules-0.2.5/tests/test_rfc8418.py 2019-04-24
06:40:45.000000000 +0200
@@ -0,0 +1,43 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+
+import sys
+
+from pyasn1.codec.der import decoder as der_decoder
+from pyasn1.codec.der import encoder as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc8418
+
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+
+
+class KeyAgreeAlgTestCase(unittest.TestCase):
+ key_agree_alg_id_pem_text = "MBoGCyqGSIb3DQEJEAMUMAsGCWCGSAFlAwQBLQ=="
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.AlgorithmIdentifier()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.key_agree_alg_id_pem_text)
+ asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec)
+ assert not rest
+ assert asn1Object.prettyPrint()
+ assert asn1Object['algorithm'] ==
rfc8418.dhSinglePass_stdDH_hkdf_sha384_scheme
+ assert asn1Object['parameters'].isValue
+ assert der_encoder.encode(asn1Object) == substrate
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ unittest.TextTestRunner(verbosity=2).run(suite)
