New Upstream Snapshot - python-pyasn1-modules
Ready changes
Summary
Merged new upstream version: 0.2.8+git20200321.1.bdbcc5d (was: 0.2.8).
Resulting package
Built on 2023-01-20T15:15 (took 6m27s)
The resulting binary packages can be installed (if you have the apt repository enabled) by running one of:
apt install -t fresh-snapshots python3-pyasn1-modules
Lintian Result
Diff
diff --git a/CHANGES.txt b/CHANGES.txt
index bb82416..b9535c0 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,4 +1,47 @@
+Revision 0.3.0, released XX-03-2020
+-----------------------------------
+
+- Added support for Python 3.8.
+- Added tox runner with a handful of basic jobs
+- Add RFC3125 providing Electronic Signature Policies
+- Add RFC5126 providing CMS Advanced Electronic Signatures (CAdES)
+- Removed support for EOL Pythons 2.4, 2.5, 2.6, 3.2, 3.3 and 3.4.
+- Improve test routines for RFC5126
+- Add RFC4387 providing Certificate Store Access via HTTP
+- Changed assertion in unit tests from Python built-in to `unittest`
+ provided
+- Add RFC8692 providing Algorithm Identifiers for RSASSA-PSS and
+ ECDSA Using SHAKEs
+- Add RFC5753 providing CMS Elliptic Curve Cryptography Algorithms
+- Add RFC3820 providing Proxy Certificates
+- Add RFC3370 providing Cryptographic Message Syntax (CMS) Algorithms
+- Add RFC3537 providing HMAC Key Wrapping
+- Add RFC3739 providing Qualified Certificates
+- Add RFC2876 providing KEA and SKIPJACK for CMS
+- Add RFC3058 providing IDEA Encryption Algorithm for CMS
+- Add RFC3657 providing Camellia Encryption Algorithm for CMS
+- Add RFC4010 providing SEED Encryption Algorithm for CMS
+- Add RFC4357 providing Additional Cryptographic Algorithms for Use with
+ GOST 28147-89, GOST R 34.10-94, GOST R 34.10-2001, and GOST R 34.11-94
+- Add RFC4490 providing GOST 28147-89, GOST R 34.11-94, GOST R 34.10-94,
+ and GOST R 34.10-2001 Algorithms for CMS
+- Add RFC4491 providing GOST R 34.10-94, GOST R 34.10-2001, and
+ GOST R 34.11-94 Algorithms for certificates and CRLs
+- Add RFC8696 providing using Pre-Shared Key (PSK) in the CMS
+- Add RFC5639 providing identifiers for the Brainpool curves in
+ Elliptic Curve Cryptography
+- Add RFC5697 providing Other Certificates Extension
+- Add RFC4683 providing Subject Identification Method (SIM)
+- Add RFC4476 providing Attribute Certificate Policies Extension
+- Add RFC5636 providing Traceable Anonymous Certificate
+- Add RFC5752 providing Multiple Signatures attribute for CMS
+- Add RFC5275 providing CMS Symmetric Key Management and Distribution
+- Add RFC8702 providing SHAKE One-way Hash Functions in the CMS
+- Add RFC8708 providing HSS/LMS Hash-based Signature Algorithm for CMS
+- Advance copyright statement to year 2020
+- Add RFC8769 providing CBOR and CBOR Sequence content types for CMS
+
Revision 0.2.8, released 16-11-2019
-----------------------------------
diff --git a/LICENSE.txt b/LICENSE.txt
index ac630e8..598b843 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,4 +1,4 @@
-Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
All rights reserved.
Redistribution and use in source and binary forms, with or without
diff --git a/PKG-INFO b/PKG-INFO
index 9ad169d..bf422cf 100644
--- a/PKG-INFO
+++ b/PKG-INFO
@@ -1,13 +1,12 @@
-Metadata-Version: 1.2
+Metadata-Version: 2.1
Name: pyasn1-modules
-Version: 0.2.8
+Version: 0.3.0
Summary: A collection of ASN.1-based protocols modules.
Home-page: https://github.com/etingof/pyasn1-modules
Author: Ilya Etingof
Author-email: etingof@gmail.com
Maintainer: Ilya Etingof <etingof@gmail.com>
License: BSD-2-Clause
-Description: A collection of ASN.1 modules expressed in form of pyasn1 classes. Includes protocols PDUs definition (SNMP, LDAP etc.) and various data structures (X.509, PKCS etc.).
Platform: any
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
@@ -20,14 +19,8 @@ Classifier: License :: OSI Approved :: BSD License
Classifier: Natural Language :: English
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.4
-Classifier: Programming Language :: Python :: 2.5
-Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.2
-Classifier: Programming Language :: Python :: 3.3
-Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
@@ -36,3 +29,7 @@ Classifier: Topic :: Communications
Classifier: Topic :: System :: Monitoring
Classifier: Topic :: System :: Networking :: Monitoring
Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
+License-File: LICENSE.txt
+
+A collection of ASN.1 modules expressed in form of pyasn1 classes. Includes protocols PDUs definition (SNMP, LDAP etc.) and various data structures (X.509, PKCS etc.).
diff --git a/README.md b/README.md
index 6e97d3d..baa11c7 100644
--- a/README.md
+++ b/README.md
@@ -25,5 +25,5 @@ or post your question [on Stack Overflow](https://stackoverflow.com/questions/as
New modules contributions are welcome via GitHub pull requests.
-Copyright (c) 2005-2019, [Ilya Etingof](mailto:etingof@gmail.com).
+Copyright (c) 2005-2020, [Ilya Etingof](mailto:etingof@gmail.com).
All rights reserved.
diff --git a/debian/changelog b/debian/changelog
index b9c381b..5ca5817 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,9 +1,10 @@
-python-pyasn1-modules (0.2.8-2) UNRELEASED; urgency=medium
+python-pyasn1-modules (0.2.8+git20200321.1.bdbcc5d-1) UNRELEASED; urgency=medium
* Remove constraints unnecessary since buster:
+ Build-Depends: Drop versioned constraint on python3-pyasn1.
+ * New upstream snapshot.
- -- Debian Janitor <janitor@jelmer.uk> Tue, 10 May 2022 18:10:23 -0000
+ -- Debian Janitor <janitor@jelmer.uk> Fri, 20 Jan 2023 15:11:15 -0000
python-pyasn1-modules (0.2.8-1) unstable; urgency=low
diff --git a/pyasn1_modules.egg-info/PKG-INFO b/pyasn1_modules.egg-info/PKG-INFO
index 9ad169d..bf422cf 100644
--- a/pyasn1_modules.egg-info/PKG-INFO
+++ b/pyasn1_modules.egg-info/PKG-INFO
@@ -1,13 +1,12 @@
-Metadata-Version: 1.2
+Metadata-Version: 2.1
Name: pyasn1-modules
-Version: 0.2.8
+Version: 0.3.0
Summary: A collection of ASN.1-based protocols modules.
Home-page: https://github.com/etingof/pyasn1-modules
Author: Ilya Etingof
Author-email: etingof@gmail.com
Maintainer: Ilya Etingof <etingof@gmail.com>
License: BSD-2-Clause
-Description: A collection of ASN.1 modules expressed in form of pyasn1 classes. Includes protocols PDUs definition (SNMP, LDAP etc.) and various data structures (X.509, PKCS etc.).
Platform: any
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Console
@@ -20,14 +19,8 @@ Classifier: License :: OSI Approved :: BSD License
Classifier: Natural Language :: English
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.4
-Classifier: Programming Language :: Python :: 2.5
-Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.2
-Classifier: Programming Language :: Python :: 3.3
-Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
@@ -36,3 +29,7 @@ Classifier: Topic :: Communications
Classifier: Topic :: System :: Monitoring
Classifier: Topic :: System :: Networking :: Monitoring
Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
+License-File: LICENSE.txt
+
+A collection of ASN.1 modules expressed in form of pyasn1 classes. Includes protocols PDUs definition (SNMP, LDAP etc.) and various data structures (X.509, PKCS etc.).
diff --git a/pyasn1_modules.egg-info/SOURCES.txt b/pyasn1_modules.egg-info/SOURCES.txt
index 346c389..476b2a1 100644
--- a/pyasn1_modules.egg-info/SOURCES.txt
+++ b/pyasn1_modules.egg-info/SOURCES.txt
@@ -21,23 +21,32 @@ pyasn1_modules/rfc2511.py
pyasn1_modules/rfc2560.py
pyasn1_modules/rfc2631.py
pyasn1_modules/rfc2634.py
+pyasn1_modules/rfc2876.py
pyasn1_modules/rfc2985.py
pyasn1_modules/rfc2986.py
+pyasn1_modules/rfc3058.py
pyasn1_modules/rfc3114.py
+pyasn1_modules/rfc3125.py
pyasn1_modules/rfc3161.py
pyasn1_modules/rfc3274.py
pyasn1_modules/rfc3279.py
pyasn1_modules/rfc3280.py
pyasn1_modules/rfc3281.py
+pyasn1_modules/rfc3370.py
pyasn1_modules/rfc3412.py
pyasn1_modules/rfc3414.py
pyasn1_modules/rfc3447.py
+pyasn1_modules/rfc3537.py
pyasn1_modules/rfc3560.py
pyasn1_modules/rfc3565.py
+pyasn1_modules/rfc3657.py
pyasn1_modules/rfc3709.py
+pyasn1_modules/rfc3739.py
pyasn1_modules/rfc3770.py
pyasn1_modules/rfc3779.py
+pyasn1_modules/rfc3820.py
pyasn1_modules/rfc3852.py
+pyasn1_modules/rfc4010.py
pyasn1_modules/rfc4043.py
pyasn1_modules/rfc4055.py
pyasn1_modules/rfc4073.py
@@ -45,16 +54,29 @@ pyasn1_modules/rfc4108.py
pyasn1_modules/rfc4210.py
pyasn1_modules/rfc4211.py
pyasn1_modules/rfc4334.py
+pyasn1_modules/rfc4357.py
+pyasn1_modules/rfc4387.py
+pyasn1_modules/rfc4476.py
+pyasn1_modules/rfc4490.py
+pyasn1_modules/rfc4491.py
+pyasn1_modules/rfc4683.py
pyasn1_modules/rfc4985.py
pyasn1_modules/rfc5035.py
pyasn1_modules/rfc5083.py
pyasn1_modules/rfc5084.py
+pyasn1_modules/rfc5126.py
pyasn1_modules/rfc5208.py
+pyasn1_modules/rfc5275.py
pyasn1_modules/rfc5280.py
pyasn1_modules/rfc5480.py
+pyasn1_modules/rfc5636.py
+pyasn1_modules/rfc5639.py
pyasn1_modules/rfc5649.py
pyasn1_modules/rfc5652.py
+pyasn1_modules/rfc5697.py
pyasn1_modules/rfc5751.py
+pyasn1_modules/rfc5752.py
+pyasn1_modules/rfc5753.py
pyasn1_modules/rfc5755.py
pyasn1_modules/rfc5913.py
pyasn1_modules/rfc5914.py
@@ -75,7 +97,6 @@ pyasn1_modules/rfc6170.py
pyasn1_modules/rfc6187.py
pyasn1_modules/rfc6210.py
pyasn1_modules/rfc6211.py
-pyasn1_modules/rfc6402-1.py
pyasn1_modules/rfc6402.py
pyasn1_modules/rfc6482.py
pyasn1_modules/rfc6486.py
@@ -92,7 +113,6 @@ pyasn1_modules/rfc7508.py
pyasn1_modules/rfc7585.py
pyasn1_modules/rfc7633.py
pyasn1_modules/rfc7773.py
-pyasn1_modules/rfc7894-1.py
pyasn1_modules/rfc7894.py
pyasn1_modules/rfc7906.py
pyasn1_modules/rfc7914.py
@@ -112,6 +132,11 @@ pyasn1_modules/rfc8494.py
pyasn1_modules/rfc8520.py
pyasn1_modules/rfc8619.py
pyasn1_modules/rfc8649.py
+pyasn1_modules/rfc8692.py
+pyasn1_modules/rfc8696.py
+pyasn1_modules/rfc8702.py
+pyasn1_modules/rfc8708.py
+pyasn1_modules/rfc8769.py
pyasn1_modules.egg-info/PKG-INFO
pyasn1_modules.egg-info/SOURCES.txt
pyasn1_modules.egg-info/dependency_links.txt
@@ -129,21 +154,30 @@ tests/test_rfc2511.py
tests/test_rfc2560.py
tests/test_rfc2631.py
tests/test_rfc2634.py
+tests/test_rfc2876.py
tests/test_rfc2985.py
tests/test_rfc2986.py
+tests/test_rfc3058.py
tests/test_rfc3114.py
+tests/test_rfc3125.py
tests/test_rfc3161.py
tests/test_rfc3274.py
tests/test_rfc3279.py
tests/test_rfc3280.py
tests/test_rfc3281.py
+tests/test_rfc3370.py
tests/test_rfc3447.py
+tests/test_rfc3537.py
tests/test_rfc3560.py
tests/test_rfc3565.py
+tests/test_rfc3657.py
tests/test_rfc3709.py
+tests/test_rfc3739.py
tests/test_rfc3770.py
tests/test_rfc3779.py
+tests/test_rfc3820.py
tests/test_rfc3852.py
+tests/test_rfc4010.py
tests/test_rfc4043.py
tests/test_rfc4055.py
tests/test_rfc4073.py
@@ -151,16 +185,29 @@ tests/test_rfc4108.py
tests/test_rfc4210.py
tests/test_rfc4211.py
tests/test_rfc4334.py
+tests/test_rfc4357.py
+tests/test_rfc4387.py
+tests/test_rfc4476.py
+tests/test_rfc4490.py
+tests/test_rfc4491.py
+tests/test_rfc4683.py
tests/test_rfc4985.py
tests/test_rfc5035.py
tests/test_rfc5083.py
tests/test_rfc5084.py
+tests/test_rfc5126.py
tests/test_rfc5208.py
+tests/test_rfc5275.py
tests/test_rfc5280.py
tests/test_rfc5480.py
+tests/test_rfc5636.py
+tests/test_rfc5639.py
tests/test_rfc5649.py
tests/test_rfc5652.py
+tests/test_rfc5697.py
tests/test_rfc5751.py
+tests/test_rfc5752.py
+tests/test_rfc5753.py
tests/test_rfc5755.py
tests/test_rfc5913.py
tests/test_rfc5914.py
@@ -215,6 +262,11 @@ tests/test_rfc8494.py
tests/test_rfc8520.py
tests/test_rfc8619.py
tests/test_rfc8649.py
+tests/test_rfc8692.py
+tests/test_rfc8696.py
+tests/test_rfc8702.py
+tests/test_rfc8708.py
+tests/test_rfc8769.py
tools/cmcdump.py
tools/cmpdump.py
tools/crldump.py
diff --git a/pyasn1_modules.egg-info/requires.txt b/pyasn1_modules.egg-info/requires.txt
index 81a097b..45d7a2c 100644
--- a/pyasn1_modules.egg-info/requires.txt
+++ b/pyasn1_modules.egg-info/requires.txt
@@ -1 +1 @@
-pyasn1<0.5.0,>=0.4.6
+pyasn1<0.6.0,>=0.4.6
diff --git a/pyasn1_modules/__init__.py b/pyasn1_modules/__init__.py
index 917ac12..95a220e 100644
--- a/pyasn1_modules/__init__.py
+++ b/pyasn1_modules/__init__.py
@@ -1,2 +1,2 @@
# http://www.python.org/dev/peps/pep-0396/
-__version__ = '0.2.8'
+__version__ = '0.3.0'
diff --git a/pyasn1_modules/pem.py b/pyasn1_modules/pem.py
index a6090bd..f7c80a9 100644
--- a/pyasn1_modules/pem.py
+++ b/pyasn1_modules/pem.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import base64
diff --git a/pyasn1_modules/rfc1155.py b/pyasn1_modules/rfc1155.py
index 611e97e..1870234 100644
--- a/pyasn1_modules/rfc1155.py
+++ b/pyasn1_modules/rfc1155.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# SNMPv1 message syntax
diff --git a/pyasn1_modules/rfc1157.py b/pyasn1_modules/rfc1157.py
index b80d926..df49e48 100644
--- a/pyasn1_modules/rfc1157.py
+++ b/pyasn1_modules/rfc1157.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# SNMPv1 message syntax
diff --git a/pyasn1_modules/rfc1901.py b/pyasn1_modules/rfc1901.py
index 04533da..658dcb9 100644
--- a/pyasn1_modules/rfc1901.py
+++ b/pyasn1_modules/rfc1901.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# SNMPv2c message syntax
diff --git a/pyasn1_modules/rfc1902.py b/pyasn1_modules/rfc1902.py
index d1a1648..063998a 100644
--- a/pyasn1_modules/rfc1902.py
+++ b/pyasn1_modules/rfc1902.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# SNMPv2c message syntax
diff --git a/pyasn1_modules/rfc1905.py b/pyasn1_modules/rfc1905.py
index 72c44ed..435427b 100644
--- a/pyasn1_modules/rfc1905.py
+++ b/pyasn1_modules/rfc1905.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# SNMPv2c PDU syntax
diff --git a/pyasn1_modules/rfc2251.py b/pyasn1_modules/rfc2251.py
index 84c3d87..094922c 100644
--- a/pyasn1_modules/rfc2251.py
+++ b/pyasn1_modules/rfc2251.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# LDAP message syntax
diff --git a/pyasn1_modules/rfc2314.py b/pyasn1_modules/rfc2314.py
index a453217..b0edfe0 100644
--- a/pyasn1_modules/rfc2314.py
+++ b/pyasn1_modules/rfc2314.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# PKCS#10 syntax
diff --git a/pyasn1_modules/rfc2315.py b/pyasn1_modules/rfc2315.py
index a98c9a9..1069fc2 100644
--- a/pyasn1_modules/rfc2315.py
+++ b/pyasn1_modules/rfc2315.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# PKCS#7 message syntax
diff --git a/pyasn1_modules/rfc2437.py b/pyasn1_modules/rfc2437.py
index 1139eb4..88641cf 100644
--- a/pyasn1_modules/rfc2437.py
+++ b/pyasn1_modules/rfc2437.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# PKCS#1 syntax
diff --git a/pyasn1_modules/rfc2459.py b/pyasn1_modules/rfc2459.py
index 9f35787..57f783e 100644
--- a/pyasn1_modules/rfc2459.py
+++ b/pyasn1_modules/rfc2459.py
@@ -4,7 +4,7 @@
# Updated by Russ Housley to resolve the TODO regarding the Certificate
# Policies Certificate Extension.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# X.509 message syntax
diff --git a/pyasn1_modules/rfc2511.py b/pyasn1_modules/rfc2511.py
index 5dd6fc2..8935cda 100644
--- a/pyasn1_modules/rfc2511.py
+++ b/pyasn1_modules/rfc2511.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# X.509 certificate Request Message Format (CRMF) syntax
diff --git a/pyasn1_modules/rfc2560.py b/pyasn1_modules/rfc2560.py
index c37e25b..017ac0b 100644
--- a/pyasn1_modules/rfc2560.py
+++ b/pyasn1_modules/rfc2560.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# OCSP request/response syntax
diff --git a/pyasn1_modules/rfc2876.py b/pyasn1_modules/rfc2876.py
new file mode 100644
index 0000000..04c402b
--- /dev/null
+++ b/pyasn1_modules/rfc2876.py
@@ -0,0 +1,56 @@
+#
+# 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
+#
+# KEA and SKIPJACK Algorithms in CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc2876.txt
+#
+
+from pyasn1.type import namedtype
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5751
+
+
+id_fortezzaConfidentialityAlgorithm = univ.ObjectIdentifier('2.16.840.1.101.2.1.1.4')
+
+
+id_fortezzaWrap80 = univ.ObjectIdentifier('2.16.840.1.101.2.1.1.23')
+
+
+id_kEAKeyEncryptionAlgorithm = univ.ObjectIdentifier('2.16.840.1.101.2.1.1.24')
+
+
+id_keyExchangeAlgorithm = univ.ObjectIdentifier('2.16.840.1.101.2.1.1.22')
+
+
+class Skipjack_Parm(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('initialization-vector', univ.OctetString())
+ )
+
+
+# Update the Algorithm Identifier map in rfc5280.py.
+
+_algorithmIdentifierMapUpdate = {
+ id_fortezzaConfidentialityAlgorithm: Skipjack_Parm(),
+ id_kEAKeyEncryptionAlgorithm: rfc5280.AlgorithmIdentifier(),
+}
+
+rfc5280.algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)
+
+
+# Update the SMIMECapabilities Attribute map in rfc5751.py
+
+_smimeCapabilityMapUpdate = {
+ id_kEAKeyEncryptionAlgorithm: rfc5280.AlgorithmIdentifier(),
+}
+
+rfc5751.smimeCapabilityMap.update(_smimeCapabilityMapUpdate)
diff --git a/pyasn1_modules/rfc2986.py b/pyasn1_modules/rfc2986.py
index 34acbd5..309637d 100644
--- a/pyasn1_modules/rfc2986.py
+++ b/pyasn1_modules/rfc2986.py
@@ -6,7 +6,7 @@
# Modified by Russ Housley to add support for opentypes by importing
# definitions from rfc5280 so that the same maps are used.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# PKCS #10: Certification Request Syntax Specification
diff --git a/pyasn1_modules/rfc3058.py b/pyasn1_modules/rfc3058.py
new file mode 100644
index 0000000..725de82
--- /dev/null
+++ b/pyasn1_modules/rfc3058.py
@@ -0,0 +1,42 @@
+#
+# 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
+#
+# IDEA Encryption Algorithm in CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc3058.txt
+# https://www.rfc-editor.org/errata/eid5913
+#
+
+from pyasn1.type import namedtype
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+
+id_IDEA_CBC = univ.ObjectIdentifier('1.3.6.1.4.1.188.7.1.1.2')
+
+
+id_alg_CMSIDEAwrap = univ.ObjectIdentifier('1.3.6.1.4.1.188.7.1.1.6')
+
+
+class IDEA_CBCPar(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('iv', univ.OctetString())
+ # exactly 8 octets, when present
+ )
+
+
+# Update the Algorithm Identifier map in rfc5280.py.
+
+_algorithmIdentifierMapUpdate = {
+ id_IDEA_CBC: IDEA_CBCPar(),
+ id_alg_CMSIDEAwrap: univ.Null("")
+}
+
+rfc5280.algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)
diff --git a/pyasn1_modules/rfc3125.py b/pyasn1_modules/rfc3125.py
new file mode 100644
index 0000000..00ff9bf
--- /dev/null
+++ b/pyasn1_modules/rfc3125.py
@@ -0,0 +1,469 @@
+#
+# 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
+#
+# Electronic Signature Policies
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc3125.txt
+# https://www.rfc-editor.org/errata/eid5901
+# https://www.rfc-editor.org/errata/eid5902
+#
+
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import namedval
+from pyasn1.type import tag
+from pyasn1.type import useful
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+MAX = float('inf')
+
+
+# Imports from RFC 5280
+
+AlgorithmIdentifier = rfc5280.AlgorithmIdentifier
+
+Attribute = rfc5280.Attribute
+
+AttributeType = rfc5280.AttributeType
+
+AttributeTypeAndValue = rfc5280.AttributeTypeAndValue
+
+AttributeValue = rfc5280.AttributeValue
+
+Certificate = rfc5280.Certificate
+
+CertificateList = rfc5280.CertificateList
+
+DirectoryString = rfc5280.DirectoryString
+
+GeneralName = rfc5280.GeneralName
+
+GeneralNames = rfc5280.GeneralNames
+
+Name = rfc5280.Name
+
+PolicyInformation = rfc5280.PolicyInformation
+
+
+# Electronic Signature Policies
+
+class CertPolicyId(univ.ObjectIdentifier):
+ pass
+
+
+class AcceptablePolicySet(univ.SequenceOf):
+ componentType = CertPolicyId()
+
+
+class SignPolExtn(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('extnID', univ.ObjectIdentifier()),
+ namedtype.NamedType('extnValue', univ.OctetString())
+ )
+
+
+class SignPolExtensions(univ.SequenceOf):
+ componentType = SignPolExtn()
+
+
+class AlgAndLength(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('algID', univ.ObjectIdentifier()),
+ namedtype.OptionalNamedType('minKeyLength', univ.Integer()),
+ namedtype.OptionalNamedType('other', SignPolExtensions())
+ )
+
+
+class AlgorithmConstraints(univ.SequenceOf):
+ componentType = AlgAndLength()
+
+
+class AlgorithmConstraintSet(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('signerAlgorithmConstraints',
+ AlgorithmConstraints().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('eeCertAlgorithmConstraints',
+ AlgorithmConstraints().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1))),
+ namedtype.OptionalNamedType('caCertAlgorithmConstraints',
+ AlgorithmConstraints().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 2))),
+ namedtype.OptionalNamedType('aaCertAlgorithmConstraints',
+ AlgorithmConstraints().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 3))),
+ namedtype.OptionalNamedType('tsaCertAlgorithmConstraints',
+ AlgorithmConstraints().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 4)))
+ )
+
+
+class AttributeValueConstraints(univ.SequenceOf):
+ componentType = AttributeTypeAndValue()
+
+
+class AttributeTypeConstraints(univ.SequenceOf):
+ componentType = AttributeType()
+
+
+class AttributeConstraints(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('attributeTypeConstarints',
+ AttributeTypeConstraints().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('attributeValueConstarints',
+ AttributeValueConstraints().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1)))
+ )
+
+
+class HowCertAttribute(univ.Enumerated):
+ namedValues = namedval.NamedValues(
+ ('claimedAttribute', 0),
+ ('certifiedAttribtes', 1),
+ ('either', 2)
+ )
+
+
+class SkipCerts(univ.Integer):
+ subtypeSpec = constraint.ValueRangeConstraint(0, MAX)
+
+
+class PolicyConstraints(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('requireExplicitPolicy',
+ SkipCerts().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('inhibitPolicyMapping',
+ SkipCerts().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1)))
+ )
+
+
+class BaseDistance(univ.Integer):
+ subtypeSpec = constraint.ValueRangeConstraint(0, MAX)
+
+
+class GeneralSubtree(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('base', GeneralName()),
+ namedtype.DefaultedNamedType('minimum',
+ BaseDistance().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0)).subtype(
+ value=0)),
+ namedtype.OptionalNamedType('maximum',
+ BaseDistance().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1)))
+ )
+
+
+class GeneralSubtrees(univ.SequenceOf):
+ componentType = GeneralSubtree()
+ subtypeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+
+class NameConstraints(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('permittedSubtrees',
+ GeneralSubtrees().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('excludedSubtrees',
+ GeneralSubtrees().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1)))
+ )
+
+
+class PathLenConstraint(univ.Integer):
+ subtypeSpec = constraint.ValueRangeConstraint(0, MAX)
+
+
+class CertificateTrustPoint(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('trustpoint', Certificate()),
+ namedtype.OptionalNamedType('pathLenConstraint',
+ PathLenConstraint().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('acceptablePolicySet',
+ AcceptablePolicySet().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1))),
+ namedtype.OptionalNamedType('nameConstraints',
+ NameConstraints().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 2))),
+ namedtype.OptionalNamedType('policyConstraints',
+ PolicyConstraints().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 3)))
+ )
+
+
+class CertificateTrustTrees(univ.SequenceOf):
+ componentType = CertificateTrustPoint()
+
+
+class EnuRevReq(univ.Enumerated):
+ namedValues = namedval.NamedValues(
+ ('clrCheck', 0),
+ ('ocspCheck', 1),
+ ('bothCheck', 2),
+ ('eitherCheck', 3),
+ ('noCheck', 4),
+ ('other', 5)
+ )
+
+
+class RevReq(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('enuRevReq', EnuRevReq()),
+ namedtype.OptionalNamedType('exRevReq', SignPolExtensions())
+ )
+
+
+class CertRevReq(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('endCertRevReq', RevReq()),
+ namedtype.NamedType('caCerts',
+ RevReq().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 0)))
+ )
+
+
+class AttributeTrustCondition(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('attributeMandated', univ.Boolean()),
+ namedtype.NamedType('howCertAttribute', HowCertAttribute()),
+ namedtype.OptionalNamedType('attrCertificateTrustTrees',
+ CertificateTrustTrees().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('attrRevReq',
+ CertRevReq().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 1))),
+ namedtype.OptionalNamedType('attributeConstraints',
+ AttributeConstraints().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 2)))
+ )
+
+
+class CMSAttrs(univ.SequenceOf):
+ componentType = univ.ObjectIdentifier()
+
+
+class CertInfoReq(univ.Enumerated):
+ namedValues = namedval.NamedValues(
+ ('none', 0),
+ ('signerOnly', 1),
+ ('fullPath', 2)
+ )
+
+
+class CertRefReq(univ.Enumerated):
+ namedValues = namedval.NamedValues(
+ ('signerOnly', 1),
+ ('fullPath', 2)
+ )
+
+
+class DeltaTime(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('deltaSeconds', univ.Integer()),
+ namedtype.NamedType('deltaMinutes', univ.Integer()),
+ namedtype.NamedType('deltaHours', univ.Integer()),
+ namedtype.NamedType('deltaDays', univ.Integer())
+ )
+
+
+class TimestampTrustCondition(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('ttsCertificateTrustTrees',
+ CertificateTrustTrees().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('ttsRevReq',
+ CertRevReq().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 1))),
+ namedtype.OptionalNamedType('ttsNameConstraints',
+ NameConstraints().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 2))),
+ namedtype.OptionalNamedType('cautionPeriod',
+ DeltaTime().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 3))),
+ namedtype.OptionalNamedType('signatureTimestampDelay',
+ DeltaTime().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 4)))
+ )
+
+
+class SignerRules(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('externalSignedData', univ.Boolean()),
+ namedtype.NamedType('mandatedSignedAttr', CMSAttrs()),
+ namedtype.NamedType('mandatedUnsignedAttr', CMSAttrs()),
+ namedtype.DefaultedNamedType('mandatedCertificateRef',
+ CertRefReq().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0)).subtype(
+ value='signerOnly')),
+ namedtype.DefaultedNamedType('mandatedCertificateInfo',
+ CertInfoReq().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1)).subtype(
+ value='none')),
+ namedtype.OptionalNamedType('signPolExtensions',
+ SignPolExtensions().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 2)))
+ )
+
+
+class MandatedUnsignedAttr(CMSAttrs):
+ pass
+
+
+class VerifierRules(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('mandatedUnsignedAttr', MandatedUnsignedAttr()),
+ namedtype.OptionalNamedType('signPolExtensions', SignPolExtensions())
+ )
+
+
+class SignerAndVerifierRules(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('signerRules', SignerRules()),
+ namedtype.NamedType('verifierRules', VerifierRules())
+ )
+
+
+class SigningCertTrustCondition(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('signerTrustTrees', CertificateTrustTrees()),
+ namedtype.NamedType('signerRevReq', CertRevReq())
+ )
+
+
+class CommitmentTypeIdentifier(univ.ObjectIdentifier):
+ pass
+
+
+class FieldOfApplication(DirectoryString):
+ pass
+
+
+class CommitmentType(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('identifier', CommitmentTypeIdentifier()),
+ namedtype.OptionalNamedType('fieldOfApplication',
+ FieldOfApplication().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('semantics',
+ DirectoryString().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1)))
+ )
+
+
+class SelectedCommitmentTypes(univ.SequenceOf):
+ componentType = univ.Choice(componentType=namedtype.NamedTypes(
+ namedtype.NamedType('empty', univ.Null()),
+ namedtype.NamedType('recognizedCommitmentType', CommitmentType())
+ ))
+
+
+class CommitmentRule(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('selCommitmentTypes', SelectedCommitmentTypes()),
+ namedtype.OptionalNamedType('signerAndVeriferRules',
+ SignerAndVerifierRules().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 0))),
+ namedtype.OptionalNamedType('signingCertTrustCondition',
+ SigningCertTrustCondition().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 1))),
+ namedtype.OptionalNamedType('timeStampTrustCondition',
+ TimestampTrustCondition().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 2))),
+ namedtype.OptionalNamedType('attributeTrustCondition',
+ AttributeTrustCondition().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 3))),
+ namedtype.OptionalNamedType('algorithmConstraintSet',
+ AlgorithmConstraintSet().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 4))),
+ namedtype.OptionalNamedType('signPolExtensions',
+ SignPolExtensions().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 5)))
+ )
+
+
+class CommitmentRules(univ.SequenceOf):
+ componentType = CommitmentRule()
+
+
+class CommonRules(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('signerAndVeriferRules',
+ SignerAndVerifierRules().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 0))),
+ namedtype.OptionalNamedType('signingCertTrustCondition',
+ SigningCertTrustCondition().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 1))),
+ namedtype.OptionalNamedType('timeStampTrustCondition',
+ TimestampTrustCondition().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 2))),
+ namedtype.OptionalNamedType('attributeTrustCondition',
+ AttributeTrustCondition().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 3))),
+ namedtype.OptionalNamedType('algorithmConstraintSet',
+ AlgorithmConstraintSet().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 4))),
+ namedtype.OptionalNamedType('signPolExtensions',
+ SignPolExtensions().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 5)))
+ )
+
+
+class PolicyIssuerName(GeneralNames):
+ pass
+
+
+class SignPolicyHash(univ.OctetString):
+ pass
+
+
+class SignPolicyId(univ.ObjectIdentifier):
+ pass
+
+
+class SigningPeriod(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('notBefore', useful.GeneralizedTime()),
+ namedtype.OptionalNamedType('notAfter', useful.GeneralizedTime())
+ )
+
+
+class SignatureValidationPolicy(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('signingPeriod', SigningPeriod()),
+ namedtype.NamedType('commonRules', CommonRules()),
+ namedtype.NamedType('commitmentRules', CommitmentRules()),
+ namedtype.OptionalNamedType('signPolExtensions', SignPolExtensions())
+ )
+
+
+class SignPolicyInfo(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('signPolicyIdentifier', SignPolicyId()),
+ namedtype.NamedType('dateOfIssue', useful.GeneralizedTime()),
+ namedtype.NamedType('policyIssuerName', PolicyIssuerName()),
+ namedtype.NamedType('fieldOfApplication', FieldOfApplication()),
+ namedtype.NamedType('signatureValidationPolicy', SignatureValidationPolicy()),
+ namedtype.OptionalNamedType('signPolExtensions', SignPolExtensions())
+ )
+
+
+class SignaturePolicy(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('signPolicyHashAlg', AlgorithmIdentifier()),
+ namedtype.NamedType('signPolicyInfo', SignPolicyInfo()),
+ namedtype.OptionalNamedType('signPolicyHash', SignPolicyHash())
+ )
+
+
diff --git a/pyasn1_modules/rfc3280.py b/pyasn1_modules/rfc3280.py
index e9dbc86..4c6df13 100644
--- a/pyasn1_modules/rfc3280.py
+++ b/pyasn1_modules/rfc3280.py
@@ -3,7 +3,7 @@
# This file is part of pyasn1-modules software.
#
# Created by Stanisław Pitucha with asn1ate tool.
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Internet X.509 Public Key Infrastructure Certificate and Certificate
diff --git a/pyasn1_modules/rfc3281.py b/pyasn1_modules/rfc3281.py
index 39ce824..a78abf9 100644
--- a/pyasn1_modules/rfc3281.py
+++ b/pyasn1_modules/rfc3281.py
@@ -3,7 +3,7 @@
# This file is part of pyasn1-modules software.
#
# Created by Stanisław Pitucha with asn1ate tool.
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# An Internet Attribute Certificate Profile for Authorization
diff --git a/pyasn1_modules/rfc3370.py b/pyasn1_modules/rfc3370.py
new file mode 100644
index 0000000..51a9d5c
--- /dev/null
+++ b/pyasn1_modules/rfc3370.py
@@ -0,0 +1,146 @@
+#
+# 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
+#
+# Cryptographic Message Syntax (CMS) Algorithms
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc3370.txt
+#
+
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc3279
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5751
+from pyasn1_modules import rfc5753
+from pyasn1_modules import rfc5990
+from pyasn1_modules import rfc8018
+
+
+# Imports from RFC 5280
+
+AlgorithmIdentifier = rfc5280.AlgorithmIdentifier
+
+
+# Imports from RFC 3279
+
+dhpublicnumber = rfc3279.dhpublicnumber
+
+dh_public_number = dhpublicnumber
+
+DHPublicKey = rfc3279.DHPublicKey
+
+DomainParameters = rfc3279.DomainParameters
+
+DHDomainParameters = DomainParameters
+
+Dss_Parms = rfc3279.Dss_Parms
+
+Dss_Sig_Value = rfc3279.Dss_Sig_Value
+
+md5 = rfc3279.md5
+
+md5WithRSAEncryption = rfc3279.md5WithRSAEncryption
+
+RSAPublicKey = rfc3279.RSAPublicKey
+
+rsaEncryption = rfc3279.rsaEncryption
+
+ValidationParms = rfc3279.ValidationParms
+
+id_dsa = rfc3279.id_dsa
+
+id_dsa_with_sha1 = rfc3279.id_dsa_with_sha1
+
+id_sha1 = rfc3279.id_sha1
+
+sha_1 = id_sha1
+
+sha1WithRSAEncryption = rfc3279.sha1WithRSAEncryption
+
+
+# Imports from RFC 5753
+
+CBCParameter = rfc5753.CBCParameter
+
+CBCParameter = rfc5753.IV
+
+KeyWrapAlgorithm = rfc5753.KeyWrapAlgorithm
+
+
+# Imports from RFC 5990
+
+id_alg_CMS3DESwrap = rfc5990.id_alg_CMS3DESwrap
+
+
+# Imports from RFC 8018
+
+des_EDE3_CBC = rfc8018.des_EDE3_CBC
+
+des_ede3_cbc = des_EDE3_CBC
+
+rc2CBC = rfc8018.rc2CBC
+
+rc2_cbc = rc2CBC
+
+RC2_CBC_Parameter = rfc8018.RC2_CBC_Parameter
+
+RC2CBCParameter = RC2_CBC_Parameter
+
+PBKDF2_params = rfc8018.PBKDF2_params
+
+id_PBKDF2 = rfc8018.id_PBKDF2
+
+
+# The few things that are not already defined elsewhere
+
+hMAC_SHA1 = univ.ObjectIdentifier('1.3.6.1.5.5.8.1.2')
+
+
+id_alg_ESDH = univ.ObjectIdentifier('1.2.840.113549.1.9.16.3.5')
+
+
+id_alg_SSDH = univ.ObjectIdentifier('1.2.840.113549.1.9.16.3.10')
+
+
+id_alg_CMSRC2wrap = univ.ObjectIdentifier('1.2.840.113549.1.9.16.3.7')
+
+
+class RC2ParameterVersion(univ.Integer):
+ pass
+
+
+class RC2wrapParameter(RC2ParameterVersion):
+ pass
+
+
+class Dss_Pub_Key(univ.Integer):
+ pass
+
+
+# Update the Algorithm Identifier map in rfc5280.py.
+
+_algorithmIdentifierMapUpdate = {
+ hMAC_SHA1: univ.Null(""),
+ id_alg_CMSRC2wrap: RC2wrapParameter(),
+ id_alg_ESDH: KeyWrapAlgorithm(),
+ id_alg_SSDH: KeyWrapAlgorithm(),
+}
+
+rfc5280.algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)
+
+
+# Update the S/MIME Capabilities map in rfc5751.py.
+
+_smimeCapabilityMapUpdate = {
+ id_alg_CMSRC2wrap: RC2wrapParameter(),
+ id_alg_ESDH: KeyWrapAlgorithm(),
+ id_alg_SSDH: KeyWrapAlgorithm(),
+}
+
+rfc5751.smimeCapabilityMap.update(_smimeCapabilityMapUpdate)
diff --git a/pyasn1_modules/rfc3412.py b/pyasn1_modules/rfc3412.py
index 59f8495..2cf1e10 100644
--- a/pyasn1_modules/rfc3412.py
+++ b/pyasn1_modules/rfc3412.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# SNMPv3 message syntax
diff --git a/pyasn1_modules/rfc3414.py b/pyasn1_modules/rfc3414.py
index b9087cb..00420cb 100644
--- a/pyasn1_modules/rfc3414.py
+++ b/pyasn1_modules/rfc3414.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# SNMPv3 message syntax
diff --git a/pyasn1_modules/rfc3447.py b/pyasn1_modules/rfc3447.py
index c3621a0..3352b70 100644
--- a/pyasn1_modules/rfc3447.py
+++ b/pyasn1_modules/rfc3447.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# PKCS#1 syntax
diff --git a/pyasn1_modules/rfc3537.py b/pyasn1_modules/rfc3537.py
new file mode 100644
index 0000000..374dd81
--- /dev/null
+++ b/pyasn1_modules/rfc3537.py
@@ -0,0 +1,34 @@
+#
+# 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
+#
+# SEED Encryption Algorithm in CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc4010.txt
+#
+
+from pyasn1.type import constraint
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+
+id_alg_HMACwith3DESwrap = univ.ObjectIdentifier('1.2.840.113549.1.9.16.3.11')
+
+
+id_alg_HMACwithAESwrap = univ.ObjectIdentifier('1.2.840.113549.1.9.16.3.12')
+
+
+# Update the Algorithm Identifier map in rfc5280.py.
+
+_algorithmIdentifierMapUpdate = {
+ id_alg_HMACwith3DESwrap: univ.Null(""),
+ id_alg_HMACwithAESwrap: univ.Null(""),
+}
+
+rfc5280.algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)
diff --git a/pyasn1_modules/rfc3657.py b/pyasn1_modules/rfc3657.py
new file mode 100644
index 0000000..ebf23da
--- /dev/null
+++ b/pyasn1_modules/rfc3657.py
@@ -0,0 +1,66 @@
+#
+# 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
+#
+# Camellia Algorithm in CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc3657.txt
+#
+
+from pyasn1.type import constraint
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5751
+
+
+id_camellia128_cbc = univ.ObjectIdentifier('1.2.392.200011.61.1.1.1.2')
+
+id_camellia192_cbc = univ.ObjectIdentifier('1.2.392.200011.61.1.1.1.3')
+
+id_camellia256_cbc = univ.ObjectIdentifier('1.2.392.200011.61.1.1.1.4')
+
+id_camellia128_wrap = univ.ObjectIdentifier('1.2.392.200011.61.1.1.3.2')
+
+id_camellia192_wrap = univ.ObjectIdentifier('1.2.392.200011.61.1.1.3.3')
+
+id_camellia256_wrap = univ.ObjectIdentifier('1.2.392.200011.61.1.1.3.4')
+
+
+
+class Camellia_IV(univ.OctetString):
+ subtypeSpec = constraint.ValueSizeConstraint(16, 16)
+
+
+class CamelliaSMimeCapability(univ.Null):
+ pass
+
+
+# Update the Algorithm Identifier map in rfc5280.py.
+
+_algorithmIdentifierMapUpdate = {
+ id_camellia128_cbc: Camellia_IV(),
+ id_camellia192_cbc: Camellia_IV(),
+ id_camellia256_cbc: Camellia_IV(),
+}
+
+rfc5280.algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)
+
+
+# Update the SMIMECapabilities Attribute map in rfc5751.py
+
+_smimeCapabilityMapUpdate = {
+ id_camellia128_cbc: CamelliaSMimeCapability(),
+ id_camellia192_cbc: CamelliaSMimeCapability(),
+ id_camellia256_cbc: CamelliaSMimeCapability(),
+ id_camellia128_wrap: CamelliaSMimeCapability(),
+ id_camellia192_wrap: CamelliaSMimeCapability(),
+ id_camellia256_wrap: CamelliaSMimeCapability(),
+}
+
+rfc5751.smimeCapabilityMap.update(_smimeCapabilityMapUpdate)
diff --git a/pyasn1_modules/rfc3739.py b/pyasn1_modules/rfc3739.py
new file mode 100644
index 0000000..4aa5aaf
--- /dev/null
+++ b/pyasn1_modules/rfc3739.py
@@ -0,0 +1,203 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley with assistance from asn1ate v.0.6.0.
+# Modified by Russ Housley to add WithComponentsConstraints to
+# enforce the requirements that are indicated in comments.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Qualified Certificates
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc3739.txt
+#
+
+from pyasn1.type import char
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import namedval
+from pyasn1.type import opentype
+from pyasn1.type import univ
+from pyasn1.type import useful
+
+from pyasn1_modules import rfc5280
+
+MAX = float('inf')
+
+
+# Initialize the qcStatement map
+
+qcStatementMap = { }
+
+
+# Imports from RFC 5280
+
+AlgorithmIdentifier = rfc5280.AlgorithmIdentifier
+
+AttributeType = rfc5280.AttributeType
+
+DirectoryString = rfc5280.DirectoryString
+
+GeneralName = rfc5280.GeneralName
+
+id_pkix = rfc5280.id_pkix
+
+id_pe = rfc5280.id_pe
+
+
+# Arc for QC personal data attributes
+
+id_pda = id_pkix + (9, )
+
+
+# Arc for QC statements
+
+id_qcs = id_pkix + (11, )
+
+
+# Personal data attributes
+
+id_pda_dateOfBirth = id_pda + (1, )
+
+class DateOfBirth(useful.GeneralizedTime):
+ pass
+
+
+id_pda_placeOfBirth = id_pda + (2, )
+
+class PlaceOfBirth(DirectoryString):
+ pass
+
+
+id_pda_gender = id_pda + (3, )
+
+class Gender(char.PrintableString):
+ subtypeSpec = constraint.ConstraintsIntersection(
+ constraint.ValueSizeConstraint(1, 1),
+ constraint.SingleValueConstraint('M', 'F', 'm', 'f')
+ )
+
+
+id_pda_countryOfCitizenship = id_pda + (4, )
+
+class CountryOfCitizenship(char.PrintableString):
+ subtypeSpec = constraint.ValueSizeConstraint(2, 2)
+ # ISO 3166 Country Code
+
+
+id_pda_countryOfResidence = id_pda + (5, )
+
+class CountryOfResidence(char.PrintableString):
+ subtypeSpec = constraint.ValueSizeConstraint(2, 2)
+ # ISO 3166 Country Code
+
+
+# Biometric info certificate extension
+
+id_pe_biometricInfo = id_pe + (2, )
+
+
+class PredefinedBiometricType(univ.Integer):
+ namedValues = namedval.NamedValues(
+ ('picture', 0),
+ ('handwritten-signature', 1)
+ )
+ subtypeSpec = constraint.SingleValueConstraint(0, 1)
+
+
+class TypeOfBiometricData(univ.Choice):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('predefinedBiometricType', PredefinedBiometricType()),
+ namedtype.NamedType('biometricDataOid', univ.ObjectIdentifier())
+ )
+
+
+class BiometricData(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('typeOfBiometricData', TypeOfBiometricData()),
+ namedtype.NamedType('hashAlgorithm', AlgorithmIdentifier()),
+ namedtype.NamedType('biometricDataHash', univ.OctetString()),
+ namedtype.OptionalNamedType('sourceDataUri', char.IA5String())
+ )
+
+
+class BiometricSyntax(univ.SequenceOf):
+ componentType = BiometricData()
+
+
+# QC Statements certificate extension
+# NOTE: This extension does not allow to mix critical and
+# non-critical Qualified Certificate Statements. Either all
+# statements must be critical or all statements must be
+# non-critical.
+
+id_pe_qcStatements = id_pe + (3, )
+
+
+class NameRegistrationAuthorities(univ.SequenceOf):
+ componentType = GeneralName()
+ subtypeSpec=constraint.ValueSizeConstraint(1, MAX)
+
+
+class QCStatement(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('statementId', univ.ObjectIdentifier()),
+ namedtype.OptionalNamedType('statementInfo', univ.Any(),
+ openType=opentype.OpenType('statementId', qcStatementMap))
+ )
+
+
+class QCStatements(univ.SequenceOf):
+ componentType = QCStatement()
+
+
+class SemanticsInformation(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('semanticsIndentifier',
+ univ.ObjectIdentifier()),
+ namedtype.OptionalNamedType('nameRegistrationAuthorities',
+ NameRegistrationAuthorities())
+ )
+ subtypeSpec = constraint.ConstraintsUnion(
+ constraint.WithComponentsConstraint(
+ ('semanticsIndentifier', constraint.ComponentPresentConstraint())),
+ constraint.WithComponentsConstraint(
+ ('nameRegistrationAuthorities', constraint.ComponentPresentConstraint()))
+ )
+
+
+id_qcs = id_pkix + (11, )
+
+
+id_qcs_pkixQCSyntax_v1 = id_qcs + (1, )
+
+
+id_qcs_pkixQCSyntax_v2 = id_qcs + (2, )
+
+
+# Map of Certificate Extension OIDs to Extensions
+# To be added to the ones that are in rfc5280.py
+
+_certificateExtensionsMap = {
+ id_pe_biometricInfo: BiometricSyntax(),
+ id_pe_qcStatements: QCStatements(),
+}
+
+rfc5280.certificateExtensionsMap.update(_certificateExtensionsMap)
+
+
+# Map of AttributeType OIDs to AttributeValue added to the
+# ones that are in rfc5280.py
+
+_certificateAttributesMapUpdate = {
+ id_pda_dateOfBirth: DateOfBirth(),
+ id_pda_placeOfBirth: PlaceOfBirth(),
+ id_pda_gender: Gender(),
+ id_pda_countryOfCitizenship: CountryOfCitizenship(),
+ id_pda_countryOfResidence: CountryOfResidence(),
+}
+
+rfc5280.certificateAttributesMap.update(_certificateAttributesMapUpdate)
+
diff --git a/pyasn1_modules/rfc3820.py b/pyasn1_modules/rfc3820.py
new file mode 100644
index 0000000..b4ba34c
--- /dev/null
+++ b/pyasn1_modules/rfc3820.py
@@ -0,0 +1,65 @@
+#
+# 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
+#
+# Diffie-Hellman Key Agreement
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc3820.txt
+#
+
+from pyasn1.type import namedtype
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+
+
+class ProxyCertPathLengthConstraint(univ.Integer):
+ pass
+
+
+class ProxyPolicy(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('policyLanguage', univ.ObjectIdentifier()),
+ namedtype.OptionalNamedType('policy', univ.OctetString())
+ )
+
+
+class ProxyCertInfoExtension(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('pCPathLenConstraint',
+ ProxyCertPathLengthConstraint()),
+ namedtype.NamedType('proxyPolicy', ProxyPolicy())
+ )
+
+
+id_pkix = univ.ObjectIdentifier((1, 3, 6, 1, 5, 5, 7, ))
+
+
+id_pe = id_pkix + (1, )
+
+id_pe_proxyCertInfo = id_pe + (14, )
+
+
+id_ppl = id_pkix + (21, )
+
+id_ppl_anyLanguage = id_ppl + (0, )
+
+id_ppl_inheritAll = id_ppl + (1, )
+
+id_ppl_independent = id_ppl + (2, )
+
+
+# Map of Certificate Extension OIDs to Extensions added to the
+# ones that are in rfc5280.py
+
+_certificateExtensionsMapUpdate = {
+ id_pe_proxyCertInfo: ProxyCertInfoExtension(),
+}
+
+rfc5280.certificateExtensionsMap.update(_certificateExtensionsMapUpdate)
diff --git a/pyasn1_modules/rfc3852.py b/pyasn1_modules/rfc3852.py
index d294c5b..cf1bb85 100644
--- a/pyasn1_modules/rfc3852.py
+++ b/pyasn1_modules/rfc3852.py
@@ -3,7 +3,7 @@
# This file is part of pyasn1-modules software.
#
# Created by Stanisław Pitucha with asn1ate tool.
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Cryptographic Message Syntax (CMS)
diff --git a/pyasn1_modules/rfc4010.py b/pyasn1_modules/rfc4010.py
new file mode 100644
index 0000000..4981f76
--- /dev/null
+++ b/pyasn1_modules/rfc4010.py
@@ -0,0 +1,58 @@
+#
+# 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
+#
+# SEED Encryption Algorithm in CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc4010.txt
+#
+
+from pyasn1.type import constraint
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5751
+
+
+id_seedCBC = univ.ObjectIdentifier('1.2.410.200004.1.4')
+
+
+id_npki_app_cmsSeed_wrap = univ.ObjectIdentifier('1.2.410.200004.7.1.1.1')
+
+
+class SeedIV(univ.OctetString):
+ subtypeSpec = constraint.ValueSizeConstraint(16, 16)
+
+
+class SeedCBCParameter(SeedIV):
+ pass
+
+
+class SeedSMimeCapability(univ.Null):
+ pass
+
+
+# Update the Algorithm Identifier map in rfc5280.py.
+
+_algorithmIdentifierMapUpdate = {
+ id_seedCBC: SeedCBCParameter(),
+ id_npki_app_cmsSeed_wrap: univ.Null(""),
+}
+
+rfc5280.algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)
+
+
+# Update the SMIMECapabilities Attribute map in rfc5751.py
+
+_smimeCapabilityMapUpdate = {
+ id_seedCBC: SeedSMimeCapability(),
+ id_npki_app_cmsSeed_wrap: SeedSMimeCapability(),
+
+}
+
+rfc5751.smimeCapabilityMap.update(_smimeCapabilityMapUpdate)
diff --git a/pyasn1_modules/rfc4210.py b/pyasn1_modules/rfc4210.py
index 4d01a33..0935e3e 100644
--- a/pyasn1_modules/rfc4210.py
+++ b/pyasn1_modules/rfc4210.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Certificate Management Protocol structures as per RFC4210
diff --git a/pyasn1_modules/rfc4211.py b/pyasn1_modules/rfc4211.py
index 9783058..c47b3c5 100644
--- a/pyasn1_modules/rfc4211.py
+++ b/pyasn1_modules/rfc4211.py
@@ -3,7 +3,7 @@
# This file is part of pyasn1-modules software.
#
# Created by Stanisław Pitucha with asn1ate tool.
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Internet X.509 Public Key Infrastructure Certificate Request
diff --git a/pyasn1_modules/rfc4357.py b/pyasn1_modules/rfc4357.py
new file mode 100644
index 0000000..42b9e3e
--- /dev/null
+++ b/pyasn1_modules/rfc4357.py
@@ -0,0 +1,477 @@
+#
+# 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
+#
+# Additional Cryptographic Algorithms for Use with GOST 28147-89,
+# GOST R 34.10-94, GOST R 34.10-2001, and GOST R 34.11-94 Algorithms
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc4357.txt
+# https://www.rfc-editor.org/errata/eid5927
+# https://www.rfc-editor.org/errata/eid5928
+#
+
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import namedval
+from pyasn1.type import tag
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+
+# Import from RFC 5280
+
+AlgorithmIdentifier = rfc5280.AlgorithmIdentifier
+
+
+# Object Identifiers
+
+id_CryptoPro = univ.ObjectIdentifier((1, 2, 643, 2, 2,))
+
+
+id_CryptoPro_modules = id_CryptoPro + (1, 1,)
+
+id_CryptoPro_extensions = id_CryptoPro + (34,)
+
+id_CryptoPro_policyIds = id_CryptoPro + (38,)
+
+id_CryptoPro_policyQt = id_CryptoPro + (39,)
+
+
+cryptographic_Gost_Useful_Definitions = id_CryptoPro_modules + (0, 1,)
+
+gostR3411_94_DigestSyntax = id_CryptoPro_modules + (1, 1,)
+
+gostR3410_94_PKISyntax = id_CryptoPro_modules + (2, 1,)
+
+gostR3410_94_SignatureSyntax = id_CryptoPro_modules + (3, 1,)
+
+gost28147_89_EncryptionSyntax = id_CryptoPro_modules + (4, 1,)
+
+gostR3410_EncryptionSyntax = id_CryptoPro_modules + (5, 2,)
+
+gost28147_89_ParamSetSyntax = id_CryptoPro_modules + (6, 1,)
+
+gostR3411_94_ParamSetSyntax = id_CryptoPro_modules + (7, 1,)
+
+gostR3410_94_ParamSetSyntax = id_CryptoPro_modules + (8, 1, 1)
+
+gostR3410_2001_PKISyntax = id_CryptoPro_modules + (9, 1,)
+
+gostR3410_2001_SignatureSyntax = id_CryptoPro_modules + (10, 1,)
+
+gostR3410_2001_ParamSetSyntax = id_CryptoPro_modules + (12, 1,)
+
+gost_CryptoPro_ExtendedKeyUsage = id_CryptoPro_modules + (13, 1,)
+
+gost_CryptoPro_PrivateKey = id_CryptoPro_modules + (14, 1,)
+
+gost_CryptoPro_PKIXCMP = id_CryptoPro_modules + (15, 1,)
+
+gost_CryptoPro_TLS = id_CryptoPro_modules + (16, 1,)
+
+gost_CryptoPro_Policy = id_CryptoPro_modules + (17, 1,)
+
+gost_CryptoPro_Constants = id_CryptoPro_modules + (18, 1,)
+
+
+id_CryptoPro_algorithms = id_CryptoPro
+
+id_GostR3411_94_with_GostR3410_2001 = id_CryptoPro_algorithms + (3,)
+
+id_GostR3411_94_with_GostR3410_94 = id_CryptoPro_algorithms + (4,)
+
+id_GostR3411_94 = id_CryptoPro_algorithms + (9,)
+
+id_Gost28147_89_None_KeyMeshing = id_CryptoPro_algorithms + (14, 0,)
+
+id_Gost28147_89_CryptoPro_KeyMeshing = id_CryptoPro_algorithms + (14, 1,)
+
+id_GostR3410_2001 = id_CryptoPro_algorithms + (19,)
+
+id_GostR3410_94 = id_CryptoPro_algorithms + (20,)
+
+id_Gost28147_89 = id_CryptoPro_algorithms + (21,)
+
+id_Gost28147_89_MAC = id_CryptoPro_algorithms + (22,)
+
+id_CryptoPro_hashes = id_CryptoPro_algorithms + (30,)
+
+id_CryptoPro_encrypts = id_CryptoPro_algorithms + (31,)
+
+id_CryptoPro_signs = id_CryptoPro_algorithms + (32,)
+
+id_CryptoPro_exchanges = id_CryptoPro_algorithms + (33,)
+
+id_CryptoPro_ecc_signs = id_CryptoPro_algorithms + (35,)
+
+id_CryptoPro_ecc_exchanges = id_CryptoPro_algorithms + (36,)
+
+id_CryptoPro_private_keys = id_CryptoPro_algorithms + (37,)
+
+id_CryptoPro_pkixcmp_infos = id_CryptoPro_algorithms + (41,)
+
+id_CryptoPro_audit_service_types = id_CryptoPro_algorithms + (42,)
+
+id_CryptoPro_audit_record_types = id_CryptoPro_algorithms + (43,)
+
+id_CryptoPro_attributes = id_CryptoPro_algorithms + (44,)
+
+id_CryptoPro_name_service_types = id_CryptoPro_algorithms + (45,)
+
+id_GostR3410_2001DH = id_CryptoPro_algorithms + (98,)
+
+id_GostR3410_94DH = id_CryptoPro_algorithms + (99,)
+
+
+id_Gost28147_89_TestParamSet = id_CryptoPro_encrypts + (0,)
+
+id_Gost28147_89_CryptoPro_A_ParamSet = id_CryptoPro_encrypts + (1,)
+
+id_Gost28147_89_CryptoPro_B_ParamSet = id_CryptoPro_encrypts + (2,)
+
+id_Gost28147_89_CryptoPro_C_ParamSet = id_CryptoPro_encrypts + (3,)
+
+id_Gost28147_89_CryptoPro_D_ParamSet = id_CryptoPro_encrypts + (4,)
+
+id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet = id_CryptoPro_encrypts + (5,)
+
+id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet = id_CryptoPro_encrypts + (6,)
+
+id_Gost28147_89_CryptoPro_RIC_1_ParamSet = id_CryptoPro_encrypts + (7,)
+
+
+id_GostR3410_2001_TestParamSet = id_CryptoPro_ecc_signs + (0,)
+
+id_GostR3410_2001_CryptoPro_A_ParamSet = id_CryptoPro_ecc_signs + (1,)
+
+id_GostR3410_2001_CryptoPro_B_ParamSet = id_CryptoPro_ecc_signs + (2,)
+
+id_GostR3410_2001_CryptoPro_C_ParamSet = id_CryptoPro_ecc_signs + (3,)
+
+
+id_GostR3410_2001_CryptoPro_XchA_ParamSet = id_CryptoPro_ecc_exchanges + (0,)
+
+id_GostR3410_2001_CryptoPro_XchB_ParamSet = id_CryptoPro_ecc_exchanges + (1,)
+
+
+id_GostR3410_94_TestParamSet = id_CryptoPro_signs + (0,)
+
+id_GostR3410_94_CryptoPro_A_ParamSet = id_CryptoPro_signs + (2,)
+
+id_GostR3410_94_CryptoPro_B_ParamSet = id_CryptoPro_signs + (3,)
+
+id_GostR3410_94_CryptoPro_C_ParamSet = id_CryptoPro_signs + (4,)
+
+id_GostR3410_94_CryptoPro_D_ParamSet = id_CryptoPro_signs + (5,)
+
+
+id_GostR3410_94_CryptoPro_XchA_ParamSet = id_CryptoPro_exchanges + (1,)
+
+id_GostR3410_94_CryptoPro_XchB_ParamSet = id_CryptoPro_exchanges + (2,)
+
+id_GostR3410_94_CryptoPro_XchC_ParamSet = id_CryptoPro_exchanges + (3,)
+
+
+id_GostR3410_94_a = id_GostR3410_94 + (1,)
+
+id_GostR3410_94_aBis = id_GostR3410_94 + (2,)
+
+id_GostR3410_94_b = id_GostR3410_94 + (3,)
+
+id_GostR3410_94_bBis = id_GostR3410_94 + (4,)
+
+
+id_GostR3411_94_TestParamSet = id_CryptoPro_hashes + (0,)
+
+id_GostR3411_94_CryptoProParamSet = id_CryptoPro_hashes + (1,)
+
+
+
+
+class Gost28147_89_ParamSet(univ.ObjectIdentifier):
+ pass
+
+Gost28147_89_ParamSet.subtypeSpec = constraint.SingleValueConstraint(
+ id_Gost28147_89_TestParamSet,
+ id_Gost28147_89_CryptoPro_A_ParamSet,
+ id_Gost28147_89_CryptoPro_B_ParamSet,
+ id_Gost28147_89_CryptoPro_C_ParamSet,
+ id_Gost28147_89_CryptoPro_D_ParamSet,
+ id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet,
+ id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet,
+ id_Gost28147_89_CryptoPro_RIC_1_ParamSet
+)
+
+
+class Gost28147_89_BlobParameters(univ.Sequence):
+ pass
+
+Gost28147_89_BlobParameters.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('encryptionParamSet', Gost28147_89_ParamSet())
+)
+
+
+class Gost28147_89_MAC(univ.OctetString):
+ pass
+
+Gost28147_89_MAC.subtypeSpec = constraint.ValueSizeConstraint(1, 4)
+
+
+class Gost28147_89_Key(univ.OctetString):
+ pass
+
+Gost28147_89_Key.subtypeSpec = constraint.ValueSizeConstraint(32, 32)
+
+
+class Gost28147_89_EncryptedKey(univ.Sequence):
+ pass
+
+Gost28147_89_EncryptedKey.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('encryptedKey', Gost28147_89_Key()),
+ namedtype.OptionalNamedType('maskKey', Gost28147_89_Key().subtype(
+ implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.NamedType('macKey', Gost28147_89_MAC())
+)
+
+
+class Gost28147_89_IV(univ.OctetString):
+ pass
+
+Gost28147_89_IV.subtypeSpec = constraint.ValueSizeConstraint(8, 8)
+
+
+class Gost28147_89_UZ(univ.OctetString):
+ pass
+
+Gost28147_89_UZ.subtypeSpec = constraint.ValueSizeConstraint(64, 64)
+
+
+class Gost28147_89_ParamSetParameters(univ.Sequence):
+ pass
+
+Gost28147_89_ParamSetParameters.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('eUZ', Gost28147_89_UZ()),
+ namedtype.NamedType('mode',
+ univ.Integer(namedValues=namedval.NamedValues(
+ ('gost28147-89-CNT', 0),
+ ('gost28147-89-CFB', 1),
+ ('cryptoPro-CBC', 2)
+ ))),
+ namedtype.NamedType('shiftBits',
+ univ.Integer(namedValues=namedval.NamedValues(
+ ('gost28147-89-block', 64)
+ ))),
+ namedtype.NamedType('keyMeshing', AlgorithmIdentifier())
+)
+
+
+class Gost28147_89_Parameters(univ.Sequence):
+ pass
+
+Gost28147_89_Parameters.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('iv', Gost28147_89_IV()),
+ namedtype.NamedType('encryptionParamSet', Gost28147_89_ParamSet())
+)
+
+
+class GostR3410_2001_CertificateSignature(univ.BitString):
+ pass
+
+GostR3410_2001_CertificateSignature.subtypeSpec=constraint.ValueSizeConstraint(256, 512)
+
+
+class GostR3410_2001_ParamSetParameters(univ.Sequence):
+ pass
+
+GostR3410_2001_ParamSetParameters.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('a', univ.Integer()),
+ namedtype.NamedType('b', univ.Integer()),
+ namedtype.NamedType('p', univ.Integer()),
+ namedtype.NamedType('q', univ.Integer()),
+ namedtype.NamedType('x', univ.Integer()),
+ namedtype.NamedType('y', univ.Integer())
+)
+
+
+class GostR3410_2001_PublicKey(univ.OctetString):
+ pass
+
+GostR3410_2001_PublicKey.subtypeSpec = constraint.ValueSizeConstraint(64, 64)
+
+
+class GostR3410_2001_PublicKeyParameters(univ.Sequence):
+ pass
+
+GostR3410_2001_PublicKeyParameters.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('publicKeyParamSet', univ.ObjectIdentifier().subtype(
+ subtypeSpec=constraint.SingleValueConstraint(
+ id_GostR3410_2001_TestParamSet,
+ id_GostR3410_2001_CryptoPro_A_ParamSet,
+ id_GostR3410_2001_CryptoPro_B_ParamSet,
+ id_GostR3410_2001_CryptoPro_C_ParamSet,
+ id_GostR3410_2001_CryptoPro_XchA_ParamSet,
+ id_GostR3410_2001_CryptoPro_XchB_ParamSet
+ ))),
+ namedtype.NamedType('digestParamSet', univ.ObjectIdentifier().subtype(
+ subtypeSpec=constraint.SingleValueConstraint(
+ id_GostR3411_94_TestParamSet,
+ id_GostR3411_94_CryptoProParamSet
+ ))),
+ namedtype.DefaultedNamedType('encryptionParamSet',
+ Gost28147_89_ParamSet().subtype(value=id_Gost28147_89_CryptoPro_A_ParamSet
+ ))
+)
+
+
+class GostR3410_94_CertificateSignature(univ.BitString):
+ pass
+
+GostR3410_94_CertificateSignature.subtypeSpec = constraint.ValueSizeConstraint(256, 512)
+
+
+class GostR3410_94_ParamSetParameters_t(univ.Integer):
+ pass
+
+GostR3410_94_ParamSetParameters_t.subtypeSpec = constraint.SingleValueConstraint(512, 1024)
+
+
+class GostR3410_94_ParamSetParameters(univ.Sequence):
+ pass
+
+GostR3410_94_ParamSetParameters.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('t', GostR3410_94_ParamSetParameters_t()),
+ namedtype.NamedType('p', univ.Integer()),
+ namedtype.NamedType('q', univ.Integer()),
+ namedtype.NamedType('a', univ.Integer()),
+ namedtype.OptionalNamedType('validationAlgorithm', AlgorithmIdentifier())
+)
+
+
+class GostR3410_94_PublicKey(univ.OctetString):
+ pass
+
+GostR3410_94_PublicKey.subtypeSpec = constraint.ConstraintsUnion(
+ constraint.ValueSizeConstraint(64, 64),
+ constraint.ValueSizeConstraint(128, 128)
+)
+
+
+class GostR3410_94_PublicKeyParameters(univ.Sequence):
+ pass
+
+GostR3410_94_PublicKeyParameters.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('publicKeyParamSet', univ.ObjectIdentifier().subtype(
+ subtypeSpec=constraint.SingleValueConstraint(
+ id_GostR3410_94_TestParamSet,
+ id_GostR3410_94_CryptoPro_A_ParamSet,
+ id_GostR3410_94_CryptoPro_B_ParamSet,
+ id_GostR3410_94_CryptoPro_C_ParamSet,
+ id_GostR3410_94_CryptoPro_D_ParamSet,
+ id_GostR3410_94_CryptoPro_XchA_ParamSet,
+ id_GostR3410_94_CryptoPro_XchB_ParamSet,
+ id_GostR3410_94_CryptoPro_XchC_ParamSet
+ ))),
+ namedtype.NamedType('digestParamSet', univ.ObjectIdentifier().subtype(
+ subtypeSpec=constraint.SingleValueConstraint(
+ id_GostR3411_94_TestParamSet,
+ id_GostR3411_94_CryptoProParamSet
+ ))),
+ namedtype.DefaultedNamedType('encryptionParamSet',
+ Gost28147_89_ParamSet().subtype(value=id_Gost28147_89_CryptoPro_A_ParamSet
+ ))
+)
+
+
+class GostR3410_94_ValidationBisParameters_c(univ.Integer):
+ pass
+
+GostR3410_94_ValidationBisParameters_c.subtypeSpec = constraint.ValueRangeConstraint(0, 4294967295)
+
+
+class GostR3410_94_ValidationBisParameters(univ.Sequence):
+ pass
+
+GostR3410_94_ValidationBisParameters.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('x0', GostR3410_94_ValidationBisParameters_c()),
+ namedtype.NamedType('c', GostR3410_94_ValidationBisParameters_c()),
+ namedtype.OptionalNamedType('d', univ.Integer())
+)
+
+
+class GostR3410_94_ValidationParameters_c(univ.Integer):
+ pass
+
+GostR3410_94_ValidationParameters_c.subtypeSpec = constraint.ValueRangeConstraint(0, 65535)
+
+
+class GostR3410_94_ValidationParameters(univ.Sequence):
+ pass
+
+GostR3410_94_ValidationParameters.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('x0', GostR3410_94_ValidationParameters_c()),
+ namedtype.NamedType('c', GostR3410_94_ValidationParameters_c()),
+ namedtype.OptionalNamedType('d', univ.Integer())
+)
+
+
+class GostR3411_94_Digest(univ.OctetString):
+ pass
+
+GostR3411_94_Digest.subtypeSpec = constraint.ValueSizeConstraint(32, 32)
+
+
+class GostR3411_94_DigestParameters(univ.ObjectIdentifier):
+ pass
+
+GostR3411_94_DigestParameters.subtypeSpec = constraint.ConstraintsUnion(
+ constraint.SingleValueConstraint(id_GostR3411_94_TestParamSet),
+ constraint.SingleValueConstraint(id_GostR3411_94_CryptoProParamSet),
+)
+
+
+class GostR3411_94_ParamSetParameters(univ.Sequence):
+ pass
+
+GostR3411_94_ParamSetParameters.componentType = namedtype.NamedTypes(
+ namedtype.NamedType('hUZ', Gost28147_89_UZ()),
+ namedtype.NamedType('h0', GostR3411_94_Digest())
+)
+
+
+# Update the Algorithm Identifier map in rfc5280.py
+
+_algorithmIdentifierMapUpdate = {
+ id_Gost28147_89: Gost28147_89_Parameters(),
+ id_Gost28147_89_TestParamSet: Gost28147_89_ParamSetParameters(),
+ id_Gost28147_89_CryptoPro_A_ParamSet: Gost28147_89_ParamSetParameters(),
+ id_Gost28147_89_CryptoPro_B_ParamSet: Gost28147_89_ParamSetParameters(),
+ id_Gost28147_89_CryptoPro_C_ParamSet: Gost28147_89_ParamSetParameters(),
+ id_Gost28147_89_CryptoPro_D_ParamSet: Gost28147_89_ParamSetParameters(),
+ id_Gost28147_89_CryptoPro_KeyMeshing: univ.Null(""),
+ id_Gost28147_89_None_KeyMeshing: univ.Null(""),
+ id_GostR3410_94: GostR3410_94_PublicKeyParameters(),
+ id_GostR3410_94_TestParamSet: GostR3410_94_ParamSetParameters(),
+ id_GostR3410_94_CryptoPro_A_ParamSet: GostR3410_94_ParamSetParameters(),
+ id_GostR3410_94_CryptoPro_B_ParamSet: GostR3410_94_ParamSetParameters(),
+ id_GostR3410_94_CryptoPro_C_ParamSet: GostR3410_94_ParamSetParameters(),
+ id_GostR3410_94_CryptoPro_D_ParamSet: GostR3410_94_ParamSetParameters(),
+ id_GostR3410_94_CryptoPro_XchA_ParamSet: GostR3410_94_ParamSetParameters(),
+ id_GostR3410_94_CryptoPro_XchB_ParamSet: GostR3410_94_ParamSetParameters(),
+ id_GostR3410_94_CryptoPro_XchC_ParamSet: GostR3410_94_ParamSetParameters(),
+ id_GostR3410_94_a: GostR3410_94_ValidationParameters(),
+ id_GostR3410_94_aBis: GostR3410_94_ValidationBisParameters(),
+ id_GostR3410_94_b: GostR3410_94_ValidationParameters(),
+ id_GostR3410_94_bBis: GostR3410_94_ValidationBisParameters(),
+ id_GostR3410_2001: univ.Null(""),
+ id_GostR3411_94: univ.Null(""),
+ id_GostR3411_94_TestParamSet: GostR3411_94_ParamSetParameters(),
+ id_GostR3411_94_CryptoProParamSet: GostR3411_94_ParamSetParameters(),
+}
+
+rfc5280.algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)
diff --git a/pyasn1_modules/rfc4387.py b/pyasn1_modules/rfc4387.py
new file mode 100644
index 0000000..c1f4e79
--- /dev/null
+++ b/pyasn1_modules/rfc4387.py
@@ -0,0 +1,23 @@
+#
+# 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
+#
+# Certificate Store Access via HTTP
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc4387.txt
+#
+
+
+from pyasn1.type import univ
+
+
+id_ad = univ.ObjectIdentifier((1, 3, 6, 1, 5, 5, 7, 48, ))
+
+id_ad_http_certs = id_ad + (6, )
+
+id_ad_http_crls = id_ad + (7,)
diff --git a/pyasn1_modules/rfc4476.py b/pyasn1_modules/rfc4476.py
new file mode 100644
index 0000000..25a0ccb
--- /dev/null
+++ b/pyasn1_modules/rfc4476.py
@@ -0,0 +1,93 @@
+#
+# 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
+#
+# Attribute Certificate Policies Extension
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc4476.txt
+#
+
+from pyasn1.type import char
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+MAX = float('inf')
+
+
+# Imports from RFC 5280
+
+PolicyQualifierId = rfc5280.PolicyQualifierId
+
+PolicyQualifierInfo = rfc5280.PolicyQualifierInfo
+
+UserNotice = rfc5280.UserNotice
+
+id_pkix = rfc5280.id_pkix
+
+
+# Object Identifiers
+
+id_pe = id_pkix + (1,)
+
+id_pe_acPolicies = id_pe + (15,)
+
+id_qt = id_pkix + (2,)
+
+id_qt_acps = id_qt + (4,)
+
+id_qt_acunotice = id_qt + (5,)
+
+
+# Attribute Certificate Policies Extension
+
+class ACUserNotice(UserNotice):
+ pass
+
+
+class ACPSuri(char.IA5String):
+ pass
+
+
+class AcPolicyId(univ.ObjectIdentifier):
+ pass
+
+
+class PolicyInformation(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('policyIdentifier', AcPolicyId()),
+ namedtype.OptionalNamedType('policyQualifiers',
+ univ.SequenceOf(componentType=PolicyQualifierInfo()).subtype(
+ subtypeSpec=constraint.ValueSizeConstraint(1, MAX)))
+ )
+
+
+class AcPoliciesSyntax(univ.SequenceOf):
+ componentType = PolicyInformation()
+ subtypeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+
+# Update the policy qualifier map in rfc5280.py
+
+_policyQualifierInfoMapUpdate = {
+ id_qt_acps: ACPSuri(),
+ id_qt_acunotice: UserNotice(),
+}
+
+rfc5280.policyQualifierInfoMap.update(_policyQualifierInfoMapUpdate)
+
+
+# Update the certificate extension map in rfc5280.py
+
+_certificateExtensionsMapUpdate = {
+ id_pe_acPolicies: AcPoliciesSyntax(),
+}
+
+rfc5280.certificateExtensionsMap.update(_certificateExtensionsMapUpdate)
diff --git a/pyasn1_modules/rfc4490.py b/pyasn1_modules/rfc4490.py
new file mode 100644
index 0000000..b8fe321
--- /dev/null
+++ b/pyasn1_modules/rfc4490.py
@@ -0,0 +1,113 @@
+#
+# 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
+#
+# Using the GOST 28147-89, GOST R 34.11-94, GOST R 34.10-94, and
+# GOST R 34.10-2001 Algorithms with the CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc4490.txt
+#
+
+
+from pyasn1.type import univ, char, namedtype, namedval, tag, constraint, useful
+
+from pyasn1_modules import rfc4357
+from pyasn1_modules import rfc5280
+
+
+# Imports from RFC 4357
+
+id_CryptoPro_algorithms = rfc4357.id_CryptoPro_algorithms
+
+id_GostR3410_94 = rfc4357.id_GostR3410_94
+
+id_GostR3410_2001 = rfc4357.id_GostR3410_2001
+
+Gost28147_89_ParamSet = rfc4357.Gost28147_89_ParamSet
+
+Gost28147_89_EncryptedKey = rfc4357.Gost28147_89_EncryptedKey
+
+GostR3410_94_PublicKeyParameters = rfc4357.GostR3410_94_PublicKeyParameters
+
+GostR3410_2001_PublicKeyParameters = rfc4357.GostR3410_2001_PublicKeyParameters
+
+
+# Imports from RFC 5280
+
+SubjectPublicKeyInfo = rfc5280.SubjectPublicKeyInfo
+
+
+# CMS/PKCS#7 key agreement algorithms & parameters
+
+class Gost28147_89_KeyWrapParameters(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('encryptionParamSet', Gost28147_89_ParamSet()),
+ namedtype.OptionalNamedType('ukm', univ.OctetString().subtype(
+ subtypeSpec=constraint.ValueSizeConstraint(8, 8)))
+ )
+
+
+id_Gost28147_89_CryptoPro_KeyWrap = id_CryptoPro_algorithms + (13, 1, )
+
+
+id_Gost28147_89_None_KeyWrap = id_CryptoPro_algorithms + (13, 0, )
+
+
+id_GostR3410_2001_CryptoPro_ESDH = id_CryptoPro_algorithms + (96, )
+
+
+id_GostR3410_94_CryptoPro_ESDH = id_CryptoPro_algorithms + (97, )
+
+
+# CMS/PKCS#7 key transport algorithms & parameters
+
+id_GostR3410_2001_KeyTransportSMIMECapability = id_GostR3410_2001
+
+
+id_GostR3410_94_KeyTransportSMIMECapability = id_GostR3410_94
+
+
+class GostR3410_TransportParameters(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('encryptionParamSet', Gost28147_89_ParamSet()),
+ namedtype.OptionalNamedType('ephemeralPublicKey',
+ SubjectPublicKeyInfo().subtype(implicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.NamedType('ukm', univ.OctetString().subtype(
+ subtypeSpec=constraint.ValueSizeConstraint(8, 8)))
+ )
+
+class GostR3410_KeyTransport(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('sessionEncryptedKey', Gost28147_89_EncryptedKey()),
+ namedtype.OptionalNamedType('transportParameters',
+ GostR3410_TransportParameters().subtype(implicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 0)))
+ )
+
+
+# GOST R 34.10-94 signature algorithm & parameters
+
+class GostR3410_94_Signature(univ.OctetString):
+ subtypeSpec = constraint.ValueSizeConstraint(64, 64)
+
+
+# GOST R 34.10-2001 signature algorithms and parameters
+
+class GostR3410_2001_Signature(univ.OctetString):
+ subtypeSpec = constraint.ValueSizeConstraint(64, 64)
+
+
+# Update the Algorithm Identifier map in rfc5280.py
+
+_algorithmIdentifierMapUpdate = {
+ id_Gost28147_89_CryptoPro_KeyWrap: Gost28147_89_KeyWrapParameters(),
+ id_Gost28147_89_None_KeyWrap: Gost28147_89_KeyWrapParameters(),
+}
+
+rfc5280.algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)
diff --git a/pyasn1_modules/rfc4491.py b/pyasn1_modules/rfc4491.py
new file mode 100644
index 0000000..60b5560
--- /dev/null
+++ b/pyasn1_modules/rfc4491.py
@@ -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
+#
+# Using the GOST R 34.10-94, GOST R 34.10-2001, and GOST R 34.11-94
+# Algorithms with Certificates and CRLs
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc4491.txt
+#
+
+from pyasn1_modules import rfc4357
+
+
+# Signature Algorithm GOST R 34.10-94
+
+id_GostR3411_94_with_GostR3410_94 = rfc4357.id_GostR3411_94_with_GostR3410_94
+
+
+# Signature Algorithm GOST R 34.10-2001
+
+id_GostR3411_94_with_GostR3410_2001 = rfc4357.id_GostR3411_94_with_GostR3410_2001
+
+
+# GOST R 34.10-94 Keys
+
+id_GostR3410_94 = rfc4357.id_GostR3410_94
+
+GostR3410_2001_PublicKey = rfc4357.GostR3410_2001_PublicKey
+
+GostR3410_2001_PublicKeyParameters = rfc4357.GostR3410_2001_PublicKeyParameters
+
+
+# GOST R 34.10-2001 Keys
+
+id_GostR3410_2001 = rfc4357.id_GostR3410_2001
+
+GostR3410_94_PublicKey = rfc4357.GostR3410_94_PublicKey
+
+GostR3410_94_PublicKeyParameters = rfc4357.GostR3410_94_PublicKeyParameters
diff --git a/pyasn1_modules/rfc4683.py b/pyasn1_modules/rfc4683.py
new file mode 100644
index 0000000..11ac65a
--- /dev/null
+++ b/pyasn1_modules/rfc4683.py
@@ -0,0 +1,72 @@
+#
+# 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
+#
+# Subject Identification Method (SIM)
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc4683.txt
+# https://www.rfc-editor.org/errata/eid1047
+#
+
+from pyasn1.type import char
+from pyasn1.type import namedtype
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+
+# Used to compute the PEPSI value
+
+class HashContent(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('userPassword', char.UTF8String()),
+ namedtype.NamedType('authorityRandom', univ.OctetString()),
+ namedtype.NamedType('identifierType', univ.ObjectIdentifier()),
+ namedtype.NamedType('identifier', char.UTF8String())
+ )
+
+
+# Used to encode the PEPSI value as the SIM Other Name
+
+id_pkix = rfc5280.id_pkix
+
+id_on = id_pkix + (8,)
+
+id_on_SIM = id_on + (6,)
+
+
+class SIM(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('hashAlg', rfc5280.AlgorithmIdentifier()),
+ namedtype.NamedType('authorityRandom', univ.OctetString()),
+ namedtype.NamedType('pEPSI', univ.OctetString())
+ )
+
+
+# Used to encrypt the PEPSI value during certificate request
+
+id_pkip = id_pkix + (5,)
+
+id_regEPEPSI = id_pkip + (3,)
+
+
+class EncryptedPEPSI(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('identifierType', univ.ObjectIdentifier()),
+ namedtype.NamedType('identifier', char.UTF8String()),
+ namedtype.NamedType('sIM', SIM())
+ )
+
+
+# Update the map of Other Name OIDs to Other Names in rfc5280.py
+
+_anotherNameMapUpdate = {
+ id_on_SIM: SIM(),
+}
+
+rfc5280.anotherNameMap.update(_anotherNameMapUpdate)
diff --git a/pyasn1_modules/rfc5126.py b/pyasn1_modules/rfc5126.py
new file mode 100644
index 0000000..8e016c2
--- /dev/null
+++ b/pyasn1_modules/rfc5126.py
@@ -0,0 +1,577 @@
+#
+# 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 Advanced Electronic Signatures (CAdES)
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5126.txt
+#
+
+from pyasn1.type import char
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import opentype
+from pyasn1.type import tag
+from pyasn1.type import useful
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5035
+from pyasn1_modules import rfc5755
+from pyasn1_modules import rfc6960
+from pyasn1_modules import rfc3161
+
+MAX = float('inf')
+
+
+# Maps for OpenTypes
+
+commitmentQualifierMap = { }
+
+sigQualifiersMap = { }
+
+otherRevRefMap = { }
+
+otherRevValMap = { }
+
+
+# Imports from RFC 5652
+
+ContentInfo = rfc5652.ContentInfo
+
+ContentType = rfc5652.ContentType
+
+SignedData = rfc5652.SignedData
+
+EncapsulatedContentInfo = rfc5652.EncapsulatedContentInfo
+
+SignerInfo = rfc5652.SignerInfo
+
+MessageDigest = rfc5652.MessageDigest
+
+SigningTime = rfc5652.SigningTime
+
+Countersignature = rfc5652.Countersignature
+
+id_data = rfc5652.id_data
+
+id_signedData = rfc5652.id_signedData
+
+id_contentType= rfc5652.id_contentType
+
+id_messageDigest = rfc5652.id_messageDigest
+
+id_signingTime = rfc5652.id_signingTime
+
+id_countersignature = rfc5652.id_countersignature
+
+
+# Imports from RFC 5035
+
+SigningCertificate = rfc5035.SigningCertificate
+
+IssuerSerial = rfc5035.IssuerSerial
+
+ContentReference = rfc5035.ContentReference
+
+ContentIdentifier = rfc5035.ContentIdentifier
+
+id_aa_contentReference = rfc5035.id_aa_contentReference
+
+id_aa_contentIdentifier = rfc5035.id_aa_contentIdentifier
+
+id_aa_signingCertificate = rfc5035.id_aa_signingCertificate
+
+id_aa_signingCertificateV2 = rfc5035.id_aa_signingCertificateV2
+
+
+# Imports from RFC 5280
+
+Certificate = rfc5280.Certificate
+
+AlgorithmIdentifier = rfc5280.AlgorithmIdentifier
+
+CertificateList = rfc5280.CertificateList
+
+Name = rfc5280.Name
+
+Attribute = rfc5280.Attribute
+
+GeneralNames = rfc5280.GeneralNames
+
+GeneralName = rfc5280.GeneralName
+
+PolicyInformation = rfc5280.PolicyInformation
+
+DirectoryString = rfc5280.DirectoryString
+
+
+# Imports from RFC 5755
+
+AttributeCertificate = rfc5755.AttributeCertificate
+
+
+# Imports from RFC 6960
+
+BasicOCSPResponse = rfc6960.BasicOCSPResponse
+
+ResponderID = rfc6960.ResponderID
+
+
+# Imports from RFC 3161
+
+TimeStampToken = rfc3161.TimeStampToken
+
+
+# OID used referencing electronic signature mechanisms
+
+id_etsi_es_IDUP_Mechanism_v1 = univ.ObjectIdentifier('0.4.0.1733.1.4.1')
+
+
+# OtherSigningCertificate - deprecated
+
+id_aa_ets_otherSigCert = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.19')
+
+
+class OtherHashValue(univ.OctetString):
+ pass
+
+
+class OtherHashAlgAndValue(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('hashAlgorithm', AlgorithmIdentifier()),
+ namedtype.NamedType('hashValue', OtherHashValue())
+ )
+
+
+class OtherHash(univ.Choice):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('sha1Hash', OtherHashValue()),
+ namedtype.NamedType('otherHash', OtherHashAlgAndValue())
+ )
+
+
+class OtherCertID(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('otherCertHash', OtherHash()),
+ namedtype.OptionalNamedType('issuerSerial', IssuerSerial())
+ )
+
+
+class OtherSigningCertificate(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('certs',
+ univ.SequenceOf(componentType=OtherCertID())),
+ namedtype.OptionalNamedType('policies',
+ univ.SequenceOf(componentType=PolicyInformation()))
+ )
+
+
+# Signature Policy Identifier
+
+id_aa_ets_sigPolicyId = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.15')
+
+
+class SigPolicyId(univ.ObjectIdentifier):
+ pass
+
+
+class SigPolicyHash(OtherHashAlgAndValue):
+ pass
+
+
+class SigPolicyQualifierId(univ.ObjectIdentifier):
+ pass
+
+
+class SigPolicyQualifierInfo(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('sigPolicyQualifierId', SigPolicyQualifierId()),
+ namedtype.NamedType('sigQualifier', univ.Any(),
+ openType=opentype.OpenType('sigPolicyQualifierId', sigQualifiersMap))
+ )
+
+
+class SignaturePolicyId(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('sigPolicyId', SigPolicyId()),
+ namedtype.NamedType('sigPolicyHash', SigPolicyHash()),
+ namedtype.OptionalNamedType('sigPolicyQualifiers',
+ univ.SequenceOf(componentType=SigPolicyQualifierInfo()).subtype(
+ subtypeSpec=constraint.ValueSizeConstraint(1, MAX)))
+ )
+
+
+class SignaturePolicyImplied(univ.Null):
+ pass
+
+
+class SignaturePolicy(univ.Choice):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('signaturePolicyId', SignaturePolicyId()),
+ namedtype.NamedType('signaturePolicyImplied', SignaturePolicyImplied())
+ )
+
+
+id_spq_ets_unotice = univ.ObjectIdentifier('1.2.840.113549.1.9.16.5.2')
+
+
+class DisplayText(univ.Choice):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('visibleString', char.VisibleString().subtype(
+ subtypeSpec=constraint.ValueSizeConstraint(1, 200))),
+ namedtype.NamedType('bmpString', char.BMPString().subtype(
+ subtypeSpec=constraint.ValueSizeConstraint(1, 200))),
+ namedtype.NamedType('utf8String', char.UTF8String().subtype(
+ subtypeSpec=constraint.ValueSizeConstraint(1, 200)))
+ )
+
+
+class NoticeReference(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('organization', DisplayText()),
+ namedtype.NamedType('noticeNumbers',
+ univ.SequenceOf(componentType=univ.Integer()))
+ )
+
+class SPUserNotice(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('noticeRef', NoticeReference()),
+ namedtype.OptionalNamedType('explicitText', DisplayText())
+ )
+
+
+noticeToUser = SigPolicyQualifierInfo()
+noticeToUser['sigPolicyQualifierId'] = id_spq_ets_unotice
+noticeToUser['sigQualifier'] = SPUserNotice()
+
+
+id_spq_ets_uri = univ.ObjectIdentifier('1.2.840.113549.1.9.16.5.1')
+
+
+class SPuri(char.IA5String):
+ pass
+
+
+pointerToSigPolSpec = SigPolicyQualifierInfo()
+pointerToSigPolSpec['sigPolicyQualifierId'] = id_spq_ets_uri
+pointerToSigPolSpec['sigQualifier'] = SPuri()
+
+
+# Commitment Type
+
+id_aa_ets_commitmentType = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.16')
+
+
+class CommitmentTypeIdentifier(univ.ObjectIdentifier):
+ pass
+
+
+class CommitmentTypeQualifier(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('commitmentTypeIdentifier',
+ CommitmentTypeIdentifier()),
+ namedtype.NamedType('qualifier', univ.Any(),
+ openType=opentype.OpenType('commitmentTypeIdentifier',
+ commitmentQualifierMap))
+ )
+
+
+class CommitmentTypeIndication(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('commitmentTypeId', CommitmentTypeIdentifier()),
+ namedtype.OptionalNamedType('commitmentTypeQualifier',
+ univ.SequenceOf(componentType=CommitmentTypeQualifier()).subtype(
+ subtypeSpec=constraint.ValueSizeConstraint(1, MAX)))
+ )
+
+
+id_cti_ets_proofOfOrigin = univ.ObjectIdentifier('1.2.840.113549.1.9.16.6.1')
+
+id_cti_ets_proofOfReceipt = univ.ObjectIdentifier('1.2.840.113549.1.9.16.6.2')
+
+id_cti_ets_proofOfDelivery = univ.ObjectIdentifier('1.2.840.113549.1.9.16.6.3')
+
+id_cti_ets_proofOfSender = univ.ObjectIdentifier('1.2.840.113549.1.9.16.6.4')
+
+id_cti_ets_proofOfApproval = univ.ObjectIdentifier('1.2.840.113549.1.9.16.6.5')
+
+id_cti_ets_proofOfCreation = univ.ObjectIdentifier('1.2.840.113549.1.9.16.6.6')
+
+
+# Signer Location
+
+id_aa_ets_signerLocation = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.17')
+
+
+class PostalAddress(univ.SequenceOf):
+ componentType = DirectoryString()
+ subtypeSpec = constraint.ValueSizeConstraint(1, 6)
+
+
+class SignerLocation(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('countryName',
+ DirectoryString().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('localityName',
+ DirectoryString().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1))),
+ namedtype.OptionalNamedType('postalAdddress',
+ PostalAddress().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 2)))
+ )
+
+
+# Signature Timestamp
+
+id_aa_signatureTimeStampToken = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.14')
+
+
+class SignatureTimeStampToken(TimeStampToken):
+ pass
+
+
+# Content Timestamp
+
+id_aa_ets_contentTimestamp = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.20')
+
+
+class ContentTimestamp(TimeStampToken):
+ pass
+
+
+# Signer Attributes
+
+id_aa_ets_signerAttr = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.18')
+
+
+class ClaimedAttributes(univ.SequenceOf):
+ componentType = Attribute()
+
+
+class CertifiedAttributes(AttributeCertificate):
+ pass
+
+
+class SignerAttribute(univ.SequenceOf):
+ componentType = univ.Choice(componentType=namedtype.NamedTypes(
+ namedtype.NamedType('claimedAttributes',
+ ClaimedAttributes().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.NamedType('certifiedAttributes',
+ CertifiedAttributes().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1)))
+ ))
+
+
+# Complete Certificate Refs
+
+id_aa_ets_certificateRefs = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.21')
+
+
+class CompleteCertificateRefs(univ.SequenceOf):
+ componentType = OtherCertID()
+
+
+# Complete Revocation Refs
+
+id_aa_ets_revocationRefs = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.22')
+
+
+class CrlIdentifier(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('crlissuer', Name()),
+ namedtype.NamedType('crlIssuedTime', useful.UTCTime()),
+ namedtype.OptionalNamedType('crlNumber', univ.Integer())
+ )
+
+
+class CrlValidatedID(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('crlHash', OtherHash()),
+ namedtype.OptionalNamedType('crlIdentifier', CrlIdentifier())
+ )
+
+
+class CRLListID(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('crls',
+ univ.SequenceOf(componentType=CrlValidatedID()))
+ )
+
+
+class OcspIdentifier(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('ocspResponderID', ResponderID()),
+ namedtype.NamedType('producedAt', useful.GeneralizedTime())
+ )
+
+
+class OcspResponsesID(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('ocspIdentifier', OcspIdentifier()),
+ namedtype.OptionalNamedType('ocspRepHash', OtherHash())
+ )
+
+
+class OcspListID(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('ocspResponses',
+ univ.SequenceOf(componentType=OcspResponsesID()))
+ )
+
+
+class OtherRevRefType(univ.ObjectIdentifier):
+ pass
+
+
+class OtherRevRefs(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('otherRevRefType', OtherRevRefType()),
+ namedtype.NamedType('otherRevRefs', univ.Any(),
+ openType=opentype.OpenType('otherRevRefType', otherRevRefMap))
+ )
+
+
+class CrlOcspRef(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('crlids',
+ CRLListID().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 0))),
+ namedtype.OptionalNamedType('ocspids',
+ OcspListID().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 1))),
+ namedtype.OptionalNamedType('otherRev',
+ OtherRevRefs().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 2)))
+ )
+
+
+class CompleteRevocationRefs(univ.SequenceOf):
+ componentType = CrlOcspRef()
+
+
+# Certificate Values
+
+id_aa_ets_certValues = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.23')
+
+
+class CertificateValues(univ.SequenceOf):
+ componentType = Certificate()
+
+
+# Certificate Revocation Values
+
+id_aa_ets_revocationValues = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.24')
+
+
+class OtherRevValType(univ.ObjectIdentifier):
+ pass
+
+
+class OtherRevVals(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('otherRevValType', OtherRevValType()),
+ namedtype.NamedType('otherRevVals', univ.Any(),
+ openType=opentype.OpenType('otherRevValType', otherRevValMap))
+ )
+
+
+class RevocationValues(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('crlVals',
+ univ.SequenceOf(componentType=CertificateList()).subtype(
+ explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('ocspVals',
+ univ.SequenceOf(componentType=BasicOCSPResponse()).subtype(
+ explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+ namedtype.OptionalNamedType('otherRevVals',
+ OtherRevVals().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 2)))
+ )
+
+
+# CAdES-C Timestamp
+
+id_aa_ets_escTimeStamp = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.25')
+
+
+class ESCTimeStampToken(TimeStampToken):
+ pass
+
+
+# Time-Stamped Certificates and CRLs
+
+id_aa_ets_certCRLTimestamp = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.26')
+
+
+class TimestampedCertsCRLs(TimeStampToken):
+ pass
+
+
+# Archive Timestamp
+
+id_aa_ets_archiveTimestampV2 = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.48')
+
+
+class ArchiveTimeStampToken(TimeStampToken):
+ pass
+
+
+# Attribute certificate references
+
+id_aa_ets_attrCertificateRefs = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.44')
+
+
+class AttributeCertificateRefs(univ.SequenceOf):
+ componentType = OtherCertID()
+
+
+# Attribute revocation references
+
+id_aa_ets_attrRevocationRefs = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.45')
+
+
+class AttributeRevocationRefs(univ.SequenceOf):
+ componentType = CrlOcspRef()
+
+
+# Update the sigQualifiersMap
+
+_sigQualifiersMapUpdate = {
+ id_spq_ets_unotice: SPUserNotice(),
+ id_spq_ets_uri: SPuri(),
+}
+
+sigQualifiersMap.update(_sigQualifiersMapUpdate)
+
+
+# Update the CMS Attribute Map in rfc5652.py
+
+_cmsAttributesMapUpdate = {
+ id_aa_ets_otherSigCert: OtherSigningCertificate(),
+ id_aa_ets_sigPolicyId: SignaturePolicy(),
+ id_aa_ets_commitmentType: CommitmentTypeIndication(),
+ id_aa_ets_signerLocation: SignerLocation(),
+ id_aa_signatureTimeStampToken: SignatureTimeStampToken(),
+ id_aa_ets_contentTimestamp: ContentTimestamp(),
+ id_aa_ets_signerAttr: SignerAttribute(),
+ id_aa_ets_certificateRefs: CompleteCertificateRefs(),
+ id_aa_ets_revocationRefs: CompleteRevocationRefs(),
+ id_aa_ets_certValues: CertificateValues(),
+ id_aa_ets_revocationValues: RevocationValues(),
+ id_aa_ets_escTimeStamp: ESCTimeStampToken(),
+ id_aa_ets_certCRLTimestamp: TimestampedCertsCRLs(),
+ id_aa_ets_archiveTimestampV2: ArchiveTimeStampToken(),
+ id_aa_ets_attrCertificateRefs: AttributeCertificateRefs(),
+ id_aa_ets_attrRevocationRefs: AttributeRevocationRefs(),
+}
+
+rfc5652.cmsAttributesMap.update(_cmsAttributesMapUpdate)
diff --git a/pyasn1_modules/rfc5208.py b/pyasn1_modules/rfc5208.py
index 14082a8..295fdbf 100644
--- a/pyasn1_modules/rfc5208.py
+++ b/pyasn1_modules/rfc5208.py
@@ -1,7 +1,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# PKCS#8 syntax
diff --git a/pyasn1_modules/rfc5275.py b/pyasn1_modules/rfc5275.py
new file mode 100644
index 0000000..1be9598
--- /dev/null
+++ b/pyasn1_modules/rfc5275.py
@@ -0,0 +1,404 @@
+#
+# 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
+#
+# An Internet Attribute Certificate Profile for Authorization
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5275.txt
+#
+
+from pyasn1.type import constraint
+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_modules import rfc3565
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5751
+from pyasn1_modules import rfc5755
+
+MAX = float('inf')
+
+
+# Initialize the map for GLAQueryRequests and GLAQueryResponses
+
+glaQueryRRMap = { }
+
+
+# Imports from RFC 3565
+
+id_aes128_wrap = rfc3565.id_aes128_wrap
+
+
+# Imports from RFC 5280
+
+AlgorithmIdentifier = rfc5280.AlgorithmIdentifier
+
+Certificate = rfc5280.Certificate
+
+GeneralName = rfc5280.GeneralName
+
+
+# Imports from RFC 5652
+
+CertificateSet = rfc5652.CertificateSet
+
+KEKIdentifier = rfc5652.KEKIdentifier
+
+RecipientInfos = rfc5652.RecipientInfos
+
+
+# Imports from RFC 5751
+
+SMIMECapability = rfc5751.SMIMECapability
+
+
+# Imports from RFC 5755
+
+AttributeCertificate = rfc5755.AttributeCertificate
+
+
+# The GL symmetric key distribution object identifier arc
+
+id_skd = univ.ObjectIdentifier((1, 2, 840, 113549, 1, 9, 16, 8,))
+
+
+# The GL Use KEK control attribute
+
+id_skd_glUseKEK = id_skd + (1,)
+
+
+class Certificates(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('pKC',
+ Certificate().subtype(implicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('aC',
+ univ.SequenceOf(componentType=AttributeCertificate()).subtype(
+ subtypeSpec=constraint.ValueSizeConstraint(1, MAX)).subtype(
+ implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+ namedtype.OptionalNamedType('certPath',
+ CertificateSet().subtype(implicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 2)))
+ )
+
+
+class GLInfo(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glName', GeneralName()),
+ namedtype.NamedType('glAddress', GeneralName())
+ )
+
+
+class GLOwnerInfo(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glOwnerName', GeneralName()),
+ namedtype.NamedType('glOwnerAddress', GeneralName()),
+ namedtype.OptionalNamedType('certificates', Certificates())
+ )
+
+
+class GLAdministration(univ.Integer):
+ namedValues = namedval.NamedValues(
+ ('unmanaged', 0),
+ ('managed', 1),
+ ('closed', 2)
+ )
+
+
+requested_algorithm = SMIMECapability().subtype(
+ implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))
+requested_algorithm['capabilityID'] = id_aes128_wrap
+
+
+class GLKeyAttributes(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.DefaultedNamedType('rekeyControlledByGLO',
+ univ.Boolean().subtype(value=0,
+ implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.DefaultedNamedType('recipientsNotMutuallyAware',
+ univ.Boolean().subtype(value=1,
+ implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+ namedtype.DefaultedNamedType('duration',
+ univ.Integer().subtype(value=0,
+ implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 2))),
+ namedtype.DefaultedNamedType('generationCounter',
+ univ.Integer().subtype(value=2,
+ implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3))),
+ namedtype.DefaultedNamedType('requestedAlgorithm', requested_algorithm)
+ )
+
+
+class GLUseKEK(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glInfo', GLInfo()),
+ namedtype.NamedType('glOwnerInfo',
+ univ.SequenceOf(componentType=GLOwnerInfo()).subtype(
+ subtypeSpec=constraint.ValueSizeConstraint(1, MAX))),
+ namedtype.DefaultedNamedType('glAdministration',
+ GLAdministration().subtype(value=1)),
+ namedtype.OptionalNamedType('glKeyAttributes', GLKeyAttributes())
+ )
+
+
+# The Delete GL control attribute
+
+id_skd_glDelete = id_skd + (2,)
+
+
+class DeleteGL(GeneralName):
+ pass
+
+
+# The Add GL Member control attribute
+
+id_skd_glAddMember = id_skd + (3,)
+
+
+class GLMember(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glMemberName', GeneralName()),
+ namedtype.OptionalNamedType('glMemberAddress', GeneralName()),
+ namedtype.OptionalNamedType('certificates', Certificates())
+ )
+
+
+class GLAddMember(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glName', GeneralName()),
+ namedtype.NamedType('glMember', GLMember())
+ )
+
+
+# The Delete GL Member control attribute
+
+id_skd_glDeleteMember = id_skd + (4,)
+
+
+class GLDeleteMember(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glName', GeneralName()),
+ namedtype.NamedType('glMemberToDelete', GeneralName())
+ )
+
+
+# The GL Rekey control attribute
+
+id_skd_glRekey = id_skd + (5,)
+
+
+class GLNewKeyAttributes(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.OptionalNamedType('rekeyControlledByGLO',
+ univ.Boolean().subtype(implicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 0))),
+ namedtype.OptionalNamedType('recipientsNotMutuallyAware',
+ univ.Boolean().subtype(implicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1))),
+ namedtype.OptionalNamedType('duration',
+ univ.Integer().subtype(implicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 2))),
+ namedtype.OptionalNamedType('generationCounter',
+ univ.Integer().subtype(implicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 3))),
+ namedtype.OptionalNamedType('requestedAlgorithm',
+ AlgorithmIdentifier().subtype(implicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 4)))
+ )
+
+
+class GLRekey(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glName', GeneralName()),
+ namedtype.OptionalNamedType('glAdministration', GLAdministration()),
+ namedtype.OptionalNamedType('glNewKeyAttributes', GLNewKeyAttributes()),
+ namedtype.OptionalNamedType('glRekeyAllGLKeys', univ.Boolean())
+ )
+
+
+# The Add and Delete GL Owner control attributes
+
+id_skd_glAddOwner = id_skd + (6,)
+
+id_skd_glRemoveOwner = id_skd + (7,)
+
+
+class GLOwnerAdministration(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glName', GeneralName()),
+ namedtype.NamedType('glOwnerInfo', GLOwnerInfo())
+ )
+
+
+# The GL Key Compromise control attribute
+
+id_skd_glKeyCompromise = id_skd + (8,)
+
+
+class GLKCompromise(GeneralName):
+ pass
+
+
+# The GL Key Refresh control attribute
+
+id_skd_glkRefresh = id_skd + (9,)
+
+
+class Date(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('start', useful.GeneralizedTime()),
+ namedtype.OptionalNamedType('end', useful.GeneralizedTime())
+ )
+
+
+class GLKRefresh(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glName', GeneralName()),
+ namedtype.NamedType('dates',
+ univ.SequenceOf(componentType=Date()).subtype(
+ subtypeSpec=constraint.ValueSizeConstraint(1, MAX)))
+ )
+
+
+# The GLA Query Request control attribute
+
+id_skd_glaQueryRequest = id_skd + (11,)
+
+
+class GLAQueryRequest(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glaRequestType', univ.ObjectIdentifier()),
+ namedtype.NamedType('glaRequestValue', univ.Any(),
+ openType=opentype.OpenType('glaRequestType', glaQueryRRMap))
+ )
+
+
+# The GLA Query Response control attribute
+
+id_skd_glaQueryResponse = id_skd + (12,)
+
+
+class GLAQueryResponse(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glaResponseType', univ.ObjectIdentifier()),
+ namedtype.NamedType('glaResponseValue', univ.Any(),
+ openType=opentype.OpenType('glaResponseType', glaQueryRRMap))
+ )
+
+
+# The GLA Request/Response (glaRR) arc for glaRequestType/glaResponseType
+
+id_cmc_glaRR = univ.ObjectIdentifier((1, 3, 6, 1, 5, 5, 7, 7, 99,))
+
+
+# The Algorithm Request
+
+id_cmc_gla_skdAlgRequest = id_cmc_glaRR + (1,)
+
+
+class SKDAlgRequest(univ.Null):
+ pass
+
+
+# The Algorithm Response
+
+id_cmc_gla_skdAlgResponse = id_cmc_glaRR + (2,)
+
+SMIMECapabilities = rfc5751.SMIMECapabilities
+
+
+# The control attribute to request an updated certificate to the GLA and
+# the control attribute to return an updated certificate to the GLA
+
+id_skd_glProvideCert = id_skd + (13,)
+
+id_skd_glManageCert = id_skd + (14,)
+
+
+class GLManageCert(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glName', GeneralName()),
+ namedtype.NamedType('glMember', GLMember())
+ )
+
+
+# The control attribute to distribute the GL shared KEK
+
+id_skd_glKey = id_skd + (15,)
+
+
+class GLKey(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('glName', GeneralName()),
+ namedtype.NamedType('glIdentifier', KEKIdentifier()),
+ namedtype.NamedType('glkWrapped', RecipientInfos()),
+ namedtype.NamedType('glkAlgorithm', AlgorithmIdentifier()),
+ namedtype.NamedType('glkNotBefore', useful.GeneralizedTime()),
+ namedtype.NamedType('glkNotAfter', useful.GeneralizedTime())
+ )
+
+
+# The CMC error types
+
+id_cet_skdFailInfo = univ.ObjectIdentifier((1, 3, 6, 1, 5, 5, 7, 15, 1,))
+
+
+class SKDFailInfo(univ.Integer):
+ namedValues = namedval.NamedValues(
+ ('unspecified', 0),
+ ('closedGL', 1),
+ ('unsupportedDuration', 2),
+ ('noGLACertificate', 3),
+ ('invalidCert', 4),
+ ('unsupportedAlgorithm', 5),
+ ('noGLONameMatch', 6),
+ ('invalidGLName', 7),
+ ('nameAlreadyInUse', 8),
+ ('noSpam', 9),
+ ('alreadyAMember', 11),
+ ('notAMember', 12),
+ ('alreadyAnOwner', 13),
+ ('notAnOwner', 14)
+ )
+
+
+# Update the map for GLAQueryRequests and GLAQueryResponses
+
+_glaQueryRRMapUpdate = {
+ id_cmc_gla_skdAlgRequest: univ.Null(""),
+ id_cmc_gla_skdAlgResponse: SMIMECapabilities(),
+}
+
+glaQueryRRMap.update(_glaQueryRRMapUpdate)
+
+
+# Update the map for CMC control attributes; since CMS Attributes and
+# CMC Controls both use 'attrType', one map is used for both
+
+_cmcControlAttributesMapUpdate = {
+ id_skd_glUseKEK: GLUseKEK(),
+ id_skd_glDelete: DeleteGL(),
+ id_skd_glAddMember: GLAddMember(),
+ id_skd_glDeleteMember: GLDeleteMember(),
+ id_skd_glRekey: GLRekey(),
+ id_skd_glAddOwner: GLOwnerAdministration(),
+ id_skd_glRemoveOwner: GLOwnerAdministration(),
+ id_skd_glKeyCompromise: GLKCompromise(),
+ id_skd_glkRefresh: GLKRefresh(),
+ id_skd_glaQueryRequest: GLAQueryRequest(),
+ id_skd_glaQueryResponse: GLAQueryResponse(),
+ id_skd_glProvideCert: GLManageCert(),
+ id_skd_glManageCert: GLManageCert(),
+ id_skd_glKey: GLKey(),
+}
+
+rfc5652.cmsAttributesMap.update(_cmcControlAttributesMapUpdate)
diff --git a/pyasn1_modules/rfc5280.py b/pyasn1_modules/rfc5280.py
index f2b52b2..ed5d28f 100644
--- a/pyasn1_modules/rfc5280.py
+++ b/pyasn1_modules/rfc5280.py
@@ -6,7 +6,7 @@
# Updated by Russ Housley for ORAddress Extension Attribute opentype support.
# Updated by Russ Housley for AlgorithmIdentifier opentype support.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Internet X.509 Public Key Infrastructure Certificate and Certificate
diff --git a/pyasn1_modules/rfc5636.py b/pyasn1_modules/rfc5636.py
new file mode 100644
index 0000000..f87bc4e
--- /dev/null
+++ b/pyasn1_modules/rfc5636.py
@@ -0,0 +1,113 @@
+# 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
+#
+# Traceable Anonymous Certificate
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5480.txt
+
+from pyasn1.type import namedtype
+from pyasn1.type import univ
+from pyasn1.type import useful
+
+from pyasn1_modules import rfc5652
+
+
+# Imports from RFC 5652
+
+ContentInfo = rfc5652.ContentInfo
+
+EncapsulatedContentInfo = rfc5652.EncapsulatedContentInfo
+
+id_data = rfc5652.id_data
+
+
+# Object Identifiers
+
+id_KISA = univ.ObjectIdentifier((1, 2, 410, 200004,))
+
+
+id_npki = id_KISA + (10,)
+
+
+id_attribute = id_npki + (1,)
+
+
+id_kisa_tac = id_attribute + (1,)
+
+
+id_kisa_tac_token = id_kisa_tac + (1,)
+
+
+id_kisa_tac_tokenandblindbash = id_kisa_tac + (2,)
+
+
+id_kisa_tac_tokenandpartially = id_kisa_tac + (3,)
+
+
+# Structures for Traceable Anonymous Certificate (TAC)
+
+class UserKey(univ.OctetString):
+ pass
+
+
+class Timeout(useful.GeneralizedTime):
+ pass
+
+
+class BlinedCertificateHash(univ.OctetString):
+ pass
+
+
+class PartiallySignedCertificateHash(univ.OctetString):
+ pass
+
+
+class Token(ContentInfo):
+ pass
+
+
+class TokenandBlindHash(ContentInfo):
+ pass
+
+
+class TokenandPartiallySignedCertificateHash(ContentInfo):
+ pass
+
+
+# Added to the module in RFC 5636 for the CMS Content Type Map
+
+class TACToken(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('userKey', UserKey()),
+ namedtype.NamedType('timeout', Timeout())
+ )
+
+
+class TACTokenandBlindHash(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('token', Token()),
+ namedtype.NamedType('blinded', BlinedCertificateHash())
+ )
+
+
+class TACTokenandPartiallySignedCertificateHash(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('token', Token()),
+ namedtype.NamedType('partially', PartiallySignedCertificateHash())
+ )
+
+
+# Add to the CMS Content Type Map in rfc5752.py
+
+_cmsContentTypesMapUpdate = {
+ id_kisa_tac_token: TACToken(),
+ id_kisa_tac_tokenandblindbash: TACTokenandBlindHash(),
+ id_kisa_tac_tokenandpartially: TACTokenandPartiallySignedCertificateHash(),
+}
+
+rfc5652.cmsContentTypesMap.update(_cmsContentTypesMapUpdate)
diff --git a/pyasn1_modules/rfc5639.py b/pyasn1_modules/rfc5639.py
new file mode 100644
index 0000000..d48d300
--- /dev/null
+++ b/pyasn1_modules/rfc5639.py
@@ -0,0 +1,49 @@
+# 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 Cryptography Brainpool Standard Curves
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5639.txt
+
+
+from pyasn1.type import univ
+
+
+ecStdCurvesAndGeneration = univ.ObjectIdentifier((1, 3, 36, 3, 3, 2, 8,))
+
+ellipticCurve = ecStdCurvesAndGeneration + (1,)
+
+versionOne = ellipticCurve + (1,)
+
+brainpoolP160r1 = versionOne + (1,)
+
+brainpoolP160t1 = versionOne + (2,)
+
+brainpoolP192r1 = versionOne + (3,)
+
+brainpoolP192t1 = versionOne + (4,)
+
+brainpoolP224r1 = versionOne + (5,)
+
+brainpoolP224t1 = versionOne + (6,)
+
+brainpoolP256r1 = versionOne + (7,)
+
+brainpoolP256t1 = versionOne + (8,)
+
+brainpoolP320r1 = versionOne + (9,)
+
+brainpoolP320t1 = versionOne + (10,)
+
+brainpoolP384r1 = versionOne + (11,)
+
+brainpoolP384t1 = versionOne + (12,)
+
+brainpoolP512r1 = versionOne + (13,)
+
+brainpoolP512t1 = versionOne + (14,)
diff --git a/pyasn1_modules/rfc5652.py b/pyasn1_modules/rfc5652.py
index 2e48962..1e95829 100644
--- a/pyasn1_modules/rfc5652.py
+++ b/pyasn1_modules/rfc5652.py
@@ -5,7 +5,7 @@
# Created by Stanisław Pitucha with asn1ate tool.
# Modified by Russ Housley to add support for opentypes.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Cryptographic Message Syntax (CMS)
diff --git a/pyasn1_modules/rfc5697.py b/pyasn1_modules/rfc5697.py
new file mode 100644
index 0000000..8c5a9d3
--- /dev/null
+++ b/pyasn1_modules/rfc5697.py
@@ -0,0 +1,70 @@
+# 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
+#
+# 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_modules import rfc5280
+from pyasn1_modules import rfc4055
+
+
+# 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
+# These are defined here because a module for RFC 5055 does not exist yet
+
+class SCVPIssuerSerial(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('issuer', GeneralNames()),
+ namedtype.NamedType('serialNumber', CertificateSerialNumber())
+ )
+
+
+sha1_alg_id = AlgorithmIdentifier()
+sha1_alg_id['algorithm'] = id_sha1
+
+
+class SCVPCertID(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('certHash', univ.OctetString()),
+ namedtype.NamedType('issuerSerial', SCVPIssuerSerial()),
+ namedtype.DefaultedNamedType('hashAlgorithm', sha1_alg_id)
+ )
+
+
+# Other Certificates Extension
+
+id_pe_otherCerts = univ.ObjectIdentifier((1, 3, 6, 1, 5, 5, 7, 1, 19,))
+
+class OtherCertificates(univ.SequenceOf):
+ componentType = SCVPCertID()
+
+
+# Update of certificate extension map in rfc5280.py
+
+_certificateExtensionsMapUpdate = {
+ id_pe_otherCerts: OtherCertificates(),
+}
+
+rfc5280.certificateExtensionsMap.update(_certificateExtensionsMapUpdate)
diff --git a/pyasn1_modules/rfc5752.py b/pyasn1_modules/rfc5752.py
new file mode 100644
index 0000000..1d0df8f
--- /dev/null
+++ b/pyasn1_modules/rfc5752.py
@@ -0,0 +1,49 @@
+#
+# 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
+#
+# 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_modules import rfc5035
+from pyasn1_modules import rfc5652
+
+
+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')
+
+
+# Map of Attribute Type OIDs to Attributes added to the
+# ones that are in rfc5652.py
+
+_cmsAttributesMapUpdate = {
+ id_aa_multipleSignatures: MultipleSignatures(),
+}
+
+rfc5652.cmsAttributesMap.update(_cmsAttributesMapUpdate)
diff --git a/pyasn1_modules/rfc5753.py b/pyasn1_modules/rfc5753.py
new file mode 100644
index 0000000..94c37c2
--- /dev/null
+++ b/pyasn1_modules/rfc5753.py
@@ -0,0 +1,157 @@
+#
+# 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
+#
+# Elliptic Curve Cryptography (ECC) Algorithms in the CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5753.txt
+#
+
+from pyasn1.type import univ, char, namedtype, namedval, tag, constraint, useful
+
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5480
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5751
+from pyasn1_modules import rfc8018
+
+
+# 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 Identifier map in rfc5280.py and
+# Update the SMIMECapabilities Attribute Map in rfc5751.py
+
+_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(),
+}
+
+rfc5280.algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)
+
+rfc5751.smimeCapabilityMap.update(_algorithmIdentifierMapUpdate)
diff --git a/pyasn1_modules/rfc6402-1.py b/pyasn1_modules/rfc6402-1.py
deleted file mode 100644
index 322e35e..0000000
--- a/pyasn1_modules/rfc6402-1.py
+++ /dev/null
@@ -1,627 +0,0 @@
-# coding: utf-8
-#
-# This file is part of pyasn1-modules software.
-#
-# Created by Stanisław Pitucha with asn1ate tool.
-# Modified by Russ Housley to add a maps for CMC Control Attributes
-# and CMC Content Types for use with opentypes.
-#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
-# License: http://snmplabs.com/pyasn1/license.html
-#
-# Certificate Management over CMS (CMC) Updates
-#
-# ASN.1 source from:
-# https://www.rfc-editor.org/rfc/rfc6402.txt
-#
-from pyasn1.type import char
-from pyasn1.type import constraint
-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_modules import rfc4211
-from pyasn1_modules import rfc5280
-from pyasn1_modules import rfc5652
-
-MAX = float('inf')
-
-
-def _buildOid(*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)
-
-
-cmcControlAttributesMap = { }
-
-
-class ChangeSubjectName(univ.Sequence):
- pass
-
-
-ChangeSubjectName.componentType = namedtype.NamedTypes(
- namedtype.OptionalNamedType('subject', rfc5280.Name()),
- namedtype.OptionalNamedType('subjectAlt', rfc5280.GeneralNames())
-)
-
-
-class AttributeValue(univ.Any):
- pass
-
-
-class CMCStatus(univ.Integer):
- pass
-
-
-CMCStatus.namedValues = namedval.NamedValues(
- ('success', 0),
- ('failed', 2),
- ('pending', 3),
- ('noSupport', 4),
- ('confirmRequired', 5),
- ('popRequired', 6),
- ('partial', 7)
-)
-
-
-class PendInfo(univ.Sequence):
- pass
-
-
-PendInfo.componentType = namedtype.NamedTypes(
- namedtype.NamedType('pendToken', univ.OctetString()),
- namedtype.NamedType('pendTime', useful.GeneralizedTime())
-)
-
-bodyIdMax = univ.Integer(4294967295)
-
-
-class BodyPartID(univ.Integer):
- pass
-
-
-BodyPartID.subtypeSpec = constraint.ValueRangeConstraint(0, bodyIdMax)
-
-
-class BodyPartPath(univ.SequenceOf):
- pass
-
-
-BodyPartPath.componentType = BodyPartID()
-BodyPartPath.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
-
-
-class BodyPartReference(univ.Choice):
- pass
-
-
-BodyPartReference.componentType = namedtype.NamedTypes(
- namedtype.NamedType('bodyPartID', BodyPartID()),
- namedtype.NamedType('bodyPartPath', BodyPartPath())
-)
-
-
-class CMCFailInfo(univ.Integer):
- pass
-
-
-CMCFailInfo.namedValues = namedval.NamedValues(
- ('badAlg', 0),
- ('badMessageCheck', 1),
- ('badRequest', 2),
- ('badTime', 3),
- ('badCertId', 4),
- ('unsupportedExt', 5),
- ('mustArchiveKeys', 6),
- ('badIdentity', 7),
- ('popRequired', 8),
- ('popFailed', 9),
- ('noKeyReuse', 10),
- ('internalCAError', 11),
- ('tryLater', 12),
- ('authDataFail', 13)
-)
-
-
-class CMCStatusInfoV2(univ.Sequence):
- pass
-
-
-CMCStatusInfoV2.componentType = namedtype.NamedTypes(
- namedtype.NamedType('cMCStatus', CMCStatus()),
- namedtype.NamedType('bodyList', univ.SequenceOf(componentType=BodyPartReference())),
- namedtype.OptionalNamedType('statusString', char.UTF8String()),
- namedtype.OptionalNamedType(
- 'otherInfo', univ.Choice(
- componentType=namedtype.NamedTypes(
- namedtype.NamedType('failInfo', CMCFailInfo()),
- namedtype.NamedType('pendInfo', PendInfo()),
- namedtype.NamedType(
- 'extendedFailInfo', univ.Sequence(
- componentType=namedtype.NamedTypes(
- namedtype.NamedType('failInfoOID', univ.ObjectIdentifier()),
- namedtype.NamedType('failInfoValue', AttributeValue()))
- )
- )
- )
- )
- )
-)
-
-
-class GetCRL(univ.Sequence):
- pass
-
-
-GetCRL.componentType = namedtype.NamedTypes(
- namedtype.NamedType('issuerName', rfc5280.Name()),
- namedtype.OptionalNamedType('cRLName', rfc5280.GeneralName()),
- namedtype.OptionalNamedType('time', useful.GeneralizedTime()),
- namedtype.OptionalNamedType('reasons', rfc5280.ReasonFlags())
-)
-
-id_pkix = _buildOid(1, 3, 6, 1, 5, 5, 7)
-
-id_cmc = _buildOid(id_pkix, 7)
-
-id_cmc_batchResponses = _buildOid(id_cmc, 29)
-
-id_cmc_popLinkWitness = _buildOid(id_cmc, 23)
-
-
-class PopLinkWitnessV2(univ.Sequence):
- pass
-
-
-PopLinkWitnessV2.componentType = namedtype.NamedTypes(
- namedtype.NamedType('keyGenAlgorithm', rfc5280.AlgorithmIdentifier()),
- namedtype.NamedType('macAlgorithm', rfc5280.AlgorithmIdentifier()),
- namedtype.NamedType('witness', univ.OctetString())
-)
-
-id_cmc_popLinkWitnessV2 = _buildOid(id_cmc, 33)
-
-id_cmc_identityProofV2 = _buildOid(id_cmc, 34)
-
-id_cmc_revokeRequest = _buildOid(id_cmc, 17)
-
-id_cmc_recipientNonce = _buildOid(id_cmc, 7)
-
-
-class ControlsProcessed(univ.Sequence):
- pass
-
-
-ControlsProcessed.componentType = namedtype.NamedTypes(
- namedtype.NamedType('bodyList', univ.SequenceOf(componentType=BodyPartReference()))
-)
-
-
-class CertificationRequest(univ.Sequence):
- pass
-
-
-CertificationRequest.componentType = namedtype.NamedTypes(
- namedtype.NamedType(
- 'certificationRequestInfo', univ.Sequence(
- componentType=namedtype.NamedTypes(
- namedtype.NamedType('version', univ.Integer()),
- namedtype.NamedType('subject', rfc5280.Name()),
- namedtype.NamedType(
- 'subjectPublicKeyInfo', univ.Sequence(
- componentType=namedtype.NamedTypes(
- namedtype.NamedType('algorithm', rfc5280.AlgorithmIdentifier()),
- namedtype.NamedType('subjectPublicKey', univ.BitString())
- )
- )
- ),
- namedtype.NamedType(
- 'attributes', univ.SetOf(
- componentType=rfc5652.Attribute()).subtype(
- implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))
- )
- )
- )
- ),
- namedtype.NamedType('signatureAlgorithm', rfc5280.AlgorithmIdentifier()),
- namedtype.NamedType('signature', univ.BitString())
-)
-
-
-class TaggedCertificationRequest(univ.Sequence):
- pass
-
-
-TaggedCertificationRequest.componentType = namedtype.NamedTypes(
- namedtype.NamedType('bodyPartID', BodyPartID()),
- namedtype.NamedType('certificationRequest', CertificationRequest())
-)
-
-
-class TaggedRequest(univ.Choice):
- pass
-
-
-TaggedRequest.componentType = namedtype.NamedTypes(
- namedtype.NamedType('tcr', TaggedCertificationRequest().subtype(
- implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 0))),
- namedtype.NamedType('crm',
- rfc4211.CertReqMsg().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
- namedtype.NamedType('orm', univ.Sequence(componentType=namedtype.NamedTypes(
- namedtype.NamedType('bodyPartID', BodyPartID()),
- namedtype.NamedType('requestMessageType', univ.ObjectIdentifier()),
- namedtype.NamedType('requestMessageValue', univ.Any())
- ))
- .subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 2)))
-)
-
-id_cmc_popLinkRandom = _buildOid(id_cmc, 22)
-
-id_cmc_statusInfo = _buildOid(id_cmc, 1)
-
-id_cmc_trustedAnchors = _buildOid(id_cmc, 26)
-
-id_cmc_transactionId = _buildOid(id_cmc, 5)
-
-id_cmc_encryptedPOP = _buildOid(id_cmc, 9)
-
-
-class PublishTrustAnchors(univ.Sequence):
- pass
-
-
-PublishTrustAnchors.componentType = namedtype.NamedTypes(
- namedtype.NamedType('seqNumber', univ.Integer()),
- namedtype.NamedType('hashAlgorithm', rfc5280.AlgorithmIdentifier()),
- namedtype.NamedType('anchorHashes', univ.SequenceOf(componentType=univ.OctetString()))
-)
-
-
-class RevokeRequest(univ.Sequence):
- pass
-
-
-RevokeRequest.componentType = namedtype.NamedTypes(
- namedtype.NamedType('issuerName', rfc5280.Name()),
- namedtype.NamedType('serialNumber', univ.Integer()),
- namedtype.NamedType('reason', rfc5280.CRLReason()),
- namedtype.OptionalNamedType('invalidityDate', useful.GeneralizedTime()),
- namedtype.OptionalNamedType('passphrase', univ.OctetString()),
- namedtype.OptionalNamedType('comment', char.UTF8String())
-)
-
-id_cmc_senderNonce = _buildOid(id_cmc, 6)
-
-id_cmc_authData = _buildOid(id_cmc, 27)
-
-
-class TaggedContentInfo(univ.Sequence):
- pass
-
-
-TaggedContentInfo.componentType = namedtype.NamedTypes(
- namedtype.NamedType('bodyPartID', BodyPartID()),
- namedtype.NamedType('contentInfo', rfc5652.ContentInfo())
-)
-
-
-class IdentifyProofV2(univ.Sequence):
- pass
-
-
-IdentifyProofV2.componentType = namedtype.NamedTypes(
- namedtype.NamedType('proofAlgID', rfc5280.AlgorithmIdentifier()),
- namedtype.NamedType('macAlgId', rfc5280.AlgorithmIdentifier()),
- namedtype.NamedType('witness', univ.OctetString())
-)
-
-
-class CMCPublicationInfo(univ.Sequence):
- pass
-
-
-CMCPublicationInfo.componentType = namedtype.NamedTypes(
- namedtype.NamedType('hashAlg', rfc5280.AlgorithmIdentifier()),
- namedtype.NamedType('certHashes', univ.SequenceOf(componentType=univ.OctetString())),
- namedtype.NamedType('pubInfo', rfc4211.PKIPublicationInfo())
-)
-
-id_kp_cmcCA = _buildOid(rfc5280.id_kp, 27)
-
-id_cmc_confirmCertAcceptance = _buildOid(id_cmc, 24)
-
-id_cmc_raIdentityWitness = _buildOid(id_cmc, 35)
-
-id_ExtensionReq = _buildOid(1, 2, 840, 113549, 1, 9, 14)
-
-id_cct = _buildOid(id_pkix, 12)
-
-id_cct_PKIData = _buildOid(id_cct, 2)
-
-id_kp_cmcRA = _buildOid(rfc5280.id_kp, 28)
-
-
-class CMCStatusInfo(univ.Sequence):
- pass
-
-
-CMCStatusInfo.componentType = namedtype.NamedTypes(
- namedtype.NamedType('cMCStatus', CMCStatus()),
- namedtype.NamedType('bodyList', univ.SequenceOf(componentType=BodyPartID())),
- namedtype.OptionalNamedType('statusString', char.UTF8String()),
- namedtype.OptionalNamedType(
- 'otherInfo', univ.Choice(
- componentType=namedtype.NamedTypes(
- namedtype.NamedType('failInfo', CMCFailInfo()),
- namedtype.NamedType('pendInfo', PendInfo())
- )
- )
- )
-)
-
-
-class DecryptedPOP(univ.Sequence):
- pass
-
-
-DecryptedPOP.componentType = namedtype.NamedTypes(
- namedtype.NamedType('bodyPartID', BodyPartID()),
- namedtype.NamedType('thePOPAlgID', rfc5280.AlgorithmIdentifier()),
- namedtype.NamedType('thePOP', univ.OctetString())
-)
-
-id_cmc_addExtensions = _buildOid(id_cmc, 8)
-
-id_cmc_modCertTemplate = _buildOid(id_cmc, 31)
-
-
-class TaggedAttribute(univ.Sequence):
- pass
-
-
-TaggedAttribute.componentType = namedtype.NamedTypes(
- namedtype.NamedType('bodyPartID', BodyPartID()),
- namedtype.NamedType('attrType', univ.ObjectIdentifier()),
- namedtype.NamedType('attrValues', univ.SetOf(componentType=AttributeValue()),
- openType=opentype.OpenType('attrType', cmcControlAttributesMap)
- )
-)
-
-
-class OtherMsg(univ.Sequence):
- pass
-
-
-OtherMsg.componentType = namedtype.NamedTypes(
- namedtype.NamedType('bodyPartID', BodyPartID()),
- namedtype.NamedType('otherMsgType', univ.ObjectIdentifier()),
- namedtype.NamedType('otherMsgValue', univ.Any())
-)
-
-
-class PKIData(univ.Sequence):
- pass
-
-
-PKIData.componentType = namedtype.NamedTypes(
- namedtype.NamedType('controlSequence', univ.SequenceOf(componentType=TaggedAttribute())),
- namedtype.NamedType('reqSequence', univ.SequenceOf(componentType=TaggedRequest())),
- namedtype.NamedType('cmsSequence', univ.SequenceOf(componentType=TaggedContentInfo())),
- namedtype.NamedType('otherMsgSequence', univ.SequenceOf(componentType=OtherMsg()))
-)
-
-
-class BodyPartList(univ.SequenceOf):
- pass
-
-
-BodyPartList.componentType = BodyPartID()
-BodyPartList.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
-
-id_cmc_responseBody = _buildOid(id_cmc, 37)
-
-
-class AuthPublish(BodyPartID):
- pass
-
-
-class CMCUnsignedData(univ.Sequence):
- pass
-
-
-CMCUnsignedData.componentType = namedtype.NamedTypes(
- namedtype.NamedType('bodyPartPath', BodyPartPath()),
- namedtype.NamedType('identifier', univ.ObjectIdentifier()),
- namedtype.NamedType('content', univ.Any())
-)
-
-
-class CMCCertId(rfc5652.IssuerAndSerialNumber):
- pass
-
-
-class PKIResponse(univ.Sequence):
- pass
-
-
-PKIResponse.componentType = namedtype.NamedTypes(
- namedtype.NamedType('controlSequence', univ.SequenceOf(componentType=TaggedAttribute())),
- namedtype.NamedType('cmsSequence', univ.SequenceOf(componentType=TaggedContentInfo())),
- namedtype.NamedType('otherMsgSequence', univ.SequenceOf(componentType=OtherMsg()))
-)
-
-
-class ResponseBody(PKIResponse):
- pass
-
-
-id_cmc_statusInfoV2 = _buildOid(id_cmc, 25)
-
-id_cmc_lraPOPWitness = _buildOid(id_cmc, 11)
-
-
-class ModCertTemplate(univ.Sequence):
- pass
-
-
-ModCertTemplate.componentType = namedtype.NamedTypes(
- namedtype.NamedType('pkiDataReference', BodyPartPath()),
- namedtype.NamedType('certReferences', BodyPartList()),
- namedtype.DefaultedNamedType('replace', univ.Boolean().subtype(value=1)),
- namedtype.NamedType('certTemplate', rfc4211.CertTemplate())
-)
-
-id_cmc_regInfo = _buildOid(id_cmc, 18)
-
-id_cmc_identityProof = _buildOid(id_cmc, 3)
-
-
-class ExtensionReq(univ.SequenceOf):
- pass
-
-
-ExtensionReq.componentType = rfc5280.Extension()
-ExtensionReq.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
-
-id_kp_cmcArchive = _buildOid(rfc5280.id_kp, 28)
-
-id_cmc_publishCert = _buildOid(id_cmc, 30)
-
-id_cmc_dataReturn = _buildOid(id_cmc, 4)
-
-
-class LraPopWitness(univ.Sequence):
- pass
-
-
-LraPopWitness.componentType = namedtype.NamedTypes(
- namedtype.NamedType('pkiDataBodyid', BodyPartID()),
- namedtype.NamedType('bodyIds', univ.SequenceOf(componentType=BodyPartID()))
-)
-
-id_aa = _buildOid(1, 2, 840, 113549, 1, 9, 16, 2)
-
-id_aa_cmc_unsignedData = _buildOid(id_aa, 34)
-
-id_cmc_getCert = _buildOid(id_cmc, 15)
-
-id_cmc_batchRequests = _buildOid(id_cmc, 28)
-
-id_cmc_decryptedPOP = _buildOid(id_cmc, 10)
-
-id_cmc_responseInfo = _buildOid(id_cmc, 19)
-
-id_cmc_changeSubjectName = _buildOid(id_cmc, 36)
-
-
-class GetCert(univ.Sequence):
- pass
-
-
-GetCert.componentType = namedtype.NamedTypes(
- namedtype.NamedType('issuerName', rfc5280.GeneralName()),
- namedtype.NamedType('serialNumber', univ.Integer())
-)
-
-id_cmc_identification = _buildOid(id_cmc, 2)
-
-id_cmc_queryPending = _buildOid(id_cmc, 21)
-
-
-class AddExtensions(univ.Sequence):
- pass
-
-
-AddExtensions.componentType = namedtype.NamedTypes(
- namedtype.NamedType('pkiDataReference', BodyPartID()),
- namedtype.NamedType('certReferences', univ.SequenceOf(componentType=BodyPartID())),
- namedtype.NamedType('extensions', univ.SequenceOf(componentType=rfc5280.Extension()))
-)
-
-
-class EncryptedPOP(univ.Sequence):
- pass
-
-
-EncryptedPOP.componentType = namedtype.NamedTypes(
- namedtype.NamedType('request', TaggedRequest()),
- namedtype.NamedType('cms', rfc5652.ContentInfo()),
- namedtype.NamedType('thePOPAlgID', rfc5280.AlgorithmIdentifier()),
- namedtype.NamedType('witnessAlgID', rfc5280.AlgorithmIdentifier()),
- namedtype.NamedType('witness', univ.OctetString())
-)
-
-id_cmc_getCRL = _buildOid(id_cmc, 16)
-
-id_cct_PKIResponse = _buildOid(id_cct, 3)
-
-id_cmc_controlProcessed = _buildOid(id_cmc, 32)
-
-
-class NoSignatureValue(univ.OctetString):
- pass
-
-
-id_ad_cmc = _buildOid(rfc5280.id_ad, 12)
-
-id_alg_noSignature = _buildOid(id_pkix, 6, 2)
-
-
-# Map of CMC Control OIDs to CMC Control Attributes
-
-_cmcControlAttributesMapUpdate = {
- id_cmc_statusInfo: CMCStatusInfo(),
- id_cmc_statusInfoV2: CMCStatusInfoV2(),
- id_cmc_identification: char.UTF8String(),
- id_cmc_identityProof: univ.OctetString(),
- id_cmc_identityProofV2: IdentifyProofV2(),
- id_cmc_dataReturn: univ.OctetString(),
- id_cmc_transactionId: univ.Integer(),
- id_cmc_senderNonce: univ.OctetString(),
- id_cmc_recipientNonce: univ.OctetString(),
- id_cmc_addExtensions: AddExtensions(),
- id_cmc_encryptedPOP: EncryptedPOP(),
- id_cmc_decryptedPOP: DecryptedPOP(),
- id_cmc_lraPOPWitness: LraPopWitness(),
- id_cmc_getCert: GetCert(),
- id_cmc_getCRL: GetCRL(),
- id_cmc_revokeRequest: RevokeRequest(),
- id_cmc_regInfo: univ.OctetString(),
- id_cmc_responseInfo: univ.OctetString(),
- id_cmc_queryPending: univ.OctetString(),
- id_cmc_popLinkRandom: univ.OctetString(),
- id_cmc_popLinkWitness: univ.OctetString(),
- id_cmc_popLinkWitnessV2: PopLinkWitnessV2(),
- id_cmc_confirmCertAcceptance: CMCCertId(),
- id_cmc_trustedAnchors: PublishTrustAnchors(),
- id_cmc_authData: AuthPublish(),
- id_cmc_batchRequests: BodyPartList(),
- id_cmc_batchResponses: BodyPartList(),
- id_cmc_publishCert: CMCPublicationInfo(),
- id_cmc_modCertTemplate: ModCertTemplate(),
- id_cmc_controlProcessed: ControlsProcessed(),
- id_ExtensionReq: ExtensionReq(),
-}
-
-cmcControlAttributesMap.update(_cmcControlAttributesMapUpdate)
-
-
-# Map of CMC Content Type OIDs to CMC Content Types are added to
-# the ones that are in rfc5652.py
-
-_cmsContentTypesMapUpdate = {
- id_cct_PKIData: PKIData(),
- id_cct_PKIResponse: PKIResponse(),
-}
-
-rfc5652.cmsContentTypesMap.update(_cmsContentTypesMapUpdate)
-
diff --git a/pyasn1_modules/rfc6402.py b/pyasn1_modules/rfc6402.py
index b5f0d48..5490b05 100644
--- a/pyasn1_modules/rfc6402.py
+++ b/pyasn1_modules/rfc6402.py
@@ -6,7 +6,7 @@
# Modified by Russ Housley to add a maps for CMC Control Attributes
# and CMC Content Types for use with opentypes.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Certificate Management over CMS (CMC) Updates
diff --git a/pyasn1_modules/rfc7894-1.py b/pyasn1_modules/rfc7894-1.py
deleted file mode 100644
index 92638d1..0000000
--- a/pyasn1_modules/rfc7894-1.py
+++ /dev/null
@@ -1,92 +0,0 @@
-#
-# 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
-#
-# Alternative Challenge Password Attributes for EST
-#
-# ASN.1 source from:
-# https://www.rfc-editor.org/rfc/rfc7894.txt
-#
-
-from pyasn1.type import char
-from pyasn1.type import constraint
-from pyasn1.type import namedtype
-from pyasn1.type import univ
-
-from pyasn1_modules import rfc5652
-from pyasn1_modules import rfc6402
-from pyasn1_modules import rfc7191
-
-
-# SingleAttribute is the same as Attribute in RFC 5652, except that the
-# attrValues SET must have one and only one member
-
-Attribute = rfc7191.SingleAttribute
-
-
-# DirectoryString is the same as RFC 5280, except the length is limited to 255
-
-class DirectoryString(univ.Choice):
- pass
-
-DirectoryString.componentType = namedtype.NamedTypes(
- namedtype.NamedType('teletexString', char.TeletexString().subtype(
- subtypeSpec=constraint.ValueSizeConstraint(1, 255))),
- namedtype.NamedType('printableString', char.PrintableString().subtype(
- subtypeSpec=constraint.ValueSizeConstraint(1, 255))),
- namedtype.NamedType('universalString', char.UniversalString().subtype(
- subtypeSpec=constraint.ValueSizeConstraint(1, 255))),
- namedtype.NamedType('utf8String', char.UTF8String().subtype(
- subtypeSpec=constraint.ValueSizeConstraint(1, 255))),
- namedtype.NamedType('bmpString', char.BMPString().subtype(
- subtypeSpec=constraint.ValueSizeConstraint(1, 255)))
-)
-
-
-# OTP Challenge Attribute
-
-id_aa_otpChallenge = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.56')
-
-ub_aa_otpChallenge = univ.Integer(255)
-
-otpChallenge = rfc5652.Attribute()
-otpChallenge['attrType'] = id_aa_otpChallenge
-otpChallenge['attrValues'][0] = DirectoryString()
-
-
-# Revocation Challenge Attribute
-
-id_aa_revocationChallenge = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.57')
-
-ub_aa_revocationChallenge = univ.Integer(255)
-
-revocationChallenge = rfc5652.Attribute()
-revocationChallenge['attrType'] = id_aa_revocationChallenge
-revocationChallenge['attrValues'][0] = DirectoryString()
-
-
-# EST Identity Linking Attribute
-
-id_aa_estIdentityLinking = univ.ObjectIdentifier('1.2.840.113549.1.9.16.2.58')
-
-ub_aa_est_identity_linking = univ.Integer(255)
-
-estIdentityLinking = rfc5652.Attribute()
-estIdentityLinking['attrType'] = id_aa_estIdentityLinking
-estIdentityLinking['attrValues'][0] = DirectoryString()
-
-
-# Map of Attribute Type OIDs to Attributes added to the
-# ones that are in rfc6402.py
-
-_cmcControlAttributesMapUpdate = {
- id_aa_otpChallenge: DirectoryString(),
- id_aa_revocationChallenge: DirectoryString(),
- id_aa_estIdentityLinking: DirectoryString(),
-}
-
-rfc6402.cmcControlAttributesMap.update(_cmcControlAttributesMapUpdate)
\ No newline at end of file
diff --git a/pyasn1_modules/rfc8692.py b/pyasn1_modules/rfc8692.py
new file mode 100644
index 0000000..7a6791a
--- /dev/null
+++ b/pyasn1_modules/rfc8692.py
@@ -0,0 +1,79 @@
+#
+# 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
+#
+# Algorithm Identifiers for RSASSA-PSS and ECDSA using SHAKEs
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc8692.txt
+#
+
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc4055
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5480
+
+
+# SHAKE128 One-Way Hash Function
+
+id_shake128 = univ.ObjectIdentifier('2.16.840.1.101.3.4.2.11')
+
+mda_shake128 = rfc5280.AlgorithmIdentifier()
+mda_shake128['algorithm'] = id_shake128
+# mda_shake128['parameters'] is absent
+
+
+# SHAKE256 One-Way Hash Function
+
+id_shake256 = univ.ObjectIdentifier('2.16.840.1.101.3.4.2.12')
+
+mda_shake256 = rfc5280.AlgorithmIdentifier()
+mda_shake256['algorithm'] = id_shake256
+# mda_shake256['parameters'] is absent
+
+
+# RSA PSS with SHAKE128
+
+id_RSASSA_PSS_SHAKE128 = univ.ObjectIdentifier('1.3.6.1.5.5.7.6.30')
+
+sa_rSASSA_PSS_SHAKE128 = rfc5280.AlgorithmIdentifier()
+sa_rSASSA_PSS_SHAKE128['algorithm'] = id_RSASSA_PSS_SHAKE128
+# sa_rSASSA_PSS_SHAKE128['parameters'] is absent
+
+pk_rsaSSA_PSS_SHAKE128 = rfc4055.RSAPublicKey()
+
+
+# RSA PSS with SHAKE256
+
+id_RSASSA_PSS_SHAKE256 = univ.ObjectIdentifier('1.3.6.1.5.5.7.6.31')
+
+sa_rSASSA_PSS_SHAKE256 = rfc5280.AlgorithmIdentifier()
+sa_rSASSA_PSS_SHAKE256['algorithm'] = id_RSASSA_PSS_SHAKE256
+# sa_rSASSA_PSS_SHAKE256['parameters'] is absent
+
+pk_rsaSSA_PSS_SHAKE256 = rfc4055.RSAPublicKey()
+
+
+# ECDSA with SHAKE128
+
+id_ecdsa_with_shake128 = univ.ObjectIdentifier('1.3.6.1.5.5.7.6.32')
+
+sa_ecdsa_with_shake128 = rfc5280.AlgorithmIdentifier()
+sa_ecdsa_with_shake128['algorithm'] = id_ecdsa_with_shake128
+# sa_ecdsa_with_shake128['parameters'] is absent
+
+pk_ec = rfc5480.ECPoint()
+
+
+# ECDSA with SHAKE128
+
+id_ecdsa_with_shake256 = univ.ObjectIdentifier('1.3.6.1.5.5.7.6.33')
+
+sa_ecdsa_with_shake256 = rfc5280.AlgorithmIdentifier()
+sa_ecdsa_with_shake256['algorithm'] = id_ecdsa_with_shake256
+# sa_ecdsa_with_shake256['parameters'] is absent
diff --git a/pyasn1_modules/rfc8696.py b/pyasn1_modules/rfc8696.py
new file mode 100644
index 0000000..4c6d38d
--- /dev/null
+++ b/pyasn1_modules/rfc8696.py
@@ -0,0 +1,104 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley with some assistance from asn1ate v.0.6.0.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Using Pre-Shared Key (PSK) in the Cryptographic Message Syntax (CMS)
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc8696.txt
+#
+
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import namedval
+from pyasn1.type import tag
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5652
+
+MAX = float('inf')
+
+
+id_ori = univ.ObjectIdentifier('1.2.840.113549.1.9.16.13')
+
+id_ori_keyTransPSK = univ.ObjectIdentifier('1.2.840.113549.1.9.16.13.1')
+
+id_ori_keyAgreePSK = univ.ObjectIdentifier('1.2.840.113549.1.9.16.13.2')
+
+
+class PreSharedKeyIdentifier(univ.OctetString):
+ pass
+
+
+class KeyTransRecipientInfos(univ.SequenceOf):
+ componentType = rfc5652.KeyTransRecipientInfo()
+
+
+class KeyTransPSKRecipientInfo(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('version',
+ rfc5652.CMSVersion()),
+ namedtype.NamedType('pskid',
+ PreSharedKeyIdentifier()),
+ namedtype.NamedType('kdfAlgorithm',
+ rfc5652.KeyDerivationAlgorithmIdentifier()),
+ namedtype.NamedType('keyEncryptionAlgorithm',
+ rfc5652.KeyEncryptionAlgorithmIdentifier()),
+ namedtype.NamedType('ktris',
+ KeyTransRecipientInfos()),
+ namedtype.NamedType('encryptedKey',
+ rfc5652.EncryptedKey())
+ )
+
+
+class KeyAgreePSKRecipientInfo(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('version',
+ rfc5652.CMSVersion()),
+ namedtype.NamedType('pskid',
+ PreSharedKeyIdentifier()),
+ namedtype.NamedType('originator',
+ rfc5652.OriginatorIdentifierOrKey().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatConstructed, 0))),
+ namedtype.OptionalNamedType('ukm',
+ rfc5652.UserKeyingMaterial().subtype(explicitTag=tag.Tag(
+ tag.tagClassContext, tag.tagFormatSimple, 1))),
+ namedtype.NamedType('kdfAlgorithm',
+ rfc5652.KeyDerivationAlgorithmIdentifier()),
+ namedtype.NamedType('keyEncryptionAlgorithm',
+ rfc5652.KeyEncryptionAlgorithmIdentifier()),
+ namedtype.NamedType('recipientEncryptedKeys',
+ rfc5652.RecipientEncryptedKeys())
+ )
+
+
+class CMSORIforPSKOtherInfo(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.NamedType('psk',
+ univ.OctetString()),
+ namedtype.NamedType('keyMgmtAlgType',
+ univ.Enumerated(namedValues=namedval.NamedValues(
+ ('keyTrans', 5), ('keyAgree', 10)))),
+ namedtype.NamedType('keyEncryptionAlgorithm',
+ rfc5652.KeyEncryptionAlgorithmIdentifier()),
+ namedtype.NamedType('pskLength',
+ univ.Integer().subtype(
+ subtypeSpec=constraint.ValueRangeConstraint(1, MAX))),
+ namedtype.NamedType('kdkLength',
+ univ.Integer().subtype(
+ subtypeSpec=constraint.ValueRangeConstraint(1, MAX)))
+ )
+
+
+# Update the CMS Other Recipient Info map in rfc5652.py
+
+_otherRecipientInfoMapUpdate = {
+ id_ori_keyTransPSK: KeyTransPSKRecipientInfo(),
+ id_ori_keyAgreePSK: KeyAgreePSKRecipientInfo(),
+}
+
+rfc5652.otherRecipientInfoMap.update(_otherRecipientInfoMapUpdate)
diff --git a/pyasn1_modules/rfc8702.py b/pyasn1_modules/rfc8702.py
new file mode 100644
index 0000000..977c278
--- /dev/null
+++ b/pyasn1_modules/rfc8702.py
@@ -0,0 +1,105 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley with assistance from asn1ate v.0.6.0.
+#
+# Copyright (c) 2020, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# SHAKE One-way Hash Functions for CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc8702.txt
+#
+from pyasn1.type import namedtype
+from pyasn1.type import tag
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc8692
+
+
+# Imports fprm RFC 5280
+
+AlgorithmIdentifier = rfc5280.AlgorithmIdentifier
+
+
+# Imports from RFC 8692
+
+id_shake128 = rfc8692.id_shake128
+
+mda_shake128 = rfc8692.mda_shake128
+
+id_shake256 = rfc8692.id_shake256
+
+mda_shake256 = rfc8692.mda_shake256
+
+id_RSASSA_PSS_SHAKE128 = rfc8692.id_RSASSA_PSS_SHAKE128
+
+sa_rSASSA_PSS_SHAKE128 = rfc8692.sa_rSASSA_PSS_SHAKE128
+
+pk_rsaSSA_PSS_SHAKE128 = rfc8692.pk_rsaSSA_PSS_SHAKE128
+
+id_RSASSA_PSS_SHAKE256 = rfc8692.id_RSASSA_PSS_SHAKE256
+
+sa_rSASSA_PSS_SHAKE256 = rfc8692.sa_rSASSA_PSS_SHAKE256
+
+pk_rsaSSA_PSS_SHAKE256 = rfc8692.pk_rsaSSA_PSS_SHAKE256
+
+id_ecdsa_with_shake128 = rfc8692.id_ecdsa_with_shake128
+
+sa_ecdsa_with_shake128 = rfc8692.sa_ecdsa_with_shake128
+
+id_ecdsa_with_shake256 = rfc8692.id_ecdsa_with_shake256
+
+sa_ecdsa_with_shake256 = rfc8692.sa_ecdsa_with_shake256
+
+pk_ec = rfc8692.pk_ec
+
+
+# KMAC with SHAKE128
+
+id_KMACWithSHAKE128 = univ.ObjectIdentifier('2.16.840.1.101.3.4.2.19')
+
+
+class KMACwithSHAKE128_params(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.DefaultedNamedType('kMACOutputLength',
+ univ.Integer().subtype(value=256)),
+ namedtype.DefaultedNamedType('customizationString',
+ univ.OctetString().subtype(value=''))
+ )
+
+
+maca_KMACwithSHAKE128 = AlgorithmIdentifier()
+maca_KMACwithSHAKE128['algorithm'] = id_KMACWithSHAKE128
+maca_KMACwithSHAKE128['parameters'] = KMACwithSHAKE128_params()
+
+
+# KMAC with SHAKE256
+
+id_KMACWithSHAKE256 = univ.ObjectIdentifier('2.16.840.1.101.3.4.2.20')
+
+
+class KMACwithSHAKE256_params(univ.Sequence):
+ componentType = namedtype.NamedTypes(
+ namedtype.DefaultedNamedType('kMACOutputLength',
+ univ.Integer().subtype(value=512)),
+ namedtype.DefaultedNamedType('customizationString',
+ univ.OctetString().subtype(value=''))
+ )
+
+
+maca_KMACwithSHAKE256 = AlgorithmIdentifier()
+maca_KMACwithSHAKE256['algorithm'] = id_KMACWithSHAKE256
+maca_KMACwithSHAKE256['parameters'] = KMACwithSHAKE256_params()
+
+
+# Update the Algorithm Identifier map in rfc5280.py
+
+_algorithmIdentifierMapUpdate = {
+ id_KMACWithSHAKE128: KMACwithSHAKE128_params(),
+ id_KMACWithSHAKE256: KMACwithSHAKE256_params(),
+}
+
+rfc5280.algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)
diff --git a/pyasn1_modules/rfc8708.py b/pyasn1_modules/rfc8708.py
new file mode 100644
index 0000000..3e9909c
--- /dev/null
+++ b/pyasn1_modules/rfc8708.py
@@ -0,0 +1,41 @@
+# This file is being contributed to pyasn1-modules software.
+#
+# Created by Russ Housley
+#
+# Copyright (c) 2020, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# HSS/LMS Hash-based Signature Algorithm for CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc8708.txt
+
+
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+
+# Object Identifiers
+
+id_alg_hss_lms_hashsig = univ.ObjectIdentifier('1.2.840.113549.1.9.16.3.17')
+
+id_alg_mts_hashsig = id_alg_hss_lms_hashsig
+
+
+# Signature Algorithm Identifier
+
+sa_HSS_LMS_HashSig = rfc5280.AlgorithmIdentifier()
+sa_HSS_LMS_HashSig['algorithm'] = id_alg_hss_lms_hashsig
+# sa_HSS_LMS_HashSig['parameters'] is alway absent
+
+
+# Public Key
+
+class HSS_LMS_HashSig_PublicKey(univ.OctetString):
+ pass
+
+
+pk_HSS_LMS_HashSig = rfc5280.SubjectPublicKeyInfo()
+pk_HSS_LMS_HashSig['algorithm'] = sa_HSS_LMS_HashSig
+# pk_HSS_LMS_HashSig['parameters'] CONTAINS a DER-encoded HSS_LMS_HashSig_PublicKey
diff --git a/pyasn1_modules/rfc8769.py b/pyasn1_modules/rfc8769.py
new file mode 100644
index 0000000..5d2b300
--- /dev/null
+++ b/pyasn1_modules/rfc8769.py
@@ -0,0 +1,21 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley.
+#
+# Copyright (c) 2020, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# CBOR Content for CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc8769.txt
+#
+
+from pyasn1.type import univ
+
+
+id_ct_cbor = univ.ObjectIdentifier('1.2.840.113549.1.9.16.1.44')
+
+
+id_ct_cborSequence = univ.ObjectIdentifier('1.2.840.113549.1.9.16.1.45')
diff --git a/setup.py b/setup.py
index 7a0ecd0..7f7c332 100644
--- a/setup.py
+++ b/setup.py
@@ -2,10 +2,12 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
+
doclines = """A collection of ASN.1-based protocols modules.
@@ -29,14 +31,8 @@ License :: OSI Approved :: BSD License
Natural Language :: English
Operating System :: OS Independent
Programming Language :: Python :: 2
-Programming Language :: Python :: 2.4
-Programming Language :: Python :: 2.5
-Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3
-Programming Language :: Python :: 3.2
-Programming Language :: Python :: 3.3
-Programming Language :: Python :: 3.4
Programming Language :: Python :: 3.5
Programming Language :: Python :: 3.6
Programming Language :: Python :: 3.7
@@ -61,8 +57,8 @@ def howto_install_setuptools():
""")
-if sys.version_info[:2] < (2, 4):
- print("ERROR: this package requires Python 2.4 or later!")
+if sys.version_info[:2] < (2, 7):
+ print("ERROR: this package requires Python 2.7 or later!")
sys.exit(1)
try:
@@ -70,7 +66,7 @@ try:
params = {
'zip_safe': True,
- 'install_requires': ['pyasn1>=0.4.6,<0.5.0']
+ 'install_requires': ['pyasn1>=0.4.6,<0.6.0']
}
except ImportError:
@@ -81,14 +77,9 @@ except ImportError:
from distutils.core import setup, Command
- if sys.version_info[:2] > (2, 4):
- params = {
- 'requires': ['pyasn1(>=0.4.6,<0.5.0)']
- }
- else:
- params = {
- 'requires': ['pyasn1']
- }
+ params = {
+ 'requires': ['pyasn1(>=0.4.6,<0.6.0)']
+ }
params.update(
{'name': 'pyasn1-modules',
@@ -100,17 +91,11 @@ params.update(
'author_email': 'etingof@gmail.com',
'url': 'https://github.com/etingof/pyasn1-modules',
'platforms': ['any'],
+ 'python_requires': '>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*',
'classifiers': [x for x in classifiers.split('\n') if x],
'license': 'BSD-2-Clause',
- 'packages': ['pyasn1_modules']}
-)
-
-
-# handle unittest discovery feature
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
+ 'packages': ['pyasn1_modules'],
+ 'python_requires': '>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*'})
class PyTest(Command):
diff --git a/tests/__main__.py b/tests/__main__.py
index dd0bc32..4e10bc8 100644
--- a/tests/__main__.py
+++ b/tests/__main__.py
@@ -1,14 +1,10 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
+import unittest
suite = unittest.TestLoader().loadTestsFromNames(
['tests.test_pem.suite',
@@ -20,21 +16,30 @@ suite = unittest.TestLoader().loadTestsFromNames(
'tests.test_rfc2560.suite',
'tests.test_rfc2631.suite',
'tests.test_rfc2634.suite',
+ 'tests.test_rfc2876.suite',
'tests.test_rfc2985.suite',
'tests.test_rfc2986.suite',
+ 'tests.test_rfc3058.suite',
'tests.test_rfc3114.suite',
+ 'tests.test_rfc3125.suite',
'tests.test_rfc3161.suite',
'tests.test_rfc3274.suite',
'tests.test_rfc3279.suite',
'tests.test_rfc3280.suite',
'tests.test_rfc3281.suite',
+ 'tests.test_rfc3370.suite',
'tests.test_rfc3447.suite',
+ 'tests.test_rfc3537.suite',
'tests.test_rfc3560.suite',
'tests.test_rfc3565.suite',
+ 'tests.test_rfc3657.suite',
'tests.test_rfc3709.suite',
+ 'tests.test_rfc3739.suite',
'tests.test_rfc3770.suite',
'tests.test_rfc3779.suite',
+ 'tests.test_rfc3820.suite',
'tests.test_rfc3852.suite',
+ 'tests.test_rfc4010.suite',
'tests.test_rfc4043.suite',
'tests.test_rfc4055.suite',
'tests.test_rfc4073.suite',
@@ -42,16 +47,29 @@ suite = unittest.TestLoader().loadTestsFromNames(
'tests.test_rfc4210.suite',
'tests.test_rfc4211.suite',
'tests.test_rfc4334.suite',
+ 'tests.test_rfc4357.suite',
+ 'tests.test_rfc4387.suite',
+ 'tests.test_rfc4476.suite',
+ 'tests.test_rfc4490.suite',
+ 'tests.test_rfc4491.suite',
+ 'tests.test_rfc4683.suite',
'tests.test_rfc4985.suite',
'tests.test_rfc5035.suite',
'tests.test_rfc5083.suite',
'tests.test_rfc5084.suite',
+ 'tests.test_rfc5126.suite',
'tests.test_rfc5208.suite',
+ 'tests.test_rfc5275.suite',
'tests.test_rfc5280.suite',
'tests.test_rfc5480.suite',
+ 'tests.test_rfc5636.suite',
+ 'tests.test_rfc5639.suite',
'tests.test_rfc5649.suite',
'tests.test_rfc5652.suite',
+ 'tests.test_rfc5697.suite',
'tests.test_rfc5751.suite',
+ 'tests.test_rfc5752.suite',
+ 'tests.test_rfc5753.suite',
'tests.test_rfc5755.suite',
'tests.test_rfc5913.suite',
'tests.test_rfc5914.suite',
@@ -104,7 +122,12 @@ suite = unittest.TestLoader().loadTestsFromNames(
'tests.test_rfc8494.suite',
'tests.test_rfc8520.suite',
'tests.test_rfc8619.suite',
- 'tests.test_rfc8649.suite']
+ 'tests.test_rfc8649.suite',
+ 'tests.test_rfc8692.suite',
+ 'tests.test_rfc8696.suite',
+ 'tests.test_rfc8702.suite',
+ 'tests.test_rfc8708.suite',
+ 'tests.test_rfc8769.suite']
)
diff --git a/tests/test_pem.py b/tests/test_pem.py
index 02604fc..dbcca5a 100644
--- a/tests/test_pem.py
+++ b/tests/test_pem.py
@@ -1,21 +1,15 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
from pyasn1.compat.octets import ints2octs
-
from pyasn1_modules import pem
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class PemTestCase(unittest.TestCase):
pem_text = """\
@@ -42,7 +36,7 @@ GGbx7DI=
binary = pem.readBase64fromText(self.pem_text)
- assert binary
+ self.assertTrue(binary)
expected = [
48, 130, 3, 1, 48, 130, 1, 233, 2, 1, 0, 48, 129, 153, 49, 11, 48,
@@ -99,13 +93,11 @@ GGbx7DI=
24, 102, 241, 236, 50
]
- assert ints2octs(expected) == binary
+ self.assertEqual(ints2octs(expected), binary)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc2314.py b/tests/test_rfc2314.py
index f303927..69927a6 100644
--- a/tests/test_rfc2314.py
+++ b/tests/test_rfc2314.py
@@ -1,23 +1,18 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der import decoder as der_decoder
-from pyasn1.codec.der import encoder as der_encoder
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc2314
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class CertificationRequestTestCase(unittest.TestCase):
pem_text = """\
@@ -47,17 +42,15 @@ GGbx7DI=
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc2315.py b/tests/test_rfc2315.py
index 829099f..40030c9 100644
--- a/tests/test_rfc2315.py
+++ b/tests/test_rfc2315.py
@@ -1,23 +1,18 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der import decoder as der_decoder
-from pyasn1.codec.der import encoder as der_encoder
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc2315
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class Pkcs7TestCase(unittest.TestCase):
pem_text_unordered = """\
@@ -146,27 +141,25 @@ Kv0xuR3b3Le+ZqolT8wQELd5Mmw5JPofZ+O2cGNvet8tYwOKFjEA
substrate = pem.readBase64fromText(self.pem_text_unordered)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
def testDerCodecDecodeOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text_reordered)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(
- asn1Object, omitEmptyOptionals=False) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(
+ substrate, der_encoder(asn1Object, omitEmptyOptionals=False))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc2437.py b/tests/test_rfc2437.py
index 2490d10..b411756 100644
--- a/tests/test_rfc2437.py
+++ b/tests/test_rfc2437.py
@@ -1,23 +1,18 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der import decoder as der_decoder
-from pyasn1.codec.der import encoder as der_encoder
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc2437
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class RSAPrivateKeyTestCase(unittest.TestCase):
pem_text = """\
@@ -37,17 +32,15 @@ n8lDw3JT6NjvMnD6aM8KBsLyhazWSVVkaUSqmJzgCF0=
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc2459.py b/tests/test_rfc2459.py
index 4b54e44..4132daa 100644
--- a/tests/test_rfc2459.py
+++ b/tests/test_rfc2459.py
@@ -1,23 +1,18 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der import decoder as der_decoder
-from pyasn1.codec.der import encoder as der_encoder
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc2459
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class CertificateTestCase(unittest.TestCase):
pem_text = """\
@@ -46,21 +41,22 @@ PhmcGcwTTYJBtYze4D1gCCAPRX5ron+jjBXu
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(der_encoder(asn1Object), substrate)
def testDerCodecDecodeOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(der_encoder(asn1Object), substrate)
class CertificateListTestCase(unittest.TestCase):
@@ -82,21 +78,22 @@ vjnIhxTFoCb5vA==
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(der_encoder(asn1Object), substrate)
def testDerCodecDecodeOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(der_encoder(asn1Object), substrate)
class DSAPrivateKeyTestCase(unittest.TestCase):
@@ -120,27 +117,26 @@ INow2I3/ks+0MxDabTY=
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
def testDerCodecDecodeOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc2511.py b/tests/test_rfc2511.py
index 494d017..057b7fe 100644
--- a/tests/test_rfc2511.py
+++ b/tests/test_rfc2511.py
@@ -1,23 +1,18 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der import decoder as der_decoder
-from pyasn1.codec.der import encoder as der_encoder
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc2511
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class CertificateReqTestCase(unittest.TestCase):
pem_text = """\
@@ -39,17 +34,15 @@ xfu5YVWi81/fw8QQ6X6YGHFQkomLd7jxakVyjxSng9BhO6GpjJNF
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc2560.py b/tests/test_rfc2560.py
index fd6db37..eef5451 100644
--- a/tests/test_rfc2560.py
+++ b/tests/test_rfc2560.py
@@ -1,23 +1,18 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der import decoder as der_decoder
-from pyasn1.codec.der import encoder as der_encoder
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc2560
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class OCSPRequestTestCase(unittest.TestCase):
pem_text = """\
@@ -32,11 +27,11 @@ isWVpesQdXMCBDXe9M+iIzAhMB8GCSsGAQUFBzABAgQSBBBjdJOiIW9EKJGELNNf/rdA
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(der_encoder(asn1Object), substrate)
class OCSPResponseTestCase(unittest.TestCase):
@@ -71,17 +66,15 @@ HAESdf7nebz1wtqAOXE1jWF/y8g=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc2631.py b/tests/test_rfc2631.py
index 7abdcd7..ca9e547 100644
--- a/tests/test_rfc2631.py
+++ b/tests/test_rfc2631.py
@@ -5,22 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
from pyasn1_modules import rfc2631
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class OtherInfoTestCase(unittest.TestCase):
pem_text = "MB0wEwYLKoZIhvcNAQkQAwYEBAAAAAGiBgQEAAAAwA=="
@@ -30,19 +24,18 @@ class OtherInfoTestCase(unittest.TestCase):
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
hex1 = univ.OctetString(hexValue='00000001')
- assert asn1Object['keyInfo']['counter'] == hex1
+ self.assertEqual(hex1, asn1Object['keyInfo']['counter'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc2634.py b/tests/test_rfc2634.py
index 18c8a3d..225b987 100644
--- a/tests/test_rfc2634.py
+++ b/tests/test_rfc2634.py
@@ -7,19 +7,15 @@
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc2634
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class SignedMessageTestCase(unittest.TestCase):
signed_message_pem_text = """\
@@ -58,26 +54,30 @@ mNTr0mjYeUWRe/15IsWNx+kuFcLDr71DFHvMFY5M3sdfMA==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.signed_message_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
- sd, rest = der_decode(asn1Object['content'], asn1Spec=rfc5652.SignedData())
- assert not rest
- assert sd.prettyPrint()
- assert der_encode(sd) == asn1Object['content']
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
+ sd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.SignedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(sd.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(sd))
for sa in sd['signerInfos'][0]['signedAttrs']:
sat = sa['attrType']
sav0 = sa['attrValues'][0]
if sat in rfc5652.cmsAttributesMap.keys():
- sav, rest = der_decode(sav0, asn1Spec=rfc5652.cmsAttributesMap[sat])
- assert not rest
- assert sav.prettyPrint()
- assert der_encode(sav) == sav0
+ sav, rest = der_decoder(
+ sav0, asn1Spec=rfc5652.cmsAttributesMap[sat])
+ self.assertFalse(rest)
+ self.assertTrue(sav.prettyPrint())
+ self.assertEqual(sav0, der_encoder(sav))
class SignedReceiptTestCase(unittest.TestCase):
@@ -116,68 +116,76 @@ lropBdPJ6jIXiZQgCwxbGTCwCMQClaQ9K+L5LTeuW50ZKSIbmBZQ5dxjtnK3OlS
def testDerCodec(self):
substrate = pem.readBase64fromText(self.signed_receipt_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
- sd, rest = der_decode (asn1Object['content'], asn1Spec=rfc5652.SignedData())
- assert not rest
- assert sd.prettyPrint()
- assert der_encode(sd) == asn1Object['content']
-
- assert sd['encapContentInfo']['eContentType'] == rfc2634.id_ct_receipt
- receipt, rest = der_decode(sd['encapContentInfo']['eContent'],
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(asn1Object['contentType'], rfc5652.id_signedData)
+
+ sd, rest = der_decoder(asn1Object['content'], asn1Spec=rfc5652.SignedData())
+
+ self.assertFalse(rest)
+
+ self.assertTrue(sd.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(sd))
+ self.assertEqual(sd['encapContentInfo']['eContentType'],
+ rfc2634.id_ct_receipt)
+
+ receipt, rest = der_decoder(sd['encapContentInfo']['eContent'],
asn1Spec=rfc2634.Receipt())
- assert not rest
- assert receipt.prettyPrint()
- assert der_encode(receipt) == sd['encapContentInfo']['eContent']
- assert receipt['version'] == rfc2634.ESSVersion().subtype(value='v1')
+
+ self.assertFalse(rest)
+ self.assertTrue(receipt.prettyPrint())
+ self.assertEqual(sd['encapContentInfo']['eContent'], der_encoder(receipt))
+ self.assertEqual(receipt['version'], rfc2634.ESSVersion().subtype(value='v1'))
for sa in sd['signerInfos'][0]['signedAttrs']:
sat = sa['attrType']
sav0 = sa['attrValues'][0]
if sat in rfc5652.cmsAttributesMap.keys():
- sav, rest = der_decode(sav0, asn1Spec=rfc5652.cmsAttributesMap[sat])
- assert not rest
- assert sav.prettyPrint()
- assert der_encode(sav) == sav0
+ sav, rest = der_decoder(sav0, asn1Spec=rfc5652.cmsAttributesMap[sat])
+
+ self.assertFalse(rest)
+ self.assertTrue(sav.prettyPrint())
+ self.assertEqual(sav0, der_encoder(sav))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.signed_receipt_pem_text)
- asn1Object, rest = der_decode(substrate,
+ asn1Object, rest = der_decoder(substrate,
asn1Spec=self.asn1Spec,
decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
- assert asn1Object['contentType'] in rfc5652.cmsContentTypesMap.keys()
- assert asn1Object['contentType'] == rfc5652.id_signedData
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertIn(asn1Object['contentType'], rfc5652.cmsContentTypesMap.keys())
+ self.assertEqual(asn1Object['contentType'], rfc5652.id_signedData)
sd = asn1Object['content']
- assert sd['version'] == rfc5652.CMSVersion().subtype(value='v3')
- assert sd['encapContentInfo']['eContentType'] in rfc5652.cmsContentTypesMap.keys()
- assert sd['encapContentInfo']['eContentType'] == rfc2634.id_ct_receipt
+
+ self.assertEqual(sd['version'], rfc5652.CMSVersion().subtype(value='v3'))
+ self.assertIn(sd['encapContentInfo']['eContentType'], rfc5652.cmsContentTypesMap)
+ self.assertEqual(sd['encapContentInfo']['eContentType'], rfc2634.id_ct_receipt)
for sa in sd['signerInfos'][0]['signedAttrs']:
- assert sa['attrType'] in rfc5652.cmsAttributesMap.keys()
+
+ self.assertIn(sa['attrType'], rfc5652.cmsAttributesMap)
+
if sa['attrType'] == rfc2634.id_aa_msgSigDigest:
sa['attrValues'][0].prettyPrint()[:10] == '0x167378'
# Since receipt is inside an OCTET STRING, decodeOpenTypes=True cannot
# automatically decode it
- receipt, rest = der_decode(sd['encapContentInfo']['eContent'],
+ receipt, rest = der_decoder(sd['encapContentInfo']['eContent'],
asn1Spec=rfc5652.cmsContentTypesMap[sd['encapContentInfo']['eContentType']])
- assert receipt['version'] == rfc2634.ESSVersion().subtype(value='v1')
+
+ self.assertEqual(receipt['version'], rfc2634.ESSVersion().subtype(value='v1'))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc2876.py b/tests/test_rfc2876.py
new file mode 100644
index 0000000..177e038
--- /dev/null
+++ b/tests/test_rfc2876.py
@@ -0,0 +1,185 @@
+#
+# 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.type import univ
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc2876
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5751
+
+try:
+ import unittest2 as unittest
+except ImportError:
+ import unittest
+
+
+class EnvelopedDataTestCase(unittest.TestCase):
+ env_data_pem_text = """\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+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.env_data_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+ ed, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.EnvelopedData())
+ self.assertFalse(rest)
+ self.assertTrue(ed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ed))
+
+ kari_kea = ed['recipientInfos'][0]['kari']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc2876.id_kEAKeyEncryptionAlgorithm, kari_kea['algorithm'])
+ kwa, rest = der_decoder(
+ kari_kea['parameters'], asn1Spec=rfc5280.AlgorithmIdentifier())
+ self.assertFalse(rest)
+ self.assertTrue(kwa.prettyPrint())
+ self.assertEqual(kari_kea['parameters'], der_encoder(kwa))
+ self.assertEqual(rfc2876.id_fortezzaWrap80, kwa['algorithm'])
+
+ cea = ed['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc2876.id_fortezzaConfidentialityAlgorithm, cea['algorithm'])
+ param, rest = der_decoder(cea['parameters'], rfc2876.Skipjack_Parm())
+ self.assertFalse(rest)
+ self.assertTrue(param.prettyPrint())
+ self.assertEqual(cea['parameters'], der_encoder(param))
+
+ iv = univ.OctetString(hexValue='424f4755535f4956')
+ self.assertEqual(iv, param['initialization-vector'])
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.env_data_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertIn(asn1Object['contentType'], rfc5652.cmsContentTypesMap.keys())
+ kari_kea = asn1Object['content']['recipientInfos'][0]['kari']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc2876.id_kEAKeyEncryptionAlgorithm, kari_kea['algorithm'])
+ self.assertEqual(rfc2876.id_fortezzaWrap80, kari_kea['parameters']['algorithm'])
+
+ cea = asn1Object['content']['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc2876.id_fortezzaConfidentialityAlgorithm, cea['algorithm'])
+
+ iv = univ.OctetString(hexValue='424f4755535f4956')
+ self.assertEqual(iv, cea['parameters']['initialization-vector'])
+
+class SMIMECapabilitiesTestCase(unittest.TestCase):
+ smime_capabilities_pem_text = "\
+MCcwGAYJYIZIAWUCAQEYMAsGCWCGSAFlAgEBFzALBglghkgBZQIBAQQ="
+
+ def setUp(self):
+ self.asn1Spec = rfc5751.SMIMECapabilities()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ found_wrap_alg = False
+ for cap in asn1Object:
+ if cap['capabilityID'] in rfc5751.smimeCapabilityMap.keys():
+ if cap['parameters'].hasValue():
+ param, rest = der_decoder(
+ cap['parameters'],
+ asn1Spec=rfc5751.smimeCapabilityMap[cap['capabilityID']])
+ self.assertFalse(rest)
+ self.assertTrue(param.prettyPrint())
+ self.assertEqual(cap['parameters'], der_encoder(param))
+
+ if cap['capabilityID'] == rfc2876.id_kEAKeyEncryptionAlgorithm:
+ self.assertEqual(rfc2876.id_fortezzaWrap80, param['algorithm'])
+ found_wrap_alg = True
+
+ self.assertTrue(found_wrap_alg)
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ found_wrap_alg = False
+ for cap in asn1Object:
+ if cap['capabilityID'] == rfc2876.id_kEAKeyEncryptionAlgorithm:
+ self.assertEqual(rfc2876.id_fortezzaWrap80, cap['parameters']['algorithm'])
+ found_wrap_alg = True
+
+ self.assertTrue(found_wrap_alg)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ unittest.TextTestRunner(verbosity=2).run(suite)
diff --git a/tests/test_rfc2985.py b/tests/test_rfc2985.py
index f95ede8..376475e 100644
--- a/tests/test_rfc2985.py
+++ b/tests/test_rfc2985.py
@@ -6,10 +6,10 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
@@ -19,13 +19,6 @@ from pyasn1_modules import rfc5652
from pyasn1_modules import rfc7292
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
-
class PKCS9AttrsTestCase(unittest.TestCase):
pem_text = """\
MYIQjzAOBgNVBEExBwwFQWxpY2UwDwYIKwYBBQUHCQMxAxMBTTAQBgNVBAUxCRMH
@@ -124,10 +117,11 @@ HktMK+isIjxOTk4yJTOOAgIH0A==
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(der_encoder(asn1Object), substrate)
openTypesMap = {
rfc2985.pkcs_9_at_smimeCapabilities: rfc2985.SMIMECapabilities(),
@@ -136,88 +130,104 @@ HktMK+isIjxOTk4yJTOOAgIH0A==
openTypesMap.update(rfc5652.cmsAttributesMap)
for attr in asn1Object:
- assert attr['type'] in openTypesMap.keys()
- av, rest = der_decode(attr['values'][0],
- asn1Spec=openTypesMap[attr['type']])
- assert not rest
- assert av.prettyPrint()
- assert der_encode(av) == attr['values'][0]
+ self.assertIn(attr['type'], openTypesMap)
+
+ av, rest = der_decoder(
+ attr['values'][0], asn1Spec=openTypesMap[attr['type']])
+
+ self.assertFalse(rest)
+ self.assertTrue(av.prettyPrint())
+ self.assertEqual(attr['values'][0], der_encoder(av))
if attr['type'] == rfc2985.pkcs_9_at_userPKCS12:
- assert av['version'] == univ.Integer(3)
- assert av['authSafe']['contentType'] == rfc5652.id_data
- outdata, rest = der_decode(av['authSafe']['content'],
- asn1Spec=univ.OctetString())
- assert not rest
- authsafe, rest = der_decode(outdata,
- asn1Spec=rfc7292.AuthenticatedSafe())
- assert not rest
+
+ self.assertEqual(univ.Integer(3), av['version'])
+ self.assertEqual(rfc5652.id_data, av['authSafe']['contentType'])
+
+ outdata, rest = der_decoder(
+ av['authSafe']['content'], asn1Spec=univ.OctetString())
+
+ self.assertFalse(rest)
+
+ authsafe, rest = der_decoder(
+ outdata, asn1Spec=rfc7292.AuthenticatedSafe())
+
+ self.assertFalse(rest)
for ci in authsafe:
- assert ci['contentType'] == rfc5652.id_data
- indata, rest = der_decode(ci['content'],
- asn1Spec=univ.OctetString())
- assert not rest
- sc, rest = der_decode(indata,
- asn1Spec=rfc7292.SafeContents())
- assert not rest
+ self.assertEqual(rfc5652.id_data, ci['contentType'])
+
+ indata, rest = der_decoder(
+ ci['content'], asn1Spec=univ.OctetString())
+
+ self.assertFalse(rest)
+
+ sc, rest = der_decoder(
+ indata, asn1Spec=rfc7292.SafeContents())
+
+ self.assertFalse(rest)
for sb in sc:
if sb['bagId'] in rfc7292.pkcs12BagTypeMap:
- bv, rest = der_decode(sb['bagValue'],
- asn1Spec=rfc7292.pkcs12BagTypeMap[sb['bagId']])
- assert not rest
+ bv, rest = der_decoder(
+ sb['bagValue'], asn1Spec=rfc7292.pkcs12BagTypeMap[sb['bagId']])
+
+ self.assertFalse(rest)
for bagattr in sb['bagAttributes']:
if bagattr['attrType'] in openTypesMap:
- inav, rest = der_decode(bagattr['attrValues'][0],
- asn1Spec=openTypesMap[bagattr['attrType']])
- assert not rest
+ inav, rest = der_decoder(
+ bagattr['attrValues'][0], asn1Spec=openTypesMap[bagattr['attrType']])
+
+ self.assertFalse(rest)
if bagattr['attrType'] == rfc2985.pkcs_9_at_friendlyName:
- assert inav == "3f71af65-1687-444a-9f46-c8be194c3e8e"
+ self.assertEqual( "3f71af65-1687-444a-9f46-c8be194c3e8e", inav)
if bagattr['attrType'] == rfc2985.pkcs_9_at_localKeyId:
- assert inav == univ.OctetString(hexValue='01000000')
+ self.assertEqual(univ.OctetString(hexValue='01000000'), inav)
if attr['type'] == rfc2985.pkcs_9_at_pkcs7PDU:
- ci, rest = der_decode(attr['values'][0],
- asn1Spec=rfc5652.ContentInfo())
- assert not rest
- assert ci['contentType'] == rfc5652.id_signedData
-
- sd, rest = der_decode(ci['content'],
- asn1Spec=rfc5652.SignedData())
- assert not rest
- assert sd['version'] == 1
+ ci, rest = der_decoder(
+ attr['values'][0], asn1Spec=rfc5652.ContentInfo())
+
+ self.assertFalse(rest)
+ self.assertEqual(rfc5652.id_signedData, ci['contentType'])
+
+ sd, rest = der_decoder(
+ ci['content'], asn1Spec=rfc5652.SignedData())
+
+ self.assertFalse(rest)
+ self.assertEqual(1, sd['version'])
for si in sd['signerInfos']:
- assert si['version'] == 1
+ self.assertEqual(1, si['version'])
for siattr in si['signedAttrs']:
if siattr['attrType'] in openTypesMap:
- siav, rest = der_decode(siattr['attrValues'][0],
- asn1Spec=openTypesMap[siattr['attrType']])
- assert not rest
+ siav, rest = der_decoder(
+ siattr['attrValues'][0], asn1Spec=openTypesMap[siattr['attrType']])
+
+ self.assertFalse(rest)
if siattr['attrType'] == rfc2985.pkcs_9_at_contentType:
- assert siav == rfc5652.id_data
+ self.assertEqual(rfc5652.id_data, siav)
if siattr['attrType'] == rfc2985.pkcs_9_at_messageDigest:
- assert siav.prettyPrint()[2:10] == 'b6e422a4'
+ self.assertEqual('b6e422a4', siav.prettyPrint()[2:10])
if siattr['attrType'] == rfc2985.pkcs_9_at_signingTime:
- assert siav['utcTime'] == '190529182319Z'
+ self.assertEqual('190529182319Z', siav['utcTime'])
for choices in sd['certificates']:
for rdn in choices[0]['tbsCertificate']['subject']['rdnSequence']:
if rdn[0]['type'] in openTypesMap:
- nv, rest = der_decode(rdn[0]['value'],
- asn1Spec=openTypesMap[rdn[0]['type']])
- assert not rest
+ nv, rest = der_decoder(
+ rdn[0]['value'], asn1Spec=openTypesMap[rdn[0]['type']])
+ self.assertFalse(rest)
if rdn[0]['type'] == rfc2985.pkcs_9_at_emailAddress:
- assert nv == 'alice@example.com'
+ self.assertEqual('alice@example.com', nv)
def testOpenTypes(self):
openTypesMap = {
@@ -227,34 +237,40 @@ HktMK+isIjxOTk4yJTOOAgIH0A==
openTypesMap.update(rfc5652.cmsAttributesMap)
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- openTypes=openTypesMap,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec,
+ openTypes=openTypesMap, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for attr in asn1Object:
- assert attr['type'] in openTypesMap.keys()
+ self.assertTrue(attr['type'], openTypesMap)
if attr['type'] == rfc2985.pkcs_9_at_userPKCS12:
- assert attr['values'][0]['version'] == univ.Integer(3)
- assert attr['values'][0]['authSafe']['contentType'] == rfc5652.id_data
- authsafe, rest = der_decode(attr['values'][0]['authSafe']['content'],
+
+ self.assertEqual(univ.Integer(3), attr['values'][0]['version'])
+ self.assertEqual(rfc5652.id_data, attr['values'][0]['authSafe']['contentType'])
+
+ authsafe, rest = der_decoder(
+ attr['values'][0]['authSafe']['content'],
asn1Spec=rfc7292.AuthenticatedSafe())
- assert not rest
+
+ self.assertFalse(rest)
for ci in authsafe:
- assert ci['contentType'] == rfc5652.id_data
- indata, rest = der_decode(ci['content'],
- asn1Spec=univ.OctetString())
- assert not rest
+ self.assertEqual(rfc5652.id_data, ci['contentType'])
+
+ indata, rest = der_decoder(
+ ci['content'], asn1Spec=univ.OctetString())
+
+ self.assertFalse(rest)
+
+ sc, rest = der_decoder(
+ indata, asn1Spec=rfc7292.SafeContents(), decodeOpenTypes=True)
- sc, rest = der_decode(indata,
- asn1Spec=rfc7292.SafeContents(),
- decodeOpenTypes=True)
- assert not rest
+ self.assertFalse(rest)
for sb in sc:
if sb['bagId'] in rfc7292.pkcs12BagTypeMap:
@@ -262,35 +278,39 @@ HktMK+isIjxOTk4yJTOOAgIH0A==
if bagattr['attrType'] in openTypesMap:
if bagattr['attrType'] == rfc2985.pkcs_9_at_friendlyName:
- assert bagattr['attrValues'][0] == "3f71af65-1687-444a-9f46-c8be194c3e8e"
+ self.assertEqual(
+ "3f71af65-1687-444a-9f46-c8be194c3e8e",
+ bagattr['attrValues'][0])
if bagattr['attrType'] == rfc2985.pkcs_9_at_localKeyId:
- assert bagattr['attrValues'][0] == univ.OctetString(hexValue='01000000')
+ self.assertEqual(
+ univ.OctetString(hexValue='01000000'),
+ bagattr['attrValues'][0])
if attr['type'] == rfc2985.pkcs_9_at_pkcs7PDU:
- assert attr['values'][0]['contentType'] == rfc5652.id_signedData
- assert attr['values'][0]['content']['version'] == 1
+ self.assertEqual(rfc5652.id_signedData, attr['values'][0]['contentType'])
+ self.assertEqual(1, attr['values'][0]['content']['version'])
for si in attr['values'][0]['content']['signerInfos']:
- assert si['version'] == 1
+ self.assertEqual(1, si['version'])
for siattr in si['signedAttrs']:
if siattr['attrType'] in openTypesMap:
if siattr['attrType'] == rfc2985.pkcs_9_at_contentType:
- assert siattr['attrValues'][0] == rfc5652.id_data
+ self.assertEqual(rfc5652.id_data, siattr['attrValues'][0])
if siattr['attrType'] == rfc2985.pkcs_9_at_messageDigest:
- assert siattr['attrValues'][0].prettyPrint()[2:10] == 'b6e422a4'
+ self.assertEqual('b6e422a4', siattr['attrValues'][0].prettyPrint()[2:10])
if siattr['attrType'] == rfc2985.pkcs_9_at_signingTime:
- assert siattr['attrValues'][0]['utcTime'] == '190529182319Z'
+ self.assertEqual('190529182319Z', siattr['attrValues'][0]['utcTime'])
for choices in attr['values'][0]['content']['certificates']:
for rdn in choices[0]['tbsCertificate']['subject']['rdnSequence']:
if rdn[0]['type'] in openTypesMap:
if rdn[0]['type'] == rfc2985.pkcs_9_at_emailAddress:
- assert rdn[0]['value'] == 'alice@example.com'
+ self.assertEqual('alice@example.com', rdn[0]['value'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc2986.py b/tests/test_rfc2986.py
index fa1370d..91e3d05 100644
--- a/tests/test_rfc2986.py
+++ b/tests/test_rfc2986.py
@@ -1,14 +1,14 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import char
from pyasn1.type import univ
@@ -17,13 +17,6 @@ from pyasn1_modules import rfc2986
from pyasn1_modules import rfc5280
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
-
class CertificationRequestTestCase(unittest.TestCase):
pem_text = """\
MIICxjCCAa4CAQAwgYAxCzAJBgNVBAYTAlVTMR0wGwYDVQQDDBRmY3UuZmFrZS5h
@@ -50,11 +43,11 @@ fi6h7i9VVAZpslaKFfkNg12gLbbsCB1q36l5VXjHY/qe0FIUa9ogRrOi
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
def testOpenTypes(self):
openTypesMap = {
@@ -64,33 +57,34 @@ fi6h7i9VVAZpslaKFfkNg12gLbbsCB1q36l5VXjHY/qe0FIUa9ogRrOi
}
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=rfc2986.CertificationRequest(),
- openTypes=openTypesMap,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
+ asn1Object, rest = der_decoder(substrate,
+ asn1Spec=rfc2986.CertificationRequest(),
+ openTypes=openTypesMap,
+ decodeOpenTypes=True)
- assert der_encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for rdn in asn1Object['certificationRequestInfo']['subject']['rdnSequence']:
for atv in rdn:
if atv['type'] == rfc5280.id_at_countryName:
- assert atv['value'] == char.PrintableString('US')
+ self.assertEqual(char.PrintableString('US'), atv['value'])
+
else:
- assert len(atv['value']['utf8String']) > 2
+ self.assertGreater(len(atv['value']['utf8String']), 2)
spki_alg = asn1Object['certificationRequestInfo']['subjectPKInfo']['algorithm']
- assert spki_alg['parameters'] == univ.Null("")
+
+ self.assertEqual(univ.Null(""), spki_alg['parameters'])
sig_alg = asn1Object['signatureAlgorithm']
- assert sig_alg['parameters'] == univ.Null("")
+
+ self.assertEqual(univ.Null(""), sig_alg['parameters'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3058.py b/tests/test_rfc3058.py
new file mode 100644
index 0000000..0a0645c
--- /dev/null
+++ b/tests/test_rfc3058.py
@@ -0,0 +1,140 @@
+#
+# 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
+import unittest
+
+from pyasn1.type import univ
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc3058
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5751
+
+
+class EnvelopedDataTestCase(unittest.TestCase):
+ env_data_pem_text = """\
+MIIFgwYJKoZIhvcNAQcDoIIFdDCCBXACAQIxXaJbAgEEMCMEEDiCUYXKXu8SzLos
+n2xeYP4YDzIwMTkwOTEyMTIwMDAwWjAPBgsrBgEEAYE8BwEBBgUABCB0G/YBGH3L
+3RhoG0mK33M8IvRYAOsnHB5MfUAOGF6kuDCCBQoGCSqGSIb3DQEHATAZBgsrBgEE
+AYE8BwEBAjAKBAhCT0dVU19JVoCCBOBzx7F6GMkP+C0Q4iuDq0rkSZprg8nuXx/4
+S3IMP999BrJdUAbPYxdQhAwTOZIuueyv00TJe/Eam9yyLuZXy0PFlTRi7KED8L8c
+yHsRoEobWGMLvE3D4hEhTGttElqQxBvMxZZgm6kLnNG7j8Z72L4lU4aARLYTQvkt
+lJnnfCaccDSiWzU8eXcXdnZAzcKR7CoDc0/XBpdDRddvQ7KXoarXYHuSybt649YD
+cpy0SN9gEPqcFPrBB3nusAx4VOTlpx5Z3ZJv/TEymN8KDobNfykBZURTwupO9WaV
+JZ3Hd/d8C1SCJn6DHuM1jwDp26WfzO8xCfea08MJrnQbNKsDHwmt4dFZIOvcOnwR
+8nNSB/Lt1aUj3GzluHVMyQQyT4AdZDmwFdNmQOBUBLmbWYhtd7t3O7Eqx8bGNa7V
+7LL0nvua04aj1oA6ph/G/8jxhByBYdN5Bwg7f1Ga3ZCwju2tFoQnWOCPYTVOjmBE
+JshBbNC7KhLpp9+C7/13A9cIC3T7Reuc7m+Fopf9Fabu97yFiyJPS8jSF0EnesNG
+R1L1Uvo2Wdc66iECoSrxvezaSgGKB2uLTnaFx4ASVMcP7gDipEOIwuUUuVCqgmWk
+HAK0Q9mwhBLLrYrsn9OjDHFpvkWgWNRMLl/v3E9A+grFh2BQHkB4C7keB1ZOfj1S
+qDi/+ylM9I1FOYMxVXJn2qHMl+QOkfdMoIATm3n3DiBI97/uX4x5KaX074v0dN31
+WeDcsFsh2ze5Dhx8vLJCaXLzWqkmNHX5G/CjjqE6bSR/awgWLRZQuY/9fMvDpvVJ
+uId/+OoWDtMVPIsyQ8w8yZzv+SkuZhsrJMHiKd5qxNQv5sOvC765LMUCNNwj7WzP
+hajintFXLAEMpIjk5xt3eIy3hdYla3PQoFfqcHOVX4EFMLBoYwBTgik8Fg669yXt
+MlbH84MGNs7jObhP/rrDkgbe0qmxUyzgm2uHya1VcItMGYoPPKMFU3ZfwAsZdqsi
+1GAtruTzSUmOpMfAoKOIAyZP96HrsrPCaoGrn7ysm5eRrHQ2hdwO7rGQIw0dRAFh
+2eyRomoLam7yEiw9M6uHuJ5hIS5yEW+7uUjQT6nvKlbrkIyLL5j9Gbk5Z4fOMqRT
+kBs+3H8x7a+lBEKBo/ByJm6fHYi+LX5ZhQFTWkY0M7tfPtrxQdsNRGSHtv7jS7PZ
+3thCMqCtkG/pjAsCbDUtMThtP08z2fstE6dfy7qSx6LzKLDyBl5W76mVYdsX7Q72
+yIoCDFmUGdrRcWA+l3OMwNNL+x9MhhdaUWPtxqaGyZMNGOjkbYHbXZ69oqYqCHkA
+stIVKTzpk3kq9C9x+ynzWO8kIGYNK2uxSBIzPLQ6Daq4c53rWFFNWVjPC8m98zMc
+Yp0hbBhRsdk4qj8osSTcTfpT0+Q+hkYQvZl4IfgX1aHeaCDSScF8SaU+cZ7GYFvL
+o1cYrtVbeXrFwmWl0xpco1Ux+XZgryT/fgfJ+3ToppgsQmzECqTWmYsSYaF1kLU4
+Cqi9UH/VqBLOkwxoH05Zao2xOMNzu2QO3wFnvY2wBsIj1eaxfzVb42o9vom7V20j
+T1ufXXctf9ls5J1WJxBxdKmXQWdNloeAcl1AtxTbw7vIUU5uWqu9wwqly11MDVPA
+b0tcQW20auWmCNkXd52jQJ7PXR6kr5I=
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.env_data_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+
+ ed, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.EnvelopedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(ed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ed))
+
+ kwa = ed['recipientInfos'][0]['kekri']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc3058.id_alg_CMSIDEAwrap, kwa['algorithm'])
+ self.assertEqual(kwa['parameters'], der_encoder(univ.Null("")))
+
+ cea = ed['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc3058.id_IDEA_CBC, cea['algorithm'])
+ param, rest = der_decoder(
+ cea['parameters'], asn1Spec=rfc3058.IDEA_CBCPar())
+
+ self.assertFalse(rest)
+ self.assertTrue(param.prettyPrint())
+ self.assertEqual(cea['parameters'], der_encoder(param))
+
+ iv = univ.OctetString(hexValue='424f4755535f4956')
+ self.assertEqual(iv, param['iv'])
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.env_data_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ kekri = asn1Object['content']['recipientInfos'][0]['kekri']
+ kwa = kekri['keyEncryptionAlgorithm']
+ self.assertEqual(rfc3058.id_alg_CMSIDEAwrap, kwa['algorithm'])
+ self.assertEqual(univ.Null(""), kwa['parameters'])
+
+ eci = asn1Object['content']['encryptedContentInfo']
+ cea = eci['contentEncryptionAlgorithm']
+ self.assertEqual(rfc3058.id_IDEA_CBC, cea['algorithm'])
+
+ iv = univ.OctetString(hexValue='424f4755535f4956')
+ self.assertEqual(iv, cea['parameters']['iv'])
+
+class SMIMECapabilitiesTestCase(unittest.TestCase):
+ smime_capabilities_pem_text = "MB4wDQYLKwYBBAGBPAcBAQIwDQYLKwYBBAGBPAcBAQY="
+
+ def setUp(self):
+ self.asn1Spec = rfc5751.SMIMECapabilities()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ alg_oid_list = [ ]
+ for cap in asn1Object:
+ self.assertFalse(cap['parameters'].hasValue())
+ alg_oid_list.append(cap['capabilityID'])
+
+ self.assertIn(rfc3058.id_IDEA_CBC, alg_oid_list)
+ self.assertIn(rfc3058.id_alg_CMSIDEAwrap, alg_oid_list)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3114.py b/tests/test_rfc3114.py
index 537fe9a..d0492a6 100644
--- a/tests/test_rfc3114.py
+++ b/tests/test_rfc3114.py
@@ -7,24 +7,19 @@
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc3114
from pyasn1_modules import rfc5035
from pyasn1_modules import rfc5083
-from pyasn1_modules import rfc5084
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc5755
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class SecurityLabelTestCase(unittest.TestCase):
pem_text = """\
@@ -152,10 +147,11 @@ uuDSOoaUIz+G9aemAE0ldpo1c0avNGa7BtynUTHmwosD6Sjfj0epAg9OnMedOjbr
next_layer = rfc5652.id_ct_contentInfo
while next_layer:
- asn1Object, rest = der_decode(substrate, asn1Spec=layers[next_layer])
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=layers[next_layer])
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
if next_layer == rfc5652.id_signedData:
attrs = asn1Object['signerInfos'][0]['signedAttrs']
@@ -168,68 +164,81 @@ uuDSOoaUIz+G9aemAE0ldpo1c0avNGa7BtynUTHmwosD6Sjfj0epAg9OnMedOjbr
catid = rfc3114.id_tsp_TEST_Whirlpool_Categories
conf = rfc3114.Whirlpool_SecurityClassification(value='whirlpool-confidential')
- assert catid in rfc5755.securityCategoryMap.keys()
- assert rfc5755.id_at_clearance in rfc5280.certificateAttributesMap.keys()
- assert rfc5280.id_ce_subjectDirectoryAttributes in rfc5280.certificateExtensionsMap.keys()
+ self.assertIn(catid, rfc5755.securityCategoryMap)
+ self.assertIn(rfc5755.id_at_clearance, rfc5280.certificateAttributesMap)
+ self.assertIn(rfc5280.id_ce_subjectDirectoryAttributes, rfc5280.certificateExtensionsMap)
security_label_okay = False
+
for attr in attrs:
if attr['attrType'] == rfc5035.id_aa_securityLabel:
- esssl, rest = der_decode(attr['attrValues'][0],
- asn1Spec=rfc5035.ESSSecurityLabel())
- assert not rest
- assert esssl.prettyPrint()
- assert der_encode(esssl) == attr['attrValues'][0]
+ esssl, rest = der_decoder(
+ attr['attrValues'][0], asn1Spec=rfc5035.ESSSecurityLabel())
+
+ self.assertFalse(rest)
+ self.assertTrue(esssl.prettyPrint())
+ self.assertEqual(attr['attrValues'][0], der_encoder(esssl))
- assert esssl['security-policy-identifier'] == spid
- assert esssl['security-classification'] == conf
+ self.assertEqual(spid, esssl['security-policy-identifier'])
+ self.assertEqual(conf, esssl['security-classification'])
for cat in esssl['security-categories']:
if cat['type'] == catid:
- scv, rest = der_decode(cat['value'],
- asn1Spec=rfc3114.SecurityCategoryValues())
- assert not rest
- assert scv.prettyPrint()
- assert der_encode(scv) == cat['value']
+ scv, rest = der_decoder(
+ cat['value'], asn1Spec=rfc3114.SecurityCategoryValues())
+
+ self.assertFalse(rest)
+ self.assertTrue(scv.prettyPrint())
+ self.assertEqual(cat['value'], der_encoder(scv))
+
for scv_str in scv:
- assert 'USE ONLY' in scv_str
+ self.assertIn('USE ONLY', scv_str)
security_label_okay = True
- assert security_label_okay
+ self.assertTrue(security_label_okay)
clearance_okay = False
for cert_choice in certs:
for extn in cert_choice['certificate']['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectDirectoryAttributes:
- ev, rest = der_decode(extn['extnValue'],
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
for attr in ev:
+
if attr['type'] == rfc5755.id_at_clearance:
- av, rest = der_decode(attr['values'][0],
+ av, rest = der_decoder(
+ attr['values'][0],
asn1Spec=rfc5280.certificateAttributesMap[attr['type']])
- assert av['policyId'] == spid
+
+ self.assertEqual(spid, av['policyId'])
+
for cat in av['securityCategories']:
- assert cat['type'] == catid
- scv, rest = der_decode(cat['value'],
+
+ self.assertEqual(catid, cat['type'])
+
+ scv, rest = der_decoder(
+ cat['value'],
asn1Spec=rfc5755.securityCategoryMap[cat['type']])
- assert not rest
- assert scv.prettyPrint()
- assert der_encode(scv) == cat['value']
+
+ self.assertFalse(rest)
+ self.assertTrue(scv.prettyPrint())
+ self.assertEqual(cat['value'], der_encoder(scv))
+
for scv_str in scv:
- assert 'USE ONLY' in scv_str
+ self.assertIn('USE ONLY', scv_str)
clearance_okay = True
- assert clearance_okay
+ self.assertTrue(clearance_okay)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3125.py b/tests/test_rfc3125.py
new file mode 100644
index 0000000..d7072b9
--- /dev/null
+++ b/tests/test_rfc3125.py
@@ -0,0 +1,109 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc2985
+from pyasn1_modules import rfc3125
+
+
+class SignaturePolicyTestCase(unittest.TestCase):
+ pem_text = """\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+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc3125.SignaturePolicy()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ svp = asn1Object['signPolicyInfo']['signatureValidationPolicy']
+ sr = svp['commonRules']['signerAndVeriferRules']['signerRules']
+ msa = sr['mandatedSignedAttr']
+
+ self.assertIn(rfc2985.pkcs_9_at_contentType, msa)
+ self.assertIn(rfc2985.pkcs_9_at_messageDigest, msa)
+ self.assertIn(rfc2985.pkcs_9_at_signingTime, msa)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ import sys
+
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3161.py b/tests/test_rfc3161.py
index 7068d5a..47db88a 100644
--- a/tests/test_rfc3161.py
+++ b/tests/test_rfc3161.py
@@ -5,20 +5,15 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc3161
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class TSPQueryTestCase(unittest.TestCase):
tsp_query_pem_text = """\
@@ -31,10 +26,11 @@ t1zOHCvK4A8i8zxwUXFHv4pAJZE+uFhZ+v53HTg9rLjO5Q==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.tsp_query_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
class TSPResponseTestCase(unittest.TestCase):
@@ -71,16 +67,15 @@ uuvuO3ZsRWuej+gso+nWi3CRnRc9Wb0++cq4s8YSLaYSj2pHMA==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.tsp_response_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3274.py b/tests/test_rfc3274.py
index a024b77..cb24d37 100644
--- a/tests/test_rfc3274.py
+++ b/tests/test_rfc3274.py
@@ -7,19 +7,15 @@
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc3274
from pyasn1_modules import rfc5652
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class CompressedDataTestCase(unittest.TestCase):
compressed_data_pem_text = """\
@@ -41,39 +37,45 @@ XQ7u2qbaKFtZ7V96NH8ApkUFkg==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.compressed_data_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc3274.id_ct_compressedData, asn1Object['contentType'])
- assert asn1Object['contentType'] == rfc3274.id_ct_compressedData
- cd, rest = der_decode(asn1Object['content'], asn1Spec=rfc3274.CompressedData())
- assert not rest
- assert cd.prettyPrint()
- assert der_encode(cd) == asn1Object['content']
+ cd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc3274.CompressedData())
- assert cd['compressionAlgorithm']['algorithm'] == rfc3274.id_alg_zlibCompress
- assert cd['encapContentInfo']['eContentType'] == rfc5652.id_data
+ self.assertFalse(rest)
+ self.assertTrue(cd.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(cd))
+
+ self.assertEqual(rfc3274.id_alg_zlibCompress,
+ cd['compressionAlgorithm']['algorithm'])
+ self.assertEqual(rfc5652.id_data, cd['encapContentInfo']['eContentType'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.compressed_data_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] == rfc3274.id_ct_compressedData
+ asn1Object, rest = der_decoder(substrate,
+ asn1Spec=self.asn1Spec,
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(
+ rfc3274.id_ct_compressedData, asn1Object['contentType'])
+
cd = asn1Object['content']
- assert cd['compressionAlgorithm']['algorithm'] == rfc3274.id_alg_zlibCompress
- assert cd['encapContentInfo']['eContentType'] == rfc5652.id_data
+
+ self.assertEqual(rfc3274.id_alg_zlibCompress,
+ cd['compressionAlgorithm']['algorithm'])
+ self.assertEqual(rfc5652.id_data, cd['encapContentInfo']['eContentType'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3279.py b/tests/test_rfc3279.py
index 28d5cce..210a2e9 100644
--- a/tests/test_rfc3279.py
+++ b/tests/test_rfc3279.py
@@ -7,20 +7,16 @@
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc3279
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
class RSACertificateTestCase(unittest.TestCase):
rsa_cert_pem_text = """\
@@ -58,36 +54,41 @@ M2jlVZ6qW8swC53HD79oRIGXi1FK
def testDerCodec(self):
substrate = pem.readBase64fromText(self.rsa_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc3279.rsaEncryption
+
+ self.assertEqual(rfc3279.rsaEncryption, spki_a['algorithm'])
spki_pk = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['subjectPublicKey'].asOctets()
- pk, rest = der_decode(spki_pk, asn1Spec=rfc3279.RSAPublicKey())
- assert not rest
- assert pk.prettyPrint()
- assert der_encode(pk) == spki_pk
- assert pk['publicExponent'] == 65537
+ pk, rest = der_decoder(spki_pk, asn1Spec=rfc3279.RSAPublicKey())
- assert asn1Object['tbsCertificate']['signature']['algorithm'] == rfc3279.sha1WithRSAEncryption
- assert asn1Object['signatureAlgorithm']['algorithm'] == rfc3279.sha1WithRSAEncryption
+ self.assertFalse(rest)
+ self.assertTrue(pk.prettyPrint())
+ self.assertEqual(spki_pk, der_encoder(pk))
+ self.assertEqual(65537, pk['publicExponent'])
+ self.assertEqual(rfc3279.sha1WithRSAEncryption,
+ asn1Object['tbsCertificate']['signature']['algorithm'])
+ self.assertEqual(rfc3279.sha1WithRSAEncryption,
+ asn1Object['signatureAlgorithm']['algorithm'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.rsa_cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc3279.rsaEncryption
- assert spki_a['parameters'] == univ.Null("")
+
+ self.assertEqual(rfc3279.rsaEncryption, spki_a['algorithm'])
+ self.assertEqual(univ.Null(""), spki_a['parameters'])
class ECCertificateTestCase(unittest.TestCase):
@@ -119,34 +120,38 @@ Ea8/B6hPatJ0ES8q/HO3X8IVQwVs1n3aAr0im0/T+Xc=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.ec_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc3279.id_ecPublicKey
- spki_a_p, rest = der_decode(spki_a['parameters'],
- asn1Spec=rfc3279.EcpkParameters())
- assert not rest
- assert spki_a_p.prettyPrint()
- assert der_encode(spki_a_p) == spki_a['parameters']
- assert spki_a_p['namedCurve'] == univ.ObjectIdentifier('1.3.132.0.34')
+ self.assertEqual(rfc3279.id_ecPublicKey, spki_a['algorithm'])
+
+ spki_a_p, rest = der_decoder(
+ spki_a['parameters'], asn1Spec=rfc3279.EcpkParameters())
+
+ self.assertFalse(rest)
+ self.assertTrue(spki_a_p.prettyPrint())
+ self.assertEqual(spki_a['parameters'], der_encoder(spki_a_p))
+ self.assertEqual(univ.ObjectIdentifier('1.3.132.0.34'), spki_a_p['namedCurve'])
def testOpenTypes(self):
- asn1Spec = rfc5280.Certificate()
substrate = pem.readBase64fromText(self.ec_cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc3279.id_ecPublicKey
- assert spki_a['parameters']['namedCurve'] == univ.ObjectIdentifier('1.3.132.0.34')
+
+ self.assertEqual(rfc3279.id_ecPublicKey, spki_a['algorithm'])
+ self.assertEqual(
+ univ.ObjectIdentifier('1.3.132.0.34'), spki_a['parameters']['namedCurve'])
class DSACertificateTestCase(unittest.TestCase):
@@ -178,43 +183,51 @@ pNqdXqZZGESXy1MT1aBc4ynPGLFUr2r7cPY=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.dsa_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc3279.id_dsa
- spki_a_p, rest = der_decode(spki_a['parameters'],
- asn1Spec=rfc3279.Dss_Parms())
- assert not rest
- assert spki_a_p.prettyPrint()
- assert der_encode(spki_a_p) == spki_a['parameters']
+ self.assertEqual(rfc3279.id_dsa, spki_a['algorithm'])
+
+ spki_a_p, rest = der_decoder(spki_a['parameters'],
+ asn1Spec=rfc3279.Dss_Parms())
+ self.assertFalse(rest)
+ self.assertTrue(spki_a_p.prettyPrint())
+ self.assertEqual(spki_a['parameters'], der_encoder(spki_a_p))
+
q_value = 1260916123897116834511257683105158021801897369967
- assert spki_a_p['q'] == q_value
- sig_value, rest = der_decode(asn1Object['signature'].asOctets(),
- asn1Spec=rfc3279.Dss_Sig_Value())
- assert not rest
- assert sig_value.prettyPrint()
- assert der_encode(sig_value) == asn1Object['signature'].asOctets()
- assert sig_value['r'].hasValue()
- assert sig_value['s'].hasValue()
+ self.assertEqual(q_value, spki_a_p['q'])
+
+ sig_value, rest = der_decoder(
+ asn1Object['signature'].asOctets(), asn1Spec=rfc3279.Dss_Sig_Value())
+
+ self.assertFalse(rest)
+ self.assertTrue(sig_value.prettyPrint())
+ self.assertEqual(asn1Object['signature'].asOctets(), der_encoder(sig_value))
+ self.assertTrue(sig_value['r'].hasValue())
+ self.assertTrue(sig_value['s'].hasValue())
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.dsa_cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc3279.id_dsa
+
+ self.assertEqual(rfc3279.id_dsa, spki_a['algorithm'])
+
q_value = 1260916123897116834511257683105158021801897369967
- assert spki_a['parameters']['q'] == q_value
+
+ self.assertEqual(q_value, spki_a['parameters']['q'])
class KEACertificateTestCase(unittest.TestCase):
@@ -239,49 +252,56 @@ TPnJ5Wym0hv2fOpnPPsWTgqvLFYfX27GGTquuOd/6A==
self.asn1Spec = rfc5280.Certificate()
def testDerCodec(self):
- asn1Spec = rfc5280.Certificate()
substrate = pem.readBase64fromText(self.kea_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc3279.id_keyExchangeAlgorithm
-
- spki_a_p, rest = der_decode(spki_a['parameters'],
- asn1Spec=rfc3279.KEA_Parms_Id())
- assert not rest
- assert spki_a_p.prettyPrint()
- assert der_encode(spki_a_p) == spki_a['parameters']
- assert spki_a_p == univ.OctetString(hexValue='5cf8f127e6569d6d88b3')
-
- assert asn1Object['tbsCertificate']['signature']['algorithm'] == rfc3279.id_dsa_with_sha1
- assert asn1Object['signatureAlgorithm']['algorithm'] == rfc3279.id_dsa_with_sha1
-
- sig_value, rest = der_decode(asn1Object['signature'].asOctets(),
- asn1Spec=rfc3279.Dss_Sig_Value())
- assert not rest
- assert sig_value.prettyPrint()
- assert der_encode(sig_value) == asn1Object['signature'].asOctets()
- assert sig_value['r'].hasValue()
- assert sig_value['s'].hasValue()
+
+ self.assertEqual(rfc3279.id_keyExchangeAlgorithm, spki_a['algorithm'])
+
+ spki_a_p, rest = der_decoder(spki_a['parameters'],
+ asn1Spec=rfc3279.KEA_Parms_Id())
+ self.assertFalse(rest)
+ self.assertTrue(spki_a_p.prettyPrint())
+
+ self.assertEqual(spki_a['parameters'], der_encoder(spki_a_p))
+ self.assertEqual(univ.OctetString(hexValue='5cf8f127e6569d6d88b3'), spki_a_p)
+ self.assertEqual(
+ rfc3279.id_dsa_with_sha1, asn1Object['tbsCertificate']['signature']['algorithm'])
+ self.assertEqual(
+ rfc3279.id_dsa_with_sha1, asn1Object['signatureAlgorithm']['algorithm'])
+
+ sig_value, rest = der_decoder(asn1Object['signature'].asOctets(),
+ asn1Spec=rfc3279.Dss_Sig_Value())
+ self.assertFalse(rest)
+ self.assertTrue(sig_value.prettyPrint())
+ self.assertEqual(asn1Object['signature'].asOctets(), der_encoder(sig_value))
+ self.assertTrue(sig_value['r'].hasValue())
+ self.assertTrue(sig_value['s'].hasValue())
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.kea_cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc3279.id_keyExchangeAlgorithm
- assert spki_a['parameters'] == univ.OctetString(hexValue='5cf8f127e6569d6d88b3')
- assert asn1Object['tbsCertificate']['signature']['algorithm'] == rfc3279.id_dsa_with_sha1
- assert asn1Object['signatureAlgorithm']['algorithm'] == rfc3279.id_dsa_with_sha1
+ self.assertEqual(rfc3279.id_keyExchangeAlgorithm, spki_a['algorithm'])
+ self.assertEqual(
+ univ.OctetString(hexValue='5cf8f127e6569d6d88b3'), spki_a['parameters'])
+
+ self.assertEqual(rfc3279.id_dsa_with_sha1,
+ asn1Object['tbsCertificate']['signature']['algorithm'])
+ self.assertEqual(
+ rfc3279.id_dsa_with_sha1, asn1Object['signatureAlgorithm']['algorithm'])
class DHCertificateTestCase(unittest.TestCase):
@@ -319,35 +339,44 @@ iPEBA+EDHjk=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.dh_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc3279.dhpublicnumber
- spki_a_p, rest = der_decode(spki_a['parameters'],
- asn1Spec=rfc3279.DomainParameters())
- assert not rest
- assert spki_a_p.prettyPrint()
- assert der_encode(spki_a_p) == spki_a['parameters']
+ self.assertEqual(rfc3279.dhpublicnumber, spki_a['algorithm'])
+
+ spki_a_p, rest = der_decoder(
+ spki_a['parameters'], asn1Spec=rfc3279.DomainParameters())
+
+ self.assertFalse(rest)
+ self.assertTrue(spki_a_p.prettyPrint())
+ self.assertEqual(spki_a['parameters'], der_encoder(spki_a_p))
+
q_value = 65838278260281264030127352144753816831178774189428428256716126077244217603537
- assert spki_a_p['q'] == q_value
+
+ self.assertEqual(q_value, spki_a_p['q'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.dh_cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate,
+ asn1Spec=self.asn1Spec,
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc3279.dhpublicnumber
+
+ self.assertEqual(rfc3279.dhpublicnumber, spki_a['algorithm'])
+
q_value = 65838278260281264030127352144753816831178774189428428256716126077244217603537
- assert spki_a['parameters']['q'] == q_value
+
+ self.assertEqual(q_value, spki_a['parameters']['q'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc3280.py b/tests/test_rfc3280.py
index 0a4dd02..3031335 100644
--- a/tests/test_rfc3280.py
+++ b/tests/test_rfc3280.py
@@ -7,19 +7,14 @@
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc3280
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class CertificateTestCase(unittest.TestCase):
pem_text = """\
@@ -46,10 +41,11 @@ PhmcGcwTTYJBtYze4D1gCCAPRX5ron+jjBXu
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
class CertificateListTestCase(unittest.TestCase):
@@ -69,16 +65,15 @@ vjnIhxTFoCb5vA==
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3281.py b/tests/test_rfc3281.py
index 915f791..f03316f 100644
--- a/tests/test_rfc3281.py
+++ b/tests/test_rfc3281.py
@@ -5,21 +5,15 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc3281
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class AttributeCertificateTestCase(unittest.TestCase):
pem_text = """\
@@ -47,12 +41,12 @@ Q4eikPk4LQey
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert asn1Object['acinfo']['version'] == 1
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(1, asn1Object['acinfo']['version'])
attributeMap = {
rfc3281.id_at_role: rfc3281.RoleSyntax(),
@@ -63,22 +57,24 @@ Q4eikPk4LQey
}
count = 0
+
for attr in asn1Object['acinfo']['attributes']:
- assert attr['type'] in attributeMap
- av, rest = der_decode(attr['values'][0],
- asn1Spec=attributeMap[attr['type']])
- assert not rest
- assert av.prettyPrint()
- assert der_encode(av) == attr['values'][0]
+ self.assertIn(attr['type'], attributeMap)
+
+ av, rest = der_decoder(
+ attr['values'][0], asn1Spec=attributeMap[attr['type']])
+
+ self.assertFalse(rest)
+ self.assertTrue(av.prettyPrint())
+ self.assertEqual(attr['values'][0], der_encoder(av))
+
count += 1
- assert count == 5
+ self.assertEqual(5, count)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3370.py b/tests/test_rfc3370.py
new file mode 100644
index 0000000..70d9d42
--- /dev/null
+++ b/tests/test_rfc3370.py
@@ -0,0 +1,234 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1.type import univ
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc3370
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5751
+
+
+class EnvelopedDataTestCase(unittest.TestCase):
+ env_data_pem_text = """\
+MIIFjAYJKoZIhvcNAQcDoIIFfTCCBXkCAQIxZqJkAgEEMCMEEH744tkBAA6gplAQ
+nKYxCF8YDzIwMTkwOTEyMTIwMDAwWjAQBgsqhkiG9w0BCRADBwIBOgQocOaZ+1cB
+94MzMPtx6HyFpCC9yZrwXSKvWg5I018xOJhsuq+0so1PNTCCBQoGCSqGSIb3DQEH
+ATAZBggqhkiG9w0DAjANAgE6BAhCT0dVU19JVoCCBOBzx7F6GMkP+C0Q4iuDq0rk
+SZprg8nuXx/4S3IMP999BrJdUAbPYxdQhAwTOZIuueyv00TJe/Eam9yyLuZXy0PF
+lTRi7KED8L8cyHsRoEobWGMLvE3D4hEhTGttElqQxBvMxZZgm6kLnNG7j8Z72L4l
+U4aARLYTQvktlJnnfCaccDSiWzU8eXcXdnZAzcKR7CoDc0/XBpdDRddvQ7KXoarX
+YHuSybt649YDcpy0SN9gEPqcFPrBB3nusAx4VOTlpx5Z3ZJv/TEymN8KDobNfykB
+ZURTwupO9WaVJZ3Hd/d8C1SCJn6DHuM1jwDp26WfzO8xCfea08MJrnQbNKsDHwmt
+4dFZIOvcOnwR8nNSB/Lt1aUj3GzluHVMyQQyT4AdZDmwFdNmQOBUBLmbWYhtd7t3
+O7Eqx8bGNa7V7LL0nvua04aj1oA6ph/G/8jxhByBYdN5Bwg7f1Ga3ZCwju2tFoQn
+WOCPYTVOjmBEJshBbNC7KhLpp9+C7/13A9cIC3T7Reuc7m+Fopf9Fabu97yFiyJP
+S8jSF0EnesNGR1L1Uvo2Wdc66iECoSrxvezaSgGKB2uLTnaFx4ASVMcP7gDipEOI
+wuUUuVCqgmWkHAK0Q9mwhBLLrYrsn9OjDHFpvkWgWNRMLl/v3E9A+grFh2BQHkB4
+C7keB1ZOfj1SqDi/+ylM9I1FOYMxVXJn2qHMl+QOkfdMoIATm3n3DiBI97/uX4x5
+KaX074v0dN31WeDcsFsh2ze5Dhx8vLJCaXLzWqkmNHX5G/CjjqE6bSR/awgWLRZQ
+uY/9fMvDpvVJuId/+OoWDtMVPIsyQ8w8yZzv+SkuZhsrJMHiKd5qxNQv5sOvC765
+LMUCNNwj7WzPhajintFXLAEMpIjk5xt3eIy3hdYla3PQoFfqcHOVX4EFMLBoYwBT
+gik8Fg669yXtMlbH84MGNs7jObhP/rrDkgbe0qmxUyzgm2uHya1VcItMGYoPPKMF
+U3ZfwAsZdqsi1GAtruTzSUmOpMfAoKOIAyZP96HrsrPCaoGrn7ysm5eRrHQ2hdwO
+7rGQIw0dRAFh2eyRomoLam7yEiw9M6uHuJ5hIS5yEW+7uUjQT6nvKlbrkIyLL5j9
+Gbk5Z4fOMqRTkBs+3H8x7a+lBEKBo/ByJm6fHYi+LX5ZhQFTWkY0M7tfPtrxQdsN
+RGSHtv7jS7PZ3thCMqCtkG/pjAsCbDUtMThtP08z2fstE6dfy7qSx6LzKLDyBl5W
+76mVYdsX7Q72yIoCDFmUGdrRcWA+l3OMwNNL+x9MhhdaUWPtxqaGyZMNGOjkbYHb
+XZ69oqYqCHkAstIVKTzpk3kq9C9x+ynzWO8kIGYNK2uxSBIzPLQ6Daq4c53rWFFN
+WVjPC8m98zMcYp0hbBhRsdk4qj8osSTcTfpT0+Q+hkYQvZl4IfgX1aHeaCDSScF8
+SaU+cZ7GYFvLo1cYrtVbeXrFwmWl0xpco1Ux+XZgryT/fgfJ+3ToppgsQmzECqTW
+mYsSYaF1kLU4Cqi9UH/VqBLOkwxoH05Zao2xOMNzu2QO3wFnvY2wBsIj1eaxfzVb
+42o9vom7V20jT1ufXXctf9ls5J1WJxBxdKmXQWdNloeAcl1AtxTbw7vIUU5uWqu9
+wwqly11MDVPAb0tcQW20auWmCNkXd52jQJ7PXR6kr5I=
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.env_data_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+
+ ed, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.EnvelopedData())
+ self.assertFalse(rest)
+ self.assertTrue(ed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ed))
+
+ kwa = ed['recipientInfos'][0]['kekri']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc3370.id_alg_CMSRC2wrap, kwa['algorithm'])
+ kwa_param, rest = der_decoder(
+ kwa['parameters'], rfc3370.RC2wrapParameter())
+ self.assertFalse(rest)
+ self.assertTrue(kwa_param.prettyPrint())
+ self.assertEqual(kwa['parameters'], der_encoder(kwa_param))
+ self.assertEqual(58, kwa_param)
+
+ cea = ed['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc3370.rc2CBC, cea['algorithm'])
+ param, rest = der_decoder(
+ cea['parameters'], rfc3370.RC2CBCParameter())
+ self.assertFalse(rest)
+ self.assertTrue(param.prettyPrint())
+ self.assertEqual(cea['parameters'], der_encoder(param))
+
+ iv = univ.OctetString(hexValue='424f4755535f4956')
+ self.assertEqual(iv, param['iv'])
+ self.assertEqual(58, param['rc2ParameterVersion'])
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.env_data_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertTrue(asn1Object['contentType'] in rfc5652.cmsContentTypesMap.keys())
+
+ ri0 = asn1Object['content']['recipientInfos'][0]
+ kwa = ri0['kekri']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc3370.id_alg_CMSRC2wrap, kwa['algorithm'])
+ self.assertEqual(58, kwa['parameters'])
+
+ eci = asn1Object['content']['encryptedContentInfo']
+ cea = eci['contentEncryptionAlgorithm']
+ self.assertEqual(rfc3370.rc2CBC, cea['algorithm'])
+
+ iv = univ.OctetString(hexValue='424f4755535f4956')
+ self.assertEqual(iv, cea['parameters']['iv'])
+ self.assertEqual(58, cea['parameters']['rc2ParameterVersion'])
+
+class DSAPublicKeyTestCase(unittest.TestCase):
+ dsa_cert_pem_text = """\
+MIIDpjCCA0ygAwIBAgIUY8xt3l0B9nIPWSpjs0hDJUJZmCkwCwYJYIZIAWUDBAMC
+MD8xCzAJBgNVBAYTAlVTMQswCQYDVQQIEwJWQTEQMA4GA1UEBxMHSGVybmRvbjER
+MA8GA1UEChMIQm9ndXMgQ0EwHhcNMTkxMDIwMjAxMjMwWhcNMjAxMDE5MjAxMjMw
+WjBwMQswCQYDVQQGEwJVUzELMAkGA1UECBMCVkExEDAOBgNVBAcTB0hlcm5kb24x
+EDAOBgNVBAoTB0V4YW1wbGUxDjAMBgNVBAsTBUFsaWNlMSAwHgYJKoZIhvcNAQkB
+FhFhbGljZUBleGFtcGxlLmNvbTCCAbYwggErBgcqhkjOOAQBMIIBHgKBgQCLpR53
+xHfe+SiknAK/L9lm/ZO1109c9iYkriPIW/5MMlM+qc/tdRkKpG6ELIpfXTPtKCJm
+zqqVIyTmAJryyE8Xw0Ie2mzYPU5ULvKmllQkjTsWgPGgQBkciZ0AW9ggD9VwZilg
+4qh3iSO7T97hVQFnpCh6vm8pOH6UP/5kpr9ZJQIVANzdbztBJlJfqCB1t4h/NvSu
+wCFvAoGAITP+jhYk9Rngd98l+5ccgauQ+cLEUBgNG2Wq56zBXQbLou6eKkQi7ecL
+NiRmExq3IU3LOj426wSxL72Kw6FPyOEv3edIFkJJEHL4Z+ZJeVe//dzya0ddOJ7k
+k6qNF2ic+viD/5Vm8yRyKiig2uHH/MgIesLdZnvbzvX+f/P0z50DgYQAAoGALAUl
+jkOi1PxjjFVvhGfK95yIsrfbfcIEKUBaTs9NR2rbGWUeP+93paoXwP39X9wrJx2M
+SWeHWhWKszNgoiyqYT0k4R9mem3WClotxOvB5fHfwIp2kQYvE7H0/TPdGhfUpHQG
+YpyLQgT6L80meSKMFnu4VXGzOANhWDxu3JxiADCjgZQwgZEwCwYDVR0PBAQDAgeA
+MEIGCWCGSAGG+EIBDQQ1FjNUaGlzIGNlcnRpZmljYXRlIGNhbm5vdCBiZSB0cnVz
+dGVkIGZvciBhbnkgcHVycG9zZS4wHQYDVR0OBBYEFO37wHcauyc03rDc6cDRRsHz
+gcK+MB8GA1UdIwQYMBaAFM1IZQGDsqYHWwb+I4EMxHPk0bU4MAsGCWCGSAFlAwQD
+AgNHADBEAiBBRbfMzLi7+SVyO8SM3xxwUsMf/k1B+Nkvf1kBTfCfGwIgSAx/6mI+
+pNqdXqZZGESXy1MT1aBc4ynPGLFUr2r7cPY=
+"""
+ def setUp(self):
+ self.asn1Spec = rfc5280.Certificate()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.dsa_cert_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ spki = asn1Object['tbsCertificate']['subjectPublicKeyInfo']
+ self.assertEqual(rfc3370.id_dsa, spki['algorithm']['algorithm'])
+ pk_substrate = spki['subjectPublicKey'].asOctets()
+
+ pk, rest = der_decoder(pk_substrate, asn1Spec=rfc3370.Dss_Pub_Key())
+ self.assertFalse(rest)
+ self.assertTrue(pk.prettyPrint())
+ self.assertEqual(pk_substrate, der_encoder(pk))
+
+ self.assertEqual(48, pk % 1024)
+
+class SMIMECapabilitiesTestCase(unittest.TestCase):
+ smime_capabilities_pem_text = """\
+MGIwDAYIKwYBBQUIAQIFADAfBgsqhkiG9w0BCRADBTAQBgsqhkiG9w0BCRADBwIB
+OjAfBgsqhkiG9w0BCRADCjAQBgsqhkiG9w0BCRADBwIBOjAQBgsqhkiG9w0BCRAD
+BwIBOg==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5751.SMIMECapabilities()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ found_wrap_alg_param = False
+ for cap in asn1Object:
+ if cap['capabilityID'] in rfc5751.smimeCapabilityMap.keys():
+ if cap['parameters'].hasValue():
+ param, rest = der_decoder(
+ cap['parameters'],
+ asn1Spec=rfc5751.smimeCapabilityMap[cap['capabilityID']])
+ self.assertFalse(rest)
+ self.assertTrue(param.prettyPrint())
+ self.assertEqual(cap['parameters'], der_encoder(param))
+
+ if cap['capabilityID'] == rfc3370.id_alg_ESDH:
+ kwa, rest = der_decoder(
+ cap['parameters'],
+ asn1Spec=rfc5751.smimeCapabilityMap[cap['capabilityID']])
+ self.assertFalse(rest)
+ self.assertTrue(kwa.prettyPrint())
+ self.assertEqual(cap['parameters'], der_encoder(kwa))
+
+ self.assertTrue(kwa['algorithm'] in rfc5280.algorithmIdentifierMap.keys())
+ self.assertEqual(rfc3370.id_alg_CMSRC2wrap, kwa['algorithm'])
+ kwa_p, rest = der_decoder(
+ kwa['parameters'],
+ asn1Spec=rfc5280.algorithmIdentifierMap[kwa['algorithm']])
+ self.assertFalse(rest)
+ self.assertTrue(kwa_p.prettyPrint())
+ self.assertEqual(kwa['parameters'], der_encoder(kwa_p))
+ self.assertEqual(58, kwa_p)
+ found_wrap_alg_param = True
+
+ self.assertTrue(found_wrap_alg_param)
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ found_wrap_alg_param = False
+ for cap in asn1Object:
+ if cap['capabilityID'] == rfc3370.id_alg_ESDH:
+ self.assertEqual(rfc3370.id_alg_CMSRC2wrap, cap['parameters']['algorithm'])
+ self.assertEqual(58, cap['parameters']['parameters'])
+ found_wrap_alg_param = True
+
+ self.assertTrue(found_wrap_alg_param)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
+
diff --git a/tests/test_rfc3447.py b/tests/test_rfc3447.py
index d4114c7..8788691 100644
--- a/tests/test_rfc3447.py
+++ b/tests/test_rfc3447.py
@@ -5,21 +5,15 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc3447
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
# openssl genrsa -primes 3 -f4 -out multiprime.key
@@ -58,16 +52,15 @@ EeEs9dusHakg1ERXAg4Vo1YowPW8kuVbZ9faxeVrmuER5NcCuZzS5X/obGUw
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3537.py b/tests/test_rfc3537.py
new file mode 100644
index 0000000..1b7490b
--- /dev/null
+++ b/tests/test_rfc3537.py
@@ -0,0 +1,76 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1.type import univ
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc3537
+from pyasn1_modules import rfc5751
+
+
+class SMIMECapabilitiesTestCase(unittest.TestCase):
+ smime_capabilities_pem_text = "MCIwDwYLKoZIhvcNAQkQAwwFADAPBgsqhkiG9w0BCRADCwUA"
+
+ def setUp(self):
+ self.asn1Spec = rfc5751.SMIMECapabilities()
+
+ def testDerCodec(self):
+ alg_oid_list = [
+ rfc3537.id_alg_HMACwithAESwrap,
+ rfc3537.id_alg_HMACwith3DESwrap,
+ ]
+
+ substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ count = 0
+ for cap in asn1Object:
+ self.assertEqual(der_encoder(univ.Null("")), cap['parameters'])
+ self.assertTrue(cap['capabilityID'] in alg_oid_list)
+ count += 1
+
+ self.assertEqual(count, 2)
+
+ def testOpenTypes(self):
+ openTypesMap = {
+ rfc3537.id_alg_HMACwithAESwrap: univ.Null(""),
+ rfc3537.id_alg_HMACwith3DESwrap: univ.Null(""),
+ }
+
+ asn1Spec=rfc5751.SMIMECapabilities()
+ substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec,
+ openTypes=openTypesMap, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ count = 0
+ for cap in asn1Object:
+ self.assertEqual(univ.Null(""), cap['parameters'])
+ self.assertTrue(cap['capabilityID'] in openTypesMap.keys())
+ count += 1
+
+ self.assertEqual(count, 2)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3560.py b/tests/test_rfc3560.py
index 112381a..3419cde 100644
--- a/tests/test_rfc3560.py
+++ b/tests/test_rfc3560.py
@@ -5,8 +5,8 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
@@ -15,11 +15,6 @@ from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc3560
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class OAEPDefautTestCase(unittest.TestCase):
oaep_default_pem_text = "MAsGCSqGSIb3DQEBBw=="
@@ -30,11 +25,10 @@ class OAEPDefautTestCase(unittest.TestCase):
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] == rfc3560.id_RSAES_OAEP
- assert der_encoder.encode(asn1Object) == substrate
- assert substrate == der_encoder.encode(asn1Object)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc3560.id_RSAES_OAEP, asn1Object[0])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
class OAEPSHA256TestCase(unittest.TestCase):
@@ -46,11 +40,10 @@ class OAEPSHA256TestCase(unittest.TestCase):
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] == rfc3560.id_RSAES_OAEP
- assert der_encoder.encode(asn1Object) == substrate
- assert substrate == der_encoder.encode(asn1Object)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc3560.id_RSAES_OAEP, asn1Object[0])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
class OAEPFullTestCase(unittest.TestCase):
@@ -62,17 +55,14 @@ class OAEPFullTestCase(unittest.TestCase):
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] == rfc3560.id_RSAES_OAEP
- assert der_encoder.encode(asn1Object) == substrate
- assert substrate == der_encoder.encode(asn1Object)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc3560.id_RSAES_OAEP, asn1Object[0])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3565.py b/tests/test_rfc3565.py
index f69e392..58574ec 100644
--- a/tests/test_rfc3565.py
+++ b/tests/test_rfc3565.py
@@ -5,22 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
-
from pyasn1.type import univ
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=="
@@ -31,10 +25,10 @@ class AESKeyWrapTestCase(unittest.TestCase):
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
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc3565.id_aes256_wrap, asn1Object[0])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
class AESCBCTestCase(unittest.TestCase):
@@ -46,23 +40,26 @@ class AESCBCTestCase(unittest.TestCase):
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
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc3565.id_aes256_CBC, asn1Object[0])
+ self.assertTrue(asn1Object[1].isValue)
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.aes_alg_id_pem_text)
asn1Object, rest = der_decoder.decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert asn1Object[0] == rfc3565.id_aes256_CBC
+ asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc3565.id_aes256_CBC, asn1Object[0])
+
aes_iv = univ.OctetString(hexValue='108996ba850e3f0339993bb5878a0e37')
- assert asn1Object[1] == aes_iv
- assert der_encoder.encode(asn1Object) == substrate
+
+ self.assertEqual(aes_iv, asn1Object[1])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc3657.py b/tests/test_rfc3657.py
new file mode 100644
index 0000000..12b49dc
--- /dev/null
+++ b/tests/test_rfc3657.py
@@ -0,0 +1,167 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc3657
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5751
+
+
+class EnvelopedDataTestCase(unittest.TestCase):
+ env_data_pem_text = """\
+MIIFfwYJKoZIhvcNAQcDoIIFcDCCBWwCAQIxU6JRAgEEMCMEECBlcTFnxBsPlsug
+4KOCj78YDzIwMTkwOTEyMTIwMDAwWjANBgsqgwiMmks9AQEDAgQYS3mK9jQmvth1
+iuBV8PEa89ICvmoomJCvMIIFEAYJKoZIhvcNAQcBMB8GCyqDCIyaSz0BAQECBBBC
+T0dVU0lWX0JPR1VTSVYhgIIE4HPHsXoYyQ/4LRDiK4OrSuRJmmuDye5fH/hLcgw/
+330Gsl1QBs9jF1CEDBM5ki657K/TRMl78Rqb3LIu5lfLQ8WVNGLsoQPwvxzIexGg
+ShtYYwu8TcPiESFMa20SWpDEG8zFlmCbqQuc0buPxnvYviVThoBEthNC+S2Umed8
+JpxwNKJbNTx5dxd2dkDNwpHsKgNzT9cGl0NF129Dspehqtdge5LJu3rj1gNynLRI
+32AQ+pwU+sEHee6wDHhU5OWnHlndkm/9MTKY3woOhs1/KQFlRFPC6k71ZpUlncd3
+93wLVIImfoMe4zWPAOnbpZ/M7zEJ95rTwwmudBs0qwMfCa3h0Vkg69w6fBHyc1IH
+8u3VpSPcbOW4dUzJBDJPgB1kObAV02ZA4FQEuZtZiG13u3c7sSrHxsY1rtXssvSe
++5rThqPWgDqmH8b/yPGEHIFh03kHCDt/UZrdkLCO7a0WhCdY4I9hNU6OYEQmyEFs
+0LsqEumn34Lv/XcD1wgLdPtF65zub4Wil/0Vpu73vIWLIk9LyNIXQSd6w0ZHUvVS
++jZZ1zrqIQKhKvG97NpKAYoHa4tOdoXHgBJUxw/uAOKkQ4jC5RS5UKqCZaQcArRD
+2bCEEsutiuyf06MMcWm+RaBY1EwuX+/cT0D6CsWHYFAeQHgLuR4HVk5+PVKoOL/7
+KUz0jUU5gzFVcmfaocyX5A6R90yggBObefcOIEj3v+5fjHkppfTvi/R03fVZ4Nyw
+WyHbN7kOHHy8skJpcvNaqSY0dfkb8KOOoTptJH9rCBYtFlC5j/18y8Om9Um4h3/4
+6hYO0xU8izJDzDzJnO/5KS5mGyskweIp3mrE1C/mw68LvrksxQI03CPtbM+FqOKe
+0VcsAQykiOTnG3d4jLeF1iVrc9CgV+pwc5VfgQUwsGhjAFOCKTwWDrr3Je0yVsfz
+gwY2zuM5uE/+usOSBt7SqbFTLOCba4fJrVVwi0wZig88owVTdl/ACxl2qyLUYC2u
+5PNJSY6kx8Cgo4gDJk/3oeuys8JqgaufvKybl5GsdDaF3A7usZAjDR1EAWHZ7JGi
+agtqbvISLD0zq4e4nmEhLnIRb7u5SNBPqe8qVuuQjIsvmP0ZuTlnh84ypFOQGz7c
+fzHtr6UEQoGj8HImbp8diL4tflmFAVNaRjQzu18+2vFB2w1EZIe2/uNLs9ne2EIy
+oK2Qb+mMCwJsNS0xOG0/TzPZ+y0Tp1/LupLHovMosPIGXlbvqZVh2xftDvbIigIM
+WZQZ2tFxYD6Xc4zA00v7H0yGF1pRY+3GpobJkw0Y6ORtgdtdnr2ipioIeQCy0hUp
+POmTeSr0L3H7KfNY7yQgZg0ra7FIEjM8tDoNqrhznetYUU1ZWM8Lyb3zMxxinSFs
+GFGx2TiqPyixJNxN+lPT5D6GRhC9mXgh+BfVod5oINJJwXxJpT5xnsZgW8ujVxiu
+1Vt5esXCZaXTGlyjVTH5dmCvJP9+B8n7dOimmCxCbMQKpNaZixJhoXWQtTgKqL1Q
+f9WoEs6TDGgfTllqjbE4w3O7ZA7fAWe9jbAGwiPV5rF/NVvjaj2+ibtXbSNPW59d
+dy1/2WzknVYnEHF0qZdBZ02Wh4ByXUC3FNvDu8hRTm5aq73DCqXLXUwNU8BvS1xB
+bbRq5aYI2Rd3naNAns9dHqSvkg==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.env_data_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+
+ ed, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.EnvelopedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(ed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ed))
+
+ kwa = ed['recipientInfos'][0]['kekri']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc3657.id_camellia128_wrap, kwa['algorithm'])
+
+ cea = ed['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc3657.id_camellia128_cbc, cea['algorithm'])
+ param, rest = der_decoder(
+ cea['parameters'], asn1Spec=rfc3657.Camellia_IV())
+
+ self.assertFalse(rest)
+ self.assertTrue(param.prettyPrint())
+ self.assertEqual(cea['parameters'], der_encoder(param))
+
+ iv = rfc3657.Camellia_IV(hexValue='424f47555349565f424f475553495621')
+ self.assertEqual(iv, param)
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.env_data_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertTrue(asn1Object['contentType'] in rfc5652.cmsContentTypesMap.keys())
+
+ kekri = asn1Object['content']['recipientInfos'][0]['kekri']
+ kwa = kekri['keyEncryptionAlgorithm']
+ self.assertEqual(rfc3657.id_camellia128_wrap, kwa['algorithm'])
+
+ eci = asn1Object['content']['encryptedContentInfo']
+ cea = eci['contentEncryptionAlgorithm']
+ self.assertEqual(rfc3657.id_camellia128_cbc, cea['algorithm'])
+
+ iv = rfc3657.Camellia_IV(hexValue='424f47555349565f424f475553495621')
+ self.assertEqual(iv, cea['parameters'])
+
+class SMIMECapabilitiesTestCase(unittest.TestCase):
+ smime_capabilities_pem_text = """\
+MGYwDwYLKoMIjJpLPQEBAQIFADAPBgsqgwiMmks9AQEBAwUAMA8GCyqDCIyaSz0B
+AQEEBQAwDwYLKoMIjJpLPQEBAwIFADAPBgsqgwiMmks9AQEDAwUAMA8GCyqDCIya
+Sz0BAQMEBQA=
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5751.SMIMECapabilities()
+
+ def testDerCodec(self):
+ alg_oid_list = [
+ rfc3657.id_camellia128_cbc,
+ rfc3657.id_camellia192_cbc,
+ rfc3657.id_camellia256_cbc,
+ rfc3657.id_camellia128_wrap,
+ rfc3657.id_camellia192_wrap,
+ rfc3657.id_camellia256_wrap,
+ ]
+
+ substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ param = der_encoder(rfc3657.CamelliaSMimeCapability(""))
+ count = 0
+ for cap in asn1Object:
+ self.assertEqual(cap['parameters'], param)
+ self.assertTrue(cap['capabilityID'] in alg_oid_list)
+ count += 1
+
+ self.assertEqual(count, 6)
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ param = rfc3657.CamelliaSMimeCapability("")
+ count = 0
+ for cap in asn1Object:
+ self.assertTrue(cap['capabilityID'] in rfc5751.smimeCapabilityMap.keys())
+ self.assertEqual(cap['parameters'], param)
+ count += 1
+
+ self.assertEqual(count, 6)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3709.py b/tests/test_rfc3709.py
index 8313129..dcab4b6 100644
--- a/tests/test_rfc3709.py
+++ b/tests/test_rfc3709.py
@@ -5,19 +5,15 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc3709
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class CertificateExtnWithUrlTestCase(unittest.TestCase):
pem_text = """\
@@ -44,39 +40,49 @@ Pj22pmfmQi5w21UljqoTj/+lQLkU3wfy5BdVKBwI0GfEA+YL3ctSzPNqAA==
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ extn_list = []
- extn_list = [ ]
for extn in asn1Object['tbsCertificate']['extensions']:
extn_list.append(extn['extnID'])
if extn['extnID'] == rfc3709.id_pe_logotype:
s = extn['extnValue']
- logotype, rest = der_decode(s, rfc3709.LogotypeExtn())
- assert not rest
- assert logotype.prettyPrint()
- assert der_encode(logotype) == s
+ logotype, rest = der_decoder(s, rfc3709.LogotypeExtn())
+
+ self.assertFalse(rest)
+ self.assertTrue(logotype.prettyPrint())
+ self.assertEqual(s, der_encoder(logotype))
+
ids = logotype['subjectLogo']['direct']['image'][0]['imageDetails']
- assert ids['mediaType'] == "image/png"
- assert ids['logotypeURI'][0] == "http://www.vigilsec.com/vigilsec_logo.png"
- assert rfc3709.id_pe_logotype in extn_list
+ self.assertEqual( "image/png", ids['mediaType'])
+
+ expected = "http://www.vigilsec.com/vigilsec_logo.png"
+ self.assertEqual(expected, ids['logotypeURI'][0])
+
+ self.assertIn(rfc3709.id_pe_logotype, extn_list)
def testExtensionsMap(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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] in rfc5280.certificateExtensionsMap.keys():
- extnValue, rest = der_decode(extn['extnValue'],
+ extnValue, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert der_encode(extnValue) == extn['extnValue']
+
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
class CertificateExtnWithDataTestCase(unittest.TestCase):
@@ -137,45 +143,52 @@ kbpmR6cDliloU808Bi/erMkrfUHRoZ2d586lkmwkLcoDkJ/yPD+Jhw==
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ extn_list = []
- extn_list = [ ]
for extn in asn1Object['tbsCertificate']['extensions']:
extn_list.append(extn['extnID'])
if extn['extnID'] == rfc3709.id_pe_logotype:
s = extn['extnValue']
- logotype, rest = der_decode(s, rfc3709.LogotypeExtn())
- assert not rest
- assert logotype.prettyPrint()
- assert der_encode(logotype) == s
+ logotype, rest = der_decoder(s, rfc3709.LogotypeExtn())
+ self.assertFalse(rest)
+
+ self.assertTrue(logotype.prettyPrint())
+ self.assertEqual(s, der_encoder(logotype))
+
ids = logotype['subjectLogo']['direct']['image'][0]['imageDetails']
- assert ids['mediaType'] == "image/svg+xml"
- assert ids['logotypeURI'][0][0:25] == "data:image/svg+xml;base64"
- assert rfc3709.id_pe_logotype in extn_list
+ self.assertEqual("image/svg+xml", ids['mediaType'])
+ self.assertEqual(
+ "data:image/svg+xml;base64", ids['logotypeURI'][0][0:25])
+
+ self.assertIn(rfc3709.id_pe_logotype, extn_list)
def testExtensionsMap(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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] in rfc5280.certificateExtensionsMap.keys():
- extnValue, rest = der_decode(extn['extnValue'],
+ extnValue, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert der_encode(extnValue) == extn['extnValue']
+
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3739.py b/tests/test_rfc3739.py
new file mode 100644
index 0000000..3c4ce3a
--- /dev/null
+++ b/tests/test_rfc3739.py
@@ -0,0 +1,126 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1.type import error
+from pyasn1.type import univ
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc3739
+
+
+class QCCertificateTestCase(unittest.TestCase):
+ pem_text = """\
+MIIFLTCCBBWgAwIBAgIMVRaIE9MInBkG6aUaMA0GCSqGSIb3DQEBCwUAMHMxCzAJ
+BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMRowGAYDVQQLExFG
+b3IgRGVtbyBVc2UgT25seTEtMCsGA1UEAxMkR2xvYmFsU2lnbiBEZW1vIElzc3Vp
+bmcgQ0EgLSBTdGFnaW5nMB4XDTE4MDYxNTA1MTgxNFoXDTE5MDYxNjA1MTgxNFow
+WjELMAkGA1UEBhMCQkUxGTAXBgNVBAMTEFRlc3QgQ2VydGlmaWNhdGUxEjAQBgNV
+BAUTCTEyMzQ1Njc4OTENMAsGA1UEKhMEVGVzdDENMAsGA1UEBBMEVGVzdDCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL/tsE2EIVQhpkZU5XmFR6FAq9ou
+k8FWbyku5M7S2JT3c6OFMQiVgu6nfqdsl4rzojhUXQtMOnO7sUqcIedmwqRIR/jd
+X+ELqGGRHodZt94Tjf6Qgn2Wv/EgG0EIwsOAisGKr4qTNs6ZmVMqQ3I4+l9Ik5eM
+whr9JfrhSxrXDzoh8Prc9lNjQbk+YKXw0zLmVxW7GAu9zTr98GF+HapIhNQbvqOc
+fHoY5svla5MqoRXagfrw/w2fSaO/LT+AFsZYODVpvCg/X3xsknoG7TDIeZ8Hmlgq
+Mvg9l9VA2JbSv1C38SeOm0Hfv0l0fspZPSrtmbYlvBtQoO1X/GhQXvE7UvMCAwEA
+AaOCAdgwggHUMA4GA1UdDwEB/wQEAwIGQDCBkQYIKwYBBQUHAQEEgYQwgYEwQQYI
+KwYBBQUHMAKGNWh0dHA6Ly9zZWN1cmUuc3RhZ2luZy5nbG9iYWxzaWduLmNvbS9n
+c2RlbW9zaGEyZzMuY3J0MDwGCCsGAQUFBzABhjBodHRwOi8vb2NzcDIuc3RhZ2lu
+Zy5nbG9iYWxzaWduLmNvbS9nc2RlbW9zaGEyZzMwWQYDVR0gBFIwUDBDBgsrBgEE
+AaAyASgjAjA0MDIGCCsGAQUFBwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNv
+bS9yZXBvc2l0b3J5LzAJBgcEAIvsQAECMAkGA1UdEwQCMAAwQwYDVR0fBDwwOjA4
+oDagNIYyaHR0cDovL2NybC5zdGFnaW5nLmdsb2JhbHNpZ24uY29tL2dzZGVtb3No
+YTJnMy5jcmwwLQYIKwYBBQUHAQMEITAfMAgGBgQAjkYBATATBgYEAI5GAQYwCQYH
+BACORgEGATAUBgNVHSUEDTALBgkqhkiG9y8BAQUwHQYDVR0OBBYEFNRFutzxY2Jg
+qilbYWe86em0QQC+MB8GA1UdIwQYMBaAFBcYifCc7R2iN5qLgGGRDT/RWZN6MA0G
+CSqGSIb3DQEBCwUAA4IBAQCMJeiaEAu45PetKSoPEnJ5t4MYr4dUl/HdnV13WEUW
+/34yHDGuubTFqJ6sM7P7dO25kdNOr75mR8yc0+gsGJv5K5C7LXfk36ofDlVQm0RJ
+3LTRhCvnJIzvuc5R52QW3MvB0EEPd1sfkpGgyTdK8zYZkwCXrWgMuPhBG/kgTiN0
+65qitL/WfkcX9SXmsYuV1a3Tsxz+6/rTtxdZfXSJgaVCOWHGyXCvpAQM/4eH5hSj
+UfTNwEMrE4sw4k9F90Sp8Wx24sMRDTIpnEXh3ceZSzBN2OYCIO84GaiZDpSvvkYN
+Iwtui+Wql/HveMqbAtXkiv9GDXYZms3HBoIaCVuDaUf6
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.Certificate()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ count = 0
+ for extn in asn1Object['tbsCertificate']['extensions']:
+ if extn['extnID'] == rfc3739.id_pe_qcStatements:
+ s = extn['extnValue']
+ qc_stmts, rest = der_decoder(s, rfc3739.QCStatements())
+ self.assertFalse(rest)
+ self.assertTrue(qc_stmts.prettyPrint())
+ self.assertEqual(s, der_encoder(qc_stmts))
+
+ for qcs in qc_stmts:
+ count += 1
+
+ self.assertEqual(2, count)
+
+ def testExtensionsMap(self):
+
+ class SequenceOfOID(univ.SequenceOf):
+ componentType = univ.ObjectIdentifier()
+
+ openTypesMap = {
+ univ.ObjectIdentifier('0.4.0.1862.1.6'): SequenceOfOID()
+ }
+
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ count = 0
+ found_qc_stmt_oid = False
+ for extn in asn1Object['tbsCertificate']['extensions']:
+ if extn['extnID'] == rfc3739.id_pe_qcStatements:
+ qc_stmts, rest = der_decoder(
+ extn['extnValue'],
+ asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']],
+ openTypes=openTypesMap,
+ decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(qc_stmts.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(qc_stmts))
+
+ for qcs in qc_stmts:
+ count += 1
+ if qcs['statementId'] in openTypesMap.keys():
+ for oid in qcs['statementInfo']:
+ if oid == univ.ObjectIdentifier('0.4.0.1862.1.6.1'):
+ found_qc_stmt_oid = True
+
+ self.assertEqual(2, count)
+ self.assertTrue(found_qc_stmt_oid)
+
+class WithComponentsTestCase(unittest.TestCase):
+
+ def testDerCodec(self):
+ si = rfc3739.SemanticsInformation()
+ self.assertRaises(error.PyAsn1Error, der_encoder, si)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3770.py b/tests/test_rfc3770.py
index df6e0dc..667ab24 100644
--- a/tests/test_rfc3770.py
+++ b/tests/test_rfc3770.py
@@ -5,12 +5,11 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.compat.octets import str2octs
from pyasn1_modules import pem
@@ -18,10 +17,6 @@ from pyasn1_modules import rfc5480
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc3770
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
class CertificateTestCase(unittest.TestCase):
cert_pem_text = """\
@@ -47,45 +42,51 @@ DAlVlhox680Jxy5J8Pkx
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
sig_alg = asn1Object['tbsCertificate']['signature']
- assert sig_alg['algorithm'] == rfc5480.ecdsa_with_SHA384
- assert not sig_alg['parameters'].hasValue()
+
+ self.assertEqual(rfc5480.ecdsa_with_SHA384, sig_alg['algorithm'])
+ self.assertFalse(sig_alg['parameters'].hasValue())
spki_alg = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_alg['algorithm'] == rfc5480.id_ecPublicKey
- assert spki_alg['parameters']['namedCurve'] == rfc5480.secp384r1
- extn_list = [ ]
+ self.assertEqual(rfc5480.id_ecPublicKey, spki_alg['algorithm'])
+ self.assertEqual(
+ rfc5480.secp384r1, spki_alg['parameters']['namedCurve'])
+
+ extn_list = []
for extn in asn1Object['tbsCertificate']['extensions']:
extn_list.append(extn['extnID'])
if extn['extnID'] in rfc5280.certificateExtensionsMap.keys():
- extnValue, rest = der_decode(extn['extnValue'],
+ extnValue, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert der_encode(extnValue) == extn['extnValue']
+
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
if extn['extnID'] == rfc3770.id_pe_wlanSSID:
- assert str2octs('Example') in extnValue
-
+ self.assertIn(str2octs('Example'), extnValue)
+
if extn['extnID'] == rfc5280.id_ce_extKeyUsage:
- assert rfc3770.id_kp_eapOverLAN in extnValue
- assert rfc3770.id_kp_eapOverPPP in extnValue
+ self.assertIn(rfc3770.id_kp_eapOverLAN, extnValue)
+ self.assertIn(rfc3770.id_kp_eapOverPPP, extnValue)
- assert rfc3770.id_pe_wlanSSID in extn_list
- assert rfc5280.id_ce_extKeyUsage in extn_list
+ self.assertIn(rfc3770.id_pe_wlanSSID, extn_list)
+ self.assertIn(rfc5280.id_ce_extKeyUsage, extn_list)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc3779.py b/tests/test_rfc3779.py
index af90376..652826e 100644
--- a/tests/test_rfc3779.py
+++ b/tests/test_rfc3779.py
@@ -5,6 +5,7 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
@@ -13,11 +14,6 @@ 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 = """\
@@ -54,52 +50,49 @@ V+vo2L72yerdbsP9xjqvhZrLKfsLZjYK4SdYYthi
asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
- extn_list = [ ]
+ extn_list = []
for extn in asn1Object['tbsCertificate']['extensions']:
extn_list.append(extn['extnID'])
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
+ self.assertFalse(rest)
+ self.assertTrue(addr_blocks.prettyPrint())
+ self.assertEqual(s, der_encoder.encode(addr_blocks))
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
-
- assert rfc3779.id_pe_ipAddrBlocks in extn_list
- assert rfc3779.id_pe_autonomousSysIds in extn_list
+ self.assertFalse(rest)
+ self.assertTrue(as_ids.prettyPrint())
+ self.assertEqual(s, der_encoder.encode(as_ids))
+ self.assertIn(rfc3779.id_pe_ipAddrBlocks, extn_list)
+ self.assertIn(rfc3779.id_pe_autonomousSysIds, extn_list)
def testExtensionsMap(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
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
for extn in asn1Object['tbsCertificate']['extensions']:
- if extn['extnID'] == rfc3779.id_pe_ipAddrBlocks or \
- extn['extnID'] == rfc3779.id_pe_autonomousSysIds:
-
- extnValue, rest = der_decoder.decode(extn['extnValue'],
+ if (extn['extnID'] == rfc3779.id_pe_ipAddrBlocks or
+ extn['extnID'] == rfc3779.id_pe_autonomousSysIds):
+ extnValue, rest = der_decoder.decode(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert der_encoder.encode(extnValue) == extn['extnValue']
+ self.assertEqual(extn['extnValue'], der_encoder.encode(extnValue))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3820.py b/tests/test_rfc3820.py
new file mode 100644
index 0000000..0895b28
--- /dev/null
+++ b/tests/test_rfc3820.py
@@ -0,0 +1,78 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+from pyasn1.type import univ
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc3820
+
+
+class ProxyCertificateTestCase(unittest.TestCase):
+ pem_text = """\
+MIID9DCCAtygAwIBAgIEDODd4TANBgkqhkiG9w0BAQUFADCBjTESMBAGCgmSJomT
+8ixkARkWAm5sMRcwFQYKCZImiZPyLGQBGRYHZS1pbmZyYTEaMBgGA1UEChMRVHJh
+aW5pbmcgU2VydmljZXMxDjAMBgNVBAsTBXVzZXJzMRowGAYDVQQLExFTZWN1cml0
+eSBUcmFpbmluZzEWMBQGA1UEAxMNUGlldGplIFB1ayA0MjAeFw0xOTExMjcwODMz
+NDZaFw0xOTExMjcyMDM4NDZaMIGhMRIwEAYKCZImiZPyLGQBGRYCbmwxFzAVBgoJ
+kiaJk/IsZAEZFgdlLWluZnJhMRowGAYDVQQKExFUcmFpbmluZyBTZXJ2aWNlczEO
+MAwGA1UECxMFdXNlcnMxGjAYBgNVBAsTEVNlY3VyaXR5IFRyYWluaW5nMRYwFAYD
+VQQDEw1QaWV0amUgUHVrIDQyMRIwEAYDVQQDEwkyMTYwNjM0NTcwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCu2b1j1XQXAgNazmTtdp6jjzvNQT8221/c
+dSIv2ftxr3UochHbazTfoR7wDT5PGlp2v99M0kZQvAEJ96CJpBDte4pwio7xHK3w
+s5h7lH3W2ydrxAMSnZp0NHxyo3DNenTV5HavGjraOZDLt/k1aPJ8C68CBbrGDQxH
+wzTs21Z+7lAy4C1ZNyOhkNF4qD5qy9Q2SHOPD+uc2QZE8IadZyxbeW/lEWHjESI1
+5y55oLZhe3leb2NswvppgdwM8KW4Pbtya6mDKGH4e1qQfNfxsqlxbIBr4UaM8iSM
+5BhJhe7VCny2iesGCJWz3NNoTJKBehN5o2xs7+fHv+sOW2Yuc3MnAgMBAAGjRjBE
+MBMGA1UdJQQMMAoGCCsGAQUFBwMCMA4GA1UdDwEB/wQEAwIEsDAdBggrBgEFBQcB
+DgEB/wQOMAwwCgYIKwYBBQUHFQEwDQYJKoZIhvcNAQEFBQADggEBAJbeKv3yQ9Yc
+GHT4r64gVkKd4do7+cRS9dfWg8pcLRn3aBzTCBIznkg+OpzjteOJCuw6AxDsDPmf
+n0Ms7LaAqegW8vcYgcZTxeABE5kgg5HTMUSMo39kFNTYHlNgsVfnOhpePnWX+e0Y
+gPpQU7w1npAhr23lXn9DNWgWMMT6T3z+NngcJ9NQdEee9D4rzY5Oo9W/2OAPuMne
+w5dGF7wVCUBRi6vrMnWYN8E3sHiFDJJrOsPWZzjRCa/W3N9A/OdgjitKQc3X4dlS
+tP2J7Yxv/B/6+VxVEa9WtVXsm/wJnhwvICBscB1/4WkI0PfJ7Nh4ZqQplPdlDEKe
+FOuri/fKBe0=
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.Certificate()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ found_ppl = False
+ for extn in asn1Object['tbsCertificate']['extensions']:
+ if extn['extnID'] == rfc3820.id_pe_proxyCertInfo:
+ self.assertTrue(rfc3820.id_pe_proxyCertInfo in rfc5280.certificateExtensionsMap.keys())
+ pci, rest = der_decoder(
+ extn['extnValue'],
+ asn1Spec=rfc5280.certificateExtensionsMap[rfc3820.id_pe_proxyCertInfo])
+ self.assertFalse(rest)
+ self.assertTrue(pci.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(pci))
+
+ self.assertEqual(rfc3820.id_ppl_inheritAll, pci['proxyPolicy']['policyLanguage'])
+ found_ppl = True
+
+ self.assertTrue(found_ppl)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc3852.py b/tests/test_rfc3852.py
index 94a618c..56b25cc 100644
--- a/tests/test_rfc3852.py
+++ b/tests/test_rfc3852.py
@@ -5,24 +5,17 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
from pyasn1_modules import rfc3852
from pyasn1_modules import rfc6402
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class ContentInfoTestCase(unittest.TestCase):
pem_text = """\
@@ -78,54 +71,58 @@ xicQmJP+VoMHo/ZpjFY9fYCjNZUArgKsEwK/s+p9yrVVeB1Nf8Mn
univ.ObjectIdentifier('1.2.840.113549.1.1.11'),
)
- encoded_null = der_encode(univ.Null(""))
+ encoded_null = der_encoder(univ.Null(""))
next_layer = rfc3852.id_ct_contentInfo
count = 0
+
while next_layer:
- asn1Object, rest = der_decode(substrate, asn1Spec=layers[next_layer])
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=layers[next_layer])
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
if next_layer == rfc3852.id_signedData:
- for d in asn1Object['digestAlgorithms']:
- assert d['algorithm'] in alg_oids
- assert d['parameters'] == encoded_null
- count += 1
+ for d in asn1Object['digestAlgorithms']:
+ self.assertIn(d['algorithm'], alg_oids)
+ self.assertEqual(encoded_null, d['parameters'])
+ count += 1
- for si in asn1Object['signerInfos']:
- assert si['digestAlgorithm']['algorithm'] in alg_oids
- assert si['digestAlgorithm']['parameters'] == encoded_null
- count += 1
+ for si in asn1Object['signerInfos']:
+ self.assertIn(si['digestAlgorithm']['algorithm'], alg_oids)
+ self.assertEqual(
+ encoded_null, si['digestAlgorithm']['parameters'])
+ count += 1
- assert si['signatureAlgorithm']['algorithm'] in alg_oids
- assert si['signatureAlgorithm']['parameters'] == encoded_null
- count += 1
+ self.assertIn(si['signatureAlgorithm']['algorithm'], alg_oids)
+ self.assertEqual(
+ encoded_null, si['signatureAlgorithm']['parameters'])
+ count += 1
if next_layer == rfc6402.id_cct_PKIData:
for req in asn1Object['reqSequence']:
cr = req['tcr']['certificationRequest']
- assert cr['signatureAlgorithm']['algorithm'] in alg_oids
- assert cr['signatureAlgorithm']['parameters'] == encoded_null
+ self.assertIn(cr['signatureAlgorithm']['algorithm'], alg_oids)
+ self.assertEqual(
+ encoded_null, cr['signatureAlgorithm']['parameters'])
count += 1
cri_spki = cr['certificationRequestInfo']['subjectPublicKeyInfo']
- assert cri_spki['algorithm']['algorithm'] in alg_oids
- assert cri_spki['algorithm']['parameters'] == encoded_null
+ self.assertIn(cri_spki['algorithm']['algorithm'], alg_oids)
+ self.assertEqual(
+ encoded_null, cri_spki['algorithm']['parameters'])
count += 1
substrate = getNextSubstrate[next_layer](asn1Object)
next_layer = getNextLayer[next_layer](asn1Object)
- assert count == 5
+ self.assertEqual(5, count)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4010.py b/tests/test_rfc4010.py
new file mode 100644
index 0000000..7474b9d
--- /dev/null
+++ b/tests/test_rfc4010.py
@@ -0,0 +1,136 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1.type import univ
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc4010
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5751
+
+
+class EnvelopedDataTestCase(unittest.TestCase):
+ env_data_pem_text = """\
+MIIFewYJKoZIhvcNAQcDoIIFbDCCBWgCAQIxUqJQAgEEMCMEEKBBI2KxDUPS5TCo
+RCEDJo4YDzIwMTkwOTEyMTIwMDAwWjAMBgoqgxqMmkQHAQEBBBipFE2DxCLAx2Og
+E53Jt21V8kAoscU7K3wwggUNBgkqhkiG9w0BBwEwHAYIKoMajJpEAQQEEEJPR1VT
+SVZfQk9HVVNJViGAggTgc8exehjJD/gtEOIrg6tK5Emaa4PJ7l8f+EtyDD/ffQay
+XVAGz2MXUIQMEzmSLrnsr9NEyXvxGpvcsi7mV8tDxZU0YuyhA/C/HMh7EaBKG1hj
+C7xNw+IRIUxrbRJakMQbzMWWYJupC5zRu4/Ge9i+JVOGgES2E0L5LZSZ53wmnHA0
+ols1PHl3F3Z2QM3CkewqA3NP1waXQ0XXb0Oyl6Gq12B7ksm7euPWA3KctEjfYBD6
+nBT6wQd57rAMeFTk5aceWd2Sb/0xMpjfCg6GzX8pAWVEU8LqTvVmlSWdx3f3fAtU
+giZ+gx7jNY8A6duln8zvMQn3mtPDCa50GzSrAx8JreHRWSDr3Dp8EfJzUgfy7dWl
+I9xs5bh1TMkEMk+AHWQ5sBXTZkDgVAS5m1mIbXe7dzuxKsfGxjWu1eyy9J77mtOG
+o9aAOqYfxv/I8YQcgWHTeQcIO39Rmt2QsI7trRaEJ1jgj2E1To5gRCbIQWzQuyoS
+6affgu/9dwPXCAt0+0XrnO5vhaKX/RWm7ve8hYsiT0vI0hdBJ3rDRkdS9VL6NlnX
+OuohAqEq8b3s2koBigdri052hceAElTHD+4A4qRDiMLlFLlQqoJlpBwCtEPZsIQS
+y62K7J/Towxxab5FoFjUTC5f79xPQPoKxYdgUB5AeAu5HgdWTn49Uqg4v/spTPSN
+RTmDMVVyZ9qhzJfkDpH3TKCAE5t59w4gSPe/7l+MeSml9O+L9HTd9Vng3LBbIds3
+uQ4cfLyyQmly81qpJjR1+Rvwo46hOm0kf2sIFi0WULmP/XzLw6b1SbiHf/jqFg7T
+FTyLMkPMPMmc7/kpLmYbKyTB4ineasTUL+bDrwu+uSzFAjTcI+1sz4Wo4p7RVywB
+DKSI5Ocbd3iMt4XWJWtz0KBX6nBzlV+BBTCwaGMAU4IpPBYOuvcl7TJWx/ODBjbO
+4zm4T/66w5IG3tKpsVMs4Jtrh8mtVXCLTBmKDzyjBVN2X8ALGXarItRgLa7k80lJ
+jqTHwKCjiAMmT/eh67KzwmqBq5+8rJuXkax0NoXcDu6xkCMNHUQBYdnskaJqC2pu
+8hIsPTOrh7ieYSEuchFvu7lI0E+p7ypW65CMiy+Y/Rm5OWeHzjKkU5AbPtx/Me2v
+pQRCgaPwciZunx2Ivi1+WYUBU1pGNDO7Xz7a8UHbDURkh7b+40uz2d7YQjKgrZBv
+6YwLAmw1LTE4bT9PM9n7LROnX8u6ksei8yiw8gZeVu+plWHbF+0O9siKAgxZlBna
+0XFgPpdzjMDTS/sfTIYXWlFj7camhsmTDRjo5G2B212evaKmKgh5ALLSFSk86ZN5
+KvQvcfsp81jvJCBmDStrsUgSMzy0Og2quHOd61hRTVlYzwvJvfMzHGKdIWwYUbHZ
+OKo/KLEk3E36U9PkPoZGEL2ZeCH4F9Wh3mgg0knBfEmlPnGexmBby6NXGK7VW3l6
+xcJlpdMaXKNVMfl2YK8k/34Hyft06KaYLEJsxAqk1pmLEmGhdZC1OAqovVB/1agS
+zpMMaB9OWWqNsTjDc7tkDt8BZ72NsAbCI9XmsX81W+NqPb6Ju1dtI09bn113LX/Z
+bOSdVicQcXSpl0FnTZaHgHJdQLcU28O7yFFOblqrvcMKpctdTA1TwG9LXEFttGrl
+pgjZF3edo0Cez10epK+S
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.env_data_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+
+ ed, rest = der_decoder(asn1Object['content'], rfc5652.EnvelopedData())
+ self.assertFalse(rest)
+ self.assertTrue(ed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ed))
+
+ kwa = ed['recipientInfos'][0]['kekri']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc4010.id_npki_app_cmsSeed_wrap, kwa['algorithm'])
+
+ cea = ed['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc4010.id_seedCBC, cea['algorithm'])
+ param, rest = der_decoder(
+ cea['parameters'], asn1Spec=rfc4010.SeedCBCParameter())
+ self.assertFalse(rest)
+ self.assertTrue(param.prettyPrint())
+ self.assertEqual(cea['parameters'], der_encoder(param))
+
+ iv = univ.OctetString(hexValue='424f47555349565f424f475553495621')
+ self.assertEqual(iv, param)
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.env_data_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertTrue(asn1Object['contentType'] in rfc5652.cmsContentTypesMap.keys())
+
+ kekri = asn1Object['content']['recipientInfos'][0]['kekri']
+ kwa = kekri['keyEncryptionAlgorithm']
+ self.assertEqual(rfc4010.id_npki_app_cmsSeed_wrap, kwa['algorithm'])
+
+ eci = asn1Object['content']['encryptedContentInfo']
+ cea = eci['contentEncryptionAlgorithm']
+ self.assertEqual(rfc4010.id_seedCBC, cea['algorithm'])
+
+ iv = univ.OctetString(hexValue='424f47555349565f424f475553495621')
+ self.assertEqual(iv, cea['parameters'])
+
+class SMIMECapabilitiesTestCase(unittest.TestCase):
+ smime_capabilities_pem_text = "MB4wDAYIKoMajJpEAQQFADAOBgoqgxqMmkQHAQEBBQA="
+
+ def setUp(self):
+ self.asn1Spec = rfc5751.SMIMECapabilities()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ alg_oid_list = [ ]
+ for cap in asn1Object:
+ self.assertTrue(cap['parameters'].hasValue())
+ self.assertEqual(cap['parameters'], der_encoder(rfc4010.SeedSMimeCapability("")))
+ alg_oid_list.append(cap['capabilityID'])
+
+ self.assertIn(rfc4010.id_seedCBC, alg_oid_list)
+ self.assertIn(rfc4010.id_npki_app_cmsSeed_wrap, alg_oid_list)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
+
diff --git a/tests/test_rfc4043.py b/tests/test_rfc4043.py
index 0637b87..0ab72dd 100644
--- a/tests/test_rfc4043.py
+++ b/tests/test_rfc4043.py
@@ -5,23 +5,17 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc4043
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class PermIdCertTestCase(unittest.TestCase):
cert_pem_text = """\
@@ -49,10 +43,11 @@ x0bpZq3PJaO0WlBgFicCMQCf+67wSvjxxtjI/OAg4t8NQIJW1LcehSXizlPDc772
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
perm_id_oid = rfc4043.id_on_permanentIdentifier
assigner_oid = univ.ObjectIdentifier('1.3.6.1.4.1.22112.48')
@@ -60,33 +55,37 @@ x0bpZq3PJaO0WlBgFicCMQCf+67wSvjxxtjI/OAg4t8NQIJW1LcehSXizlPDc772
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectAltName:
- extnValue, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.SubjectAltName())
- assert not rest
- assert extnValue.prettyPrint()
- assert der_encode(extnValue) == extn['extnValue']
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.SubjectAltName())
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
for gn in extnValue:
if gn['otherName'].hasValue():
- assert gn['otherName']['type-id'] == perm_id_oid
- onValue, rest = der_decode(gn['otherName']['value'],
+ self.assertEqual(perm_id_oid, gn['otherName']['type-id'])
+
+ onValue, rest = der_decoder(
+ gn['otherName']['value'],
asn1Spec=rfc4043.PermanentIdentifier())
- assert not rest
- assert onValue.prettyPrint()
- assert der_encode(onValue) == gn['otherName']['value']
- assert onValue['assigner'] == assigner_oid
+
+ self.assertFalse(rest)
+ self.assertTrue(onValue.prettyPrint())
+ self.assertEqual(gn['otherName']['value'], der_encoder(onValue))
+ self.assertEqual(assigner_oid, onValue['assigner'])
permanent_identifier_found = True
- assert permanent_identifier_found
+ self.assertTrue(permanent_identifier_found)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
perm_id_oid = rfc4043.id_on_permanentIdentifier
assigner_oid = univ.ObjectIdentifier('1.3.6.1.4.1.22112.48')
@@ -94,27 +93,26 @@ x0bpZq3PJaO0WlBgFicCMQCf+67wSvjxxtjI/OAg4t8NQIJW1LcehSXizlPDc772
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectAltName:
- extnValue, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.SubjectAltName(),
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.SubjectAltName(),
decodeOpenTypes=True)
- assert not rest
- assert extnValue.prettyPrint()
- assert der_encode(extnValue) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
for gn in extnValue:
if gn['otherName'].hasValue():
on = gn['otherName']
- assert on['type-id'] == perm_id_oid
- assert on['value']['assigner'] == assigner_oid
+ self.assertEqual(perm_id_oid, on['type-id'])
+ self.assertEqual(assigner_oid, on['value']['assigner'])
permanent_identifier_found = True
- assert permanent_identifier_found
+ self.assertTrue(permanent_identifier_found)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4055.py b/tests/test_rfc4055.py
index 3bb319a..cf0b376 100755
--- a/tests/test_rfc4055.py
+++ b/tests/test_rfc4055.py
@@ -5,23 +5,17 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
-
from pyasn1.type import univ
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=="
@@ -32,48 +26,52 @@ class PSSDefautTestCase(unittest.TestCase):
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)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertTrue(rfc4055.id_RSASSA_PSS, asn1Object[0])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pss_default_pem_text)
asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec,
decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
- assert not asn1Object['parameters'].hasValue()
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+ self.assertFalse(asn1Object['parameters'].hasValue())
class PSSSHA512TestCase(unittest.TestCase):
- pss_sha512_pem_text = "MDwGCSqGSIb3DQEBCjAvoA8wDQYJYIZIAWUDBAIDBQChHDAaBgkqhkiG9w0BAQgwDQYJYIZIAWUDBAIDBQA="
+ pss_sha512_pem_text = "MDwGCSqGSIb3DQEBCjAvoA8wDQYJYIZIAWUDBAIDBQChHDAaBg" \
+ "kqhkiG9w0BAQgwDQYJYIZIAWUDBAIDBQA="
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)
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertTrue(rfc4055.id_RSASSA_PSS, asn1Object[0])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pss_sha512_pem_text)
- asn1Object, rest = der_decoder.decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
- assert asn1Object['parameters'].hasValue()
- assert asn1Object['parameters']['saltLength'] == 20
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+ self.assertTrue(asn1Object['parameters'].hasValue())
+ self.assertTrue(20, asn1Object['parameters']['saltLength'])
class OAEPDefautTestCase(unittest.TestCase):
@@ -85,25 +83,26 @@ class OAEPDefautTestCase(unittest.TestCase):
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)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertTrue(rfc4055.id_RSAES_OAEP, asn1Object[0])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.oaep_default_pem_text)
- asn1Object, rest = der_decoder.decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
- assert not asn1Object['parameters'].hasValue()
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+ self.assertFalse(asn1Object['parameters'].hasValue())
class OAEPSHA256TestCase(unittest.TestCase):
- oaep_sha256_pem_text = "MDwGCSqGSIb3DQEBBzAvoA8wDQYJYIZIAWUDBAIBBQChHDAaBgkqhkiG9w0BAQgwDQYJYIZIAWUDBAIBBQA="
+ oaep_sha256_pem_text = "MDwGCSqGSIb3DQEBBzAvoA8wDQYJYIZIAWUDBAIBBQChHDAaB" \
+ "gkqhkiG9w0BAQgwDQYJYIZIAWUDBAIBBQA="
def setUp(self):
self.asn1Spec = rfc5280.AlgorithmIdentifier()
@@ -111,28 +110,33 @@ class OAEPSHA256TestCase(unittest.TestCase):
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)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertTrue(rfc4055.id_RSAES_OAEP, asn1Object[0])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.oaep_sha256_pem_text)
- asn1Object, rest = der_decoder.decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
- assert asn1Object['parameters'].hasValue()
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+ self.assertTrue(asn1Object['parameters'].hasValue())
+
oaep_p = asn1Object['parameters']
- assert oaep_p['hashFunc']['parameters'] == univ.Null("")
- assert oaep_p['maskGenFunc']['parameters']['parameters'] == univ.Null("")
+
+ self.assertEqual(univ.Null(""), oaep_p['hashFunc']['parameters'])
+ self.assertEqual(univ.Null(""), oaep_p['maskGenFunc']['parameters']['parameters'])
class OAEPFullTestCase(unittest.TestCase):
- oaep_full_pem_text = "MFMGCSqGSIb3DQEBBzBGoA8wDQYJYIZIAWUDBAICBQChHDAaBgkqhkiG9w0BAQgwDQYJYIZIAWUDBAICBQCiFTATBgkqhkiG9w0BAQkEBmZvb2Jhcg=="
+ oaep_full_pem_text = "MFMGCSqGSIb3DQEBBzBGoA8wDQYJYIZIAWUDBAICBQChHDAaBgk" \
+ "qhkiG9w0BAQgwDQYJYIZIAWUDBAICBQCiFTATBgkqhkiG9w0BAQ" \
+ "kEBmZvb2Jhcg=="
def setUp(self):
self.asn1Spec = rfc5280.AlgorithmIdentifier()
@@ -140,31 +144,38 @@ class OAEPFullTestCase(unittest.TestCase):
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)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+
+ self.assertTrue(rfc4055.id_RSAES_OAEP, asn1Object[0])
+
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.oaep_full_pem_text)
asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=self.asn1Spec,
decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
- assert asn1Object['parameters'].hasValue()
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+
+ self.assertTrue(asn1Object['parameters'].hasValue())
+
oaep_p = asn1Object['parameters']
- assert oaep_p['hashFunc']['parameters'] == univ.Null("")
- assert oaep_p['maskGenFunc']['parameters']['parameters'] == univ.Null("")
- assert oaep_p['pSourceFunc']['parameters'] == univ.OctetString(value='foobar')
+
+ self.assertEqual(univ.Null(""), oaep_p['hashFunc']['parameters'])
+ self.assertEqual(
+ univ.Null(""), oaep_p['maskGenFunc']['parameters']['parameters'])
+ self.assertEqual(
+ univ.OctetString(value='foobar'),
+ oaep_p['pSourceFunc']['parameters'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4073.py b/tests/test_rfc4073.py
index 576cc7b..4bd5e5f 100644
--- a/tests/test_rfc4073.py
+++ b/tests/test_rfc4073.py
@@ -5,12 +5,11 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.compat.octets import str2octs
from pyasn1_modules import pem
@@ -18,11 +17,6 @@ from pyasn1_modules import rfc2634
from pyasn1_modules import rfc4073
from pyasn1_modules import rfc5652
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class ContentCollectionTestCase(unittest.TestCase):
pem_text = """\
@@ -72,14 +66,14 @@ buWO3egPDL8Kf7tBhzjIKLw=
def testDerCodec(self):
def test_layer(substrate, content_type):
- asn1Object, rest = der_decode(substrate, asn1Spec=layers[content_type])
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=layers[content_type])
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
if content_type == rfc4073.id_ct_contentWithAttrs:
for attr in asn1Object['attrs']:
- assert attr['attrType'] in rfc5652.cmsAttributesMap.keys()
+ self.assertIn(attr['attrType'], rfc5652.cmsAttributesMap)
return asn1Object
@@ -102,6 +96,7 @@ buWO3egPDL8Kf7tBhzjIKLw=
substrate = pem.readBase64fromText(self.pem_text)
this_layer = rfc5652.id_ct_contentInfo
+
while this_layer != rfc5652.id_data:
if this_layer == rfc4073.id_ct_contentCollection:
asn1Object = test_layer(substrate, this_layer)
@@ -119,32 +114,33 @@ buWO3egPDL8Kf7tBhzjIKLw=
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=rfc5652.ContentInfo(),
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] == rfc4073.id_ct_contentCollection
+ asn1Object, rest = der_decoder(substrate,
+ asn1Spec=rfc5652.ContentInfo(),
+ decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(rfc4073.id_ct_contentCollection, asn1Object['contentType'])
+
for ci in asn1Object['content']:
- assert ci['contentType'] in rfc5652.cmsContentTypesMap.keys()
- assert ci['contentType'] == rfc4073.id_ct_contentWithAttrs
+ self.assertIn(ci['contentType'], rfc5652.cmsContentTypesMap)
+ self.assertEqual(rfc4073.id_ct_contentWithAttrs, ci['contentType'])
+
next_ci = ci['content']['content']
- assert next_ci['contentType'] in rfc5652.cmsContentTypesMap.keys()
- assert next_ci['contentType'] == rfc5652.id_data
- assert str2octs('Content-Type: text') in next_ci['content']
+
+ self.assertIn(next_ci['contentType'], rfc5652.cmsContentTypesMap)
+ self.assertEqual(rfc5652.id_data, next_ci['contentType'])
+ self.assertIn(str2octs('Content-Type: text'), next_ci['content'])
for attr in ci['content']['attrs']:
- assert attr['attrType'] in rfc5652.cmsAttributesMap.keys()
+ self.assertIn(attr['attrType'], rfc5652.cmsAttributesMap)
if attr['attrType'] == rfc2634.id_aa_contentHint:
- assert 'RFC 4073' in attr['attrValues'][0]['contentDescription']
+ self.assertIn('RFC 4073', attr['attrValues'][0]['contentDescription'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
- sys.exit(not result.wasSuccessful())
\ No newline at end of file
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4108.py b/tests/test_rfc4108.py
index 272558c..9d71601 100644
--- a/tests/test_rfc4108.py
+++ b/tests/test_rfc4108.py
@@ -5,21 +5,15 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-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.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
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 = """\
@@ -57,58 +51,63 @@ dsnhVtIdkPtfJIvcYteYJg==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
- assert asn1Object['contentType'] == rfc5652.id_signedData
- inner, rest = der_decode(asn1Object['content'], asn1Spec=rfc5652.SignedData())
+ inner, rest = der_decoder(asn1Object['content'], asn1Spec=rfc5652.SignedData())
- assert inner['encapContentInfo']['eContentType'] == rfc4108.id_ct_firmwarePackage
- assert inner['encapContentInfo']['eContent']
+ self.assertEqual(
+ rfc4108.id_ct_firmwarePackage, inner['encapContentInfo']['eContentType'])
+
+ self.assertTrue(inner['encapContentInfo']['eContent'])
+
+ attribute_list = []
- attribute_list = [ ]
for attr in inner['signerInfos'][0]['signedAttrs']:
attribute_list.append(attr['attrType'])
if attr['attrType'] == rfc4108.id_aa_targetHardwareIDs:
- av, rest = der_decode(attr['attrValues'][0],
- asn1Spec=rfc4108.TargetHardwareIdentifiers())
- assert len(av) == 2
+ av, rest = der_decoder(attr['attrValues'][0],
+ asn1Spec=rfc4108.TargetHardwareIdentifiers())
+ self.assertEqual(2, len(av))
+
for oid in av:
- assert '1.3.6.1.4.1.221121.1.1.' in oid.prettyPrint()
+ self.assertIn('1.3.6.1.4.1.221121.1.1.', oid.prettyPrint())
- assert rfc5652.id_contentType in attribute_list
- assert rfc5652.id_messageDigest in attribute_list
- assert rfc4108.id_aa_targetHardwareIDs in attribute_list
- assert rfc4108.id_aa_fwPkgMessageDigest in attribute_list
+ self.assertIn( rfc5652.id_contentType, attribute_list)
+ self.assertIn( rfc5652.id_messageDigest, attribute_list)
+ self.assertIn(rfc4108.id_aa_targetHardwareIDs, attribute_list)
+ self.assertIn(rfc4108.id_aa_fwPkgMessageDigest, attribute_list)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] == rfc5652.id_signedData
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(asn1Object['contentType'], rfc5652.id_signedData)
+
sd_eci = asn1Object['content']['encapContentInfo']
- assert sd_eci['eContentType'] == rfc4108.id_ct_firmwarePackage
- assert sd_eci['eContent'].hasValue()
+
+ self.assertEqual(sd_eci['eContentType'], rfc4108.id_ct_firmwarePackage)
+ self.assertTrue(sd_eci['eContent'].hasValue())
for attr in asn1Object['content']['signerInfos'][0]['signedAttrs']:
- assert attr['attrType'] in rfc5652.cmsAttributesMap.keys()
+ self.assertIn(attr['attrType'], rfc5652.cmsAttributesMap)
if attr['attrType'] == rfc4108.id_aa_targetHardwareIDs:
for oid in attr['attrValues'][0]:
- assert '1.3.6.1.4.1.221121.1.1.' in oid.prettyPrint()
+ self.assertIn('1.3.6.1.4.1.221121.1.1.', oid.prettyPrint())
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4210.py b/tests/test_rfc4210.py
index b3862e3..39d407f 100644
--- a/tests/test_rfc4210.py
+++ b/tests/test_rfc4210.py
@@ -1,10 +1,11 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
@@ -12,12 +13,6 @@ from pyasn1.codec.der import encoder as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc4210
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class PKIMessageTestCase(unittest.TestCase):
pem_text = """\
@@ -121,15 +116,13 @@ JA5RSwQoMDYTj2WrwtM/nsP12T39or4JRZhlLSM43IaTwEBtQw==
asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4211.py b/tests/test_rfc4211.py
index f96cdcf..e9be4cc 100644
--- a/tests/test_rfc4211.py
+++ b/tests/test_rfc4211.py
@@ -5,21 +5,15 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc4211
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class CertificateReqTestCase(unittest.TestCase):
pem_text = """\
@@ -39,23 +33,23 @@ xfu5YVWi81/fw8QQ6X6YGHFQkomLd7jxakVyjxSng9BhO6GpjJNF
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
count = 0
+
for crm in asn1Object:
- assert crm['certReq']['certTemplate']['version'] == 2
+ self.assertEqual(2, crm['certReq']['certTemplate']['version'])
count += 1
- assert count == 1
+ self.assertEqual(1, count)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4334.py b/tests/test_rfc4334.py
index ff4b252..9ba5fdf 100644
--- a/tests/test_rfc4334.py
+++ b/tests/test_rfc4334.py
@@ -5,22 +5,17 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.compat.octets import str2octs
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc4334
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
class CertificateTestCase(unittest.TestCase):
cert_pem_text = """\
@@ -46,37 +41,40 @@ DAlVlhox680Jxy5J8Pkx
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- extn_list = [ ]
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ extn_list = []
+
for extn in asn1Object['tbsCertificate']['extensions']:
extn_list.append(extn['extnID'])
if extn['extnID'] in rfc5280.certificateExtensionsMap.keys():
- extnValue, rest = der_decode(extn['extnValue'],
+ extnValue, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert der_encode(extnValue) == extn['extnValue']
+
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
if extn['extnID'] == rfc4334.id_pe_wlanSSID:
- assert str2octs('Example') in extnValue
+ self.assertIn( str2octs('Example'), extnValue)
if extn['extnID'] == rfc5280.id_ce_extKeyUsage:
- assert rfc4334.id_kp_eapOverLAN in extnValue
- assert rfc4334.id_kp_eapOverPPP in extnValue
+ self.assertIn(rfc4334.id_kp_eapOverLAN, extnValue)
+ self.assertIn(rfc4334.id_kp_eapOverPPP, extnValue)
- assert rfc4334.id_pe_wlanSSID in extn_list
- assert rfc5280.id_ce_extKeyUsage in extn_list
+ self.assertIn(rfc4334.id_pe_wlanSSID, extn_list)
+ self.assertIn(rfc5280.id_ce_extKeyUsage, extn_list)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc4357.py b/tests/test_rfc4357.py
new file mode 100644
index 0000000..cf10d59
--- /dev/null
+++ b/tests/test_rfc4357.py
@@ -0,0 +1,248 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+import unittest
+
+from pyasn1.type import univ
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc4357
+
+
+class SignedTestCase(unittest.TestCase):
+ signed_pem_text = """\
+MIIBKAYJKoZIhvcNAQcCoIIBGTCCARUCAQExDDAKBgYqhQMCAgkFADAbBgkqhkiG
+9w0BBwGgDgQMc2FtcGxlIHRleHQKMYHkMIHhAgEBMIGBMG0xHzAdBgNVBAMMFkdv
+c3RSMzQxMC0yMDAxIGV4YW1wbGUxEjAQBgNVBAoMCUNyeXB0b1BybzELMAkGA1UE
+BhMCUlUxKTAnBgkqhkiG9w0BCQEWGkdvc3RSMzQxMC0yMDAxQGV4YW1wbGUuY29t
+AhAr9cYewhG9F8fc1GJmtC4hMAoGBiqFAwICCQUAMAoGBiqFAwICEwUABEDAw0LZ
+P4/+JRERiHe/icPbg0IE1iD5aCqZ9v4wO+T0yPjVtNr74caRZzQfvKZ6DRJ7/RAl
+xlHbjbL0jHF+7XKp
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.signed_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
+ sd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.SignedData())
+ self.assertFalse(rest)
+ self.assertTrue(sd.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(sd))
+
+ encoded_null = der_encoder(univ.Null(""))
+
+ si = sd['signerInfos'][0]
+ self.assertEqual(rfc4357.id_GostR3411_94, si['digestAlgorithm']['algorithm'])
+ self.assertEqual(encoded_null, si['digestAlgorithm']['parameters'])
+
+ self.assertEqual(rfc4357.id_GostR3410_2001, si['signatureAlgorithm']['algorithm'])
+ self.assertEqual(encoded_null, si['signatureAlgorithm']['parameters'])
+ self.assertEqual(64, len(si['signature']))
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.signed_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
+ si = asn1Object['content']['signerInfos'][0]
+ self.assertEqual(rfc4357.id_GostR3411_94, si['digestAlgorithm']['algorithm'])
+ self.assertEqual(univ.Null(""), si['digestAlgorithm']['parameters'])
+
+ self.assertEqual(rfc4357.id_GostR3410_2001, si['signatureAlgorithm']['algorithm'])
+ self.assertEqual(univ.Null(""), si['signatureAlgorithm']['parameters'])
+
+ self.assertEqual(64, len(si['signature']))
+
+class KeyAgreeTestCase(unittest.TestCase):
+ keyagree_pem_text = """\
+MIIBpAYJKoZIhvcNAQcDoIIBlTCCAZECAQIxggFQoYIBTAIBA6BloWMwHAYGKoUD
+AgITMBIGByqFAwICJAAGByqFAwICHgEDQwAEQLNVOfRngZcrpcTZhB8n+4HtCDLm
+mtTyAHi4/4Nk6tIdsHg8ff4DwfQG5DvMFrnF9vYZNxwXuKCqx9GhlLOlNiChCgQI
+L/D20YZLMoowHgYGKoUDAgJgMBQGByqFAwICDQAwCQYHKoUDAgIfATCBszCBsDCB
+gTBtMR8wHQYDVQQDDBZHb3N0UjM0MTAtMjAwMSBleGFtcGxlMRIwEAYDVQQKDAlD
+cnlwdG9Qcm8xCzAJBgNVBAYTAlJVMSkwJwYJKoZIhvcNAQkBFhpHb3N0UjM0MTAt
+MjAwMUBleGFtcGxlLmNvbQIQK/XGHsIRvRfH3NRiZrQuIQQqMCgEIBajHOfOTukN
+8ex0aQRoHsefOu24Ox8dSn75pdnLGdXoBAST/YZ+MDgGCSqGSIb3DQEHATAdBgYq
+hQMCAhUwEwQItzXhegc1oh0GByqFAwICHwGADDmxivS/qeJlJbZVyQ==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.keyagree_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+
+ ed, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.EnvelopedData())
+ self.assertFalse(rest)
+ self.assertTrue(ed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ed))
+
+ ri = ed['recipientInfos'][0]
+ alg1 = ri['kari']['originator']['originatorKey']['algorithm']
+ self.assertEqual(rfc4357.id_GostR3410_2001, alg1['algorithm'])
+ param1, rest = der_decoder(
+ alg1['parameters'],
+ asn1Spec=rfc4357.GostR3410_2001_PublicKeyParameters())
+ self.assertFalse(rest)
+ self.assertTrue(param1.prettyPrint())
+ self.assertEqual(alg1['parameters'], der_encoder(param1))
+
+ self.assertEqual(rfc4357.id_GostR3410_2001_CryptoPro_XchA_ParamSet, param1['publicKeyParamSet'])
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, param1['digestParamSet'])
+
+ self.assertEqual(8, len(ri['kari']['ukm']))
+
+ alg2 = ed['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_Gost28147_89, alg2['algorithm'], )
+ param2, rest = der_decoder(
+ alg2['parameters'],
+ asn1Spec=rfc4357.Gost28147_89_Parameters())
+ self.assertFalse(rest)
+ self.assertTrue(param1.prettyPrint())
+ self.assertEqual(alg2['parameters'], der_encoder(param2))
+
+ self.assertEqual(8, len(param2['iv']))
+ self.assertEqual(rfc4357.id_Gost28147_89_CryptoPro_A_ParamSet, param2['encryptionParamSet'])
+
+ def testOpenTypes(self):
+ openTypeMap = {
+ rfc4357.id_GostR3410_2001: rfc4357.GostR3410_2001_PublicKeyParameters(),
+ rfc4357.id_Gost28147_89: rfc4357.Gost28147_89_Parameters(),
+ }
+
+ substrate = pem.readBase64fromText(self.keyagree_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec,
+ openTypes=openTypeMap, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+
+ ri = asn1Object['content']['recipientInfos'][0]
+ alg1 = ri['kari']['originator']['originatorKey']['algorithm']
+ self.assertEqual(rfc4357.id_GostR3410_2001, alg1['algorithm'])
+ param1 = alg1['parameters']
+ self.assertEqual(rfc4357.id_GostR3410_2001_CryptoPro_XchA_ParamSet, param1['publicKeyParamSet'])
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, param1['digestParamSet'])
+
+ self.assertEqual(8, len(ri['kari']['ukm']))
+
+ alg2 = asn1Object['content']['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_Gost28147_89, alg2['algorithm'])
+ param2 = alg2['parameters']
+ self.assertEqual(8, len(param2['iv']))
+ self.assertEqual(rfc4357.id_Gost28147_89_CryptoPro_A_ParamSet, param2['encryptionParamSet'])
+
+
+class KeyTransportTestCase(unittest.TestCase):
+ keytrans_pem_text = """\
+MIIBpwYJKoZIhvcNAQcDoIIBmDCCAZQCAQAxggFTMIIBTwIBADCBgTBtMR8wHQYD
+VQQDDBZHb3N0UjM0MTAtMjAwMSBleGFtcGxlMRIwEAYDVQQKDAlDcnlwdG9Qcm8x
+CzAJBgNVBAYTAlJVMSkwJwYJKoZIhvcNAQkBFhpHb3N0UjM0MTAtMjAwMUBleGFt
+cGxlLmNvbQIQK/XGHsIRvRfH3NRiZrQuITAcBgYqhQMCAhMwEgYHKoUDAgIkAAYH
+KoUDAgIeAQSBpzCBpDAoBCBqL6ghBpVon5/kR6qey2EVK35BYLxdjfv1PSgbGJr5
+dQQENm2Yt6B4BgcqhQMCAh8BoGMwHAYGKoUDAgITMBIGByqFAwICJAAGByqFAwIC
+HgEDQwAEQE0rLzOQ5tyj3VUqzd/g7/sx93N+Tv+/eImKK8PNMZQESw5gSJYf28dd
+Em/askCKd7W96vLsNMsjn5uL3Z4SwPYECJeV4ywrrSsMMDgGCSqGSIb3DQEHATAd
+BgYqhQMCAhUwEwQIvBCLHwv/NCkGByqFAwICHwGADKqOch3uT7Mu4w+hNw==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.keytrans_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+
+ ed, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.EnvelopedData())
+ self.assertFalse(rest)
+ self.assertTrue(ed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ed))
+
+ ri = ed['recipientInfos'][0]
+ alg1 = ri['ktri']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_GostR3410_2001, alg1['algorithm'])
+ param1, rest = der_decoder(
+ alg1['parameters'], asn1Spec=rfc4357.GostR3410_2001_PublicKeyParameters())
+ self.assertFalse(rest)
+ self.assertTrue(param1.prettyPrint())
+ self.assertEqual(alg1['parameters'], der_encoder(param1))
+ self.assertEqual(rfc4357.id_GostR3410_2001_CryptoPro_XchA_ParamSet, param1['publicKeyParamSet'])
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, param1['digestParamSet'])
+
+ alg2 = ed['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_Gost28147_89, alg2['algorithm'])
+ param2, rest = der_decoder(
+ alg2['parameters'], asn1Spec=rfc4357.Gost28147_89_Parameters())
+ self.assertFalse(rest)
+ self.assertTrue(param2.prettyPrint())
+ self.assertEqual(alg2['parameters'], der_encoder(param2))
+ self.assertEqual(8, len(param2['iv']))
+ self.assertEqual(rfc4357.id_Gost28147_89_CryptoPro_A_ParamSet, param2['encryptionParamSet'])
+
+ def testOpenTypes(self):
+ openTypeMap = {
+ rfc4357.id_GostR3410_2001: rfc4357.GostR3410_2001_PublicKeyParameters(),
+ rfc4357.id_Gost28147_89: rfc4357.Gost28147_89_Parameters(),
+ }
+
+ substrate = pem.readBase64fromText(self.keytrans_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec,
+ openTypes=openTypeMap, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ ri = asn1Object['content']['recipientInfos'][0]
+ alg1 = ri['ktri']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_GostR3410_2001, alg1['algorithm'])
+ param1 = alg1['parameters']
+ self.assertEqual(rfc4357.id_GostR3410_2001_CryptoPro_XchA_ParamSet, param1['publicKeyParamSet'])
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, param1['digestParamSet'])
+
+ alg2 = asn1Object['content']['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_Gost28147_89, alg2['algorithm'])
+ param2 = alg2['parameters']
+ self.assertEqual(8, len(param2['iv']))
+ self.assertEqual(rfc4357.id_Gost28147_89_CryptoPro_A_ParamSet, param2['encryptionParamSet'])
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4387.py b/tests/test_rfc4387.py
new file mode 100644
index 0000000..5c12225
--- /dev/null
+++ b/tests/test_rfc4387.py
@@ -0,0 +1,84 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc4387
+
+
+class CertificateTestCase(unittest.TestCase):
+ pem_text = """\
+MIIDLzCCArWgAwIBAgIJAKWzVCgbsG5JMAoGCCqGSM49BAMDMD8xCzAJBgNVBAYT
+AlVTMQswCQYDVQQIDAJWQTEQMA4GA1UEBwwHSGVybmRvbjERMA8GA1UECgwIQm9n
+dXMgQ0EwHhcNMTkxMTIyMDI1MzAzWhcNMjAxMTIxMDI1MzAzWjBZMQswCQYDVQQG
+EwJVUzELMAkGA1UECBMCVkExEDAOBgNVBAcTB0hlcm5kb24xEDAOBgNVBAoTB0V4
+YW1wbGUxGTAXBgNVBAMTEHJlcG8uZXhhbXBsZS5jb20wdjAQBgcqhkjOPQIBBgUr
+gQQAIgNiAAS/J1NNkqicN432Uwlw+Gu4pLvYpSr2W8zJvCOy61ncEzKNIs4cxqSc
+N0rl6K32tNCQGCsQFaBK4wZKXbHpUEPWrfYAWYebYDOhMlOE/agxH3nZRRnYv4O7
+pGrk/YZamGijggFhMIIBXTALBgNVHQ8EBAMCB4AwQgYJYIZIAYb4QgENBDUWM1Ro
+aXMgY2VydGlmaWNhdGUgY2Fubm90IGJlIHRydXN0ZWQgZm9yIGFueSBwdXJwb3Nl
+LjAdBgNVHQ4EFgQUWDRoN3XtN1n8ZH+bQuSAsr42gQwwHwYDVR0jBBgwFoAU8jXb
+NATapVXyvWkDmbBi7OIVCMEwgckGCCsGAQUFBwEBBIG8MIG5MCQGCCsGAQUFBzAB
+hhhodHRwOi8vb2NzcC5leGFtcGxlLmNvbS8wMgYIKwYBBQUHMAKGJmh0dHA6Ly9y
+ZXBvLmV4YW1wbGUuY29tL2NhaXNzdWVycy5odG1sMC4GCCsGAQUFBzAGhiJodHRw
+Oi8vcmVwby5leGFtcGxlLmNvbS9jZXJ0cy5odG1sMC0GCCsGAQUFBzAHhiFodHRw
+Oi8vcmVwby5leGFtcGxlLmNvbS9jcmxzLmh0bWwwCgYIKoZIzj0EAwMDaAAwZQIw
+C9Y1McQ+hSEZLtzLw1xzk3QSQX6NxalySoIIoNXpcDrGZJcjLRunBg8G9B0hqG69
+AjEAxtzj8BkMvhb5d9DTKDVg5pmjl9z7UtRK87/LJM+EW/9+PAzB2IT3T+BPHKb4
+kjBJ
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.Certificate()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ oid_list = [
+ rfc4387.id_ad_http_certs,
+ rfc4387.id_ad_http_crls,
+ ]
+
+ count = 0
+ for extn in asn1Object['tbsCertificate']['extensions']:
+ if extn['extnID'] == rfc5280.id_pe_authorityInfoAccess:
+ extnValue, rest = der_decoder(
+ extn['extnValue'],
+ asn1Spec=rfc5280.AuthorityInfoAccessSyntax())
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
+
+ for ad in extnValue:
+ if ad['accessMethod'] in oid_list:
+ uri = ad['accessLocation']['uniformResourceIdentifier']
+ self.assertIn('http://repo.example.com/c', uri)
+ count += 1
+
+ self.assertEqual(len(oid_list), count)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ import sys
+
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4476.py b/tests/test_rfc4476.py
new file mode 100644
index 0000000..b0a8fd3
--- /dev/null
+++ b/tests/test_rfc4476.py
@@ -0,0 +1,144 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1.type import univ
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5755
+from pyasn1_modules import rfc4476
+
+
+class AttributeCertificatePolicyTestCase(unittest.TestCase):
+ pem_text = """\
+MIID7zCCA1gCAQEwgY+gUTBKpEgwRjEjMCEGA1UEAwwaQUNNRSBJbnRlcm1lZGlh
+dGUgRUNEU0EgQ0ExCzAJBgNVBAYTAkZJMRIwEAYDVQQKDAlBQ01FIEx0ZC4CAx7N
+WqE6pDgwNjETMBEGA1UEAwwKQUNNRSBFQ0RTQTELMAkGA1UEBhMCRkkxEjAQBgNV
+BAoMCUFDTUUgTHRkLqBWMFSkUjBQMQswCQYDVQQGEwJVUzELMAkGA1UECAwCVkEx
+EDAOBgNVBAcMB0hlcm5kb24xIjAgBgNVBAoMGUJvZ3VzIEF0dHJpYnV0ZSBBdXRo
+b3RpdHkwDQYJKoZIhvcNAQELBQACBAu1MO4wIhgPMjAxOTEyMTUxMjAwMDBaGA8y
+MDE5MTIzMTEyMDAwMFowgfIwPAYIKwYBBQUHCgExMDAuhgt1cm46c2VydmljZaQV
+MBMxETAPBgNVBAMMCHVzZXJuYW1lBAhwYXNzd29yZDAyBggrBgEFBQcKAjEmMCSG
+C3VybjpzZXJ2aWNlpBUwEzERMA8GA1UEAwwIdXNlcm5hbWUwNQYIKwYBBQUHCgMx
+KTAnoBikFjAUMRIwEAYDVQQDDAlBQ01FIEx0ZC4wCwwJQUNNRSBMdGQuMCAGCCsG
+AQUFBwoEMRQwEjAQDAZncm91cDEMBmdyb3VwMjAlBgNVBEgxHjANoQuGCXVybjpy
+b2xlMTANoQuGCXVybjpyb2xlMjCCATkwHwYDVR0jBBgwFoAUgJCMhskAsEBzvklA
+X8yJBOXO500wCQYDVR04BAIFADA8BgNVHTcENTAzoAqGCHVybjp0ZXN0oBaCFEFD
+TUUtTHRkLmV4YW1wbGUuY29toA2GC3Vybjphbm90aGVyMIHMBggrBgEFBQcBDwSB
+vzCBvDCBuQYKKwYBBAGBrGAwCjCBqjBFBggrBgEFBQcCBBY5aHR0cHM6Ly93d3cu
+ZXhhbXBsZS5jb20vYXR0cmlidXRlLWNlcnRpZmljYXRlLXBvbGljeS5odG1sMGEG
+CCsGAQUFBwIFMFUwIwwZQm9ndXMgQXR0cmlidXRlIEF1dGhvcml0eTAGAgEKAgEU
+Gi5URVNUIGF0dHJpYnV0ZSBjZXJ0aWZpY2F0ZSBwb2xpY3kgZGlzcGxheSB0ZXh0
+MA0GCSqGSIb3DQEBCwUAA4GBACygfTs6TkPurZQTLufcE3B1H2707OXKsJlwRpuo
+dR2oJbunSHZ94jcJHs5dfbzFs6vNfVLlBiDBRieX4p+4JcQ2P44bkgyiUTJu7g1b
+6C1liB3vO6yH5hOZicOAaKd+c/myuGb9uFRoaXNfc2lnbmF0dXJlX2lzX2ludmFs
+aWQh
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5755.AttributeCertificate()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(1, asn1Object['acinfo']['version'])
+
+ found_ac_policy_qualifier1 = False
+ found_ac_policy_qualifier2 = False
+ for extn in asn1Object['acinfo']['extensions']:
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+ if extn['extnID'] == rfc4476.id_pe_acPolicies:
+ ev, rest = der_decoder(
+ extn['extnValue'],
+ asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
+
+ oid = univ.ObjectIdentifier((1, 3, 6, 1, 4, 1, 22112, 48, 10,))
+ self.assertEqual(oid, ev[0]['policyIdentifier'])
+
+ for pq in ev[0]['policyQualifiers']:
+ self.assertIn(
+ pq['policyQualifierId'], rfc5280.policyQualifierInfoMap)
+
+ pqv, rest = der_decoder(
+ pq['qualifier'],
+ asn1Spec=rfc5280.policyQualifierInfoMap[
+ pq['policyQualifierId']])
+
+ self.assertFalse(rest)
+ self.assertTrue(pqv.prettyPrint())
+ self.assertEqual(pq['qualifier'], der_encoder(pqv))
+
+ if pq['policyQualifierId'] == rfc4476.id_qt_acps:
+ self.assertIn('example.com', pqv)
+ found_ac_policy_qualifier1 = True
+
+ if pq['policyQualifierId'] == rfc4476.id_qt_acunotice:
+ self.assertIn(20, pqv[0]['noticeNumbers'])
+ found_ac_policy_qualifier2 = True
+
+ assert found_ac_policy_qualifier1
+ assert found_ac_policy_qualifier2
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(1, asn1Object['acinfo']['version'])
+
+ found_ac_policy_qualifier1 = False
+ found_ac_policy_qualifier2 = False
+ for extn in asn1Object['acinfo']['extensions']:
+ if extn['extnID'] == rfc4476.id_pe_acPolicies:
+ ev, rest = der_decoder(
+ extn['extnValue'],
+ asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']],
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
+
+ oid = univ.ObjectIdentifier((1, 3, 6, 1, 4, 1, 22112, 48, 10,))
+ self.assertEqual(oid, ev[0]['policyIdentifier'])
+
+ for pq in ev[0]['policyQualifiers']:
+
+ if pq['policyQualifierId'] == rfc4476.id_qt_acps:
+ self.assertIn('example.com', pq['qualifier'])
+ found_ac_policy_qualifier1 = True
+
+ if pq['policyQualifierId'] == rfc4476.id_qt_acunotice:
+ self.assertIn(20, pq['qualifier'][0]['noticeNumbers'])
+ found_ac_policy_qualifier2 = True
+
+ assert found_ac_policy_qualifier1
+ assert found_ac_policy_qualifier2
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4490.py b/tests/test_rfc4490.py
new file mode 100644
index 0000000..5c3b8cf
--- /dev/null
+++ b/tests/test_rfc4490.py
@@ -0,0 +1,274 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+import unittest
+
+from pyasn1.type import univ
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc4357
+from pyasn1_modules import rfc4490
+
+
+class SignedTestCase(unittest.TestCase):
+ signed_pem_text = """\
+MIIBKAYJKoZIhvcNAQcCoIIBGTCCARUCAQExDDAKBgYqhQMCAgkFADAbBgkqhkiG
+9w0BBwGgDgQMc2FtcGxlIHRleHQKMYHkMIHhAgEBMIGBMG0xHzAdBgNVBAMMFkdv
+c3RSMzQxMC0yMDAxIGV4YW1wbGUxEjAQBgNVBAoMCUNyeXB0b1BybzELMAkGA1UE
+BhMCUlUxKTAnBgkqhkiG9w0BCQEWGkdvc3RSMzQxMC0yMDAxQGV4YW1wbGUuY29t
+AhAr9cYewhG9F8fc1GJmtC4hMAoGBiqFAwICCQUAMAoGBiqFAwICEwUABEDAw0LZ
+P4/+JRERiHe/icPbg0IE1iD5aCqZ9v4wO+T0yPjVtNr74caRZzQfvKZ6DRJ7/RAl
+xlHbjbL0jHF+7XKp
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.signed_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
+ sd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.SignedData())
+ self.assertFalse(rest)
+ self.assertTrue(sd.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(sd))
+
+ encoded_null = der_encoder(univ.Null(""))
+
+ si = sd['signerInfos'][0]
+ self.assertEqual(rfc4357.id_GostR3411_94, si['digestAlgorithm']['algorithm'])
+ self.assertEqual(encoded_null, si['digestAlgorithm']['parameters'])
+
+ self.assertEqual(rfc4357.id_GostR3410_2001, si['signatureAlgorithm']['algorithm'])
+ self.assertEqual(encoded_null, si['signatureAlgorithm']['parameters'])
+
+ sig = rfc4490.GostR3410_2001_Signature()
+ sig = si['signature']
+ self.assertEqual(64, len(sig))
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.signed_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
+ si = asn1Object['content']['signerInfos'][0]
+ self.assertEqual(rfc4357.id_GostR3411_94, si['digestAlgorithm']['algorithm'])
+ self.assertEqual(univ.Null(""), si['digestAlgorithm']['parameters'])
+
+ self.assertEqual(rfc4357.id_GostR3410_2001, si['signatureAlgorithm']['algorithm'])
+ self.assertEqual(univ.Null(""), si['signatureAlgorithm']['parameters'])
+
+ sig = rfc4490.GostR3410_2001_Signature()
+ sig = si['signature']
+ self.assertEqual(64, len(sig))
+
+class KeyAgreeTestCase(unittest.TestCase):
+ keyagree_pem_text = """\
+MIIBpAYJKoZIhvcNAQcDoIIBlTCCAZECAQIxggFQoYIBTAIBA6BloWMwHAYGKoUD
+AgITMBIGByqFAwICJAAGByqFAwICHgEDQwAEQLNVOfRngZcrpcTZhB8n+4HtCDLm
+mtTyAHi4/4Nk6tIdsHg8ff4DwfQG5DvMFrnF9vYZNxwXuKCqx9GhlLOlNiChCgQI
+L/D20YZLMoowHgYGKoUDAgJgMBQGByqFAwICDQAwCQYHKoUDAgIfATCBszCBsDCB
+gTBtMR8wHQYDVQQDDBZHb3N0UjM0MTAtMjAwMSBleGFtcGxlMRIwEAYDVQQKDAlD
+cnlwdG9Qcm8xCzAJBgNVBAYTAlJVMSkwJwYJKoZIhvcNAQkBFhpHb3N0UjM0MTAt
+MjAwMUBleGFtcGxlLmNvbQIQK/XGHsIRvRfH3NRiZrQuIQQqMCgEIBajHOfOTukN
+8ex0aQRoHsefOu24Ox8dSn75pdnLGdXoBAST/YZ+MDgGCSqGSIb3DQEHATAdBgYq
+hQMCAhUwEwQItzXhegc1oh0GByqFAwICHwGADDmxivS/qeJlJbZVyQ==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.keyagree_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+
+ ed, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.EnvelopedData())
+ self.assertFalse(rest)
+ self.assertTrue(ed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ed))
+
+ ri = ed['recipientInfos'][0]
+ alg1 = ri['kari']['originator']['originatorKey']['algorithm']
+ self.assertEqual(rfc4357.id_GostR3410_2001, alg1['algorithm'])
+ param1, rest = der_decoder(
+ alg1['parameters'],
+ asn1Spec=rfc4357.GostR3410_2001_PublicKeyParameters())
+ self.assertFalse(rest)
+ self.assertTrue(param1.prettyPrint())
+ self.assertEqual(alg1['parameters'], der_encoder(param1))
+
+ self.assertEqual(rfc4357.id_GostR3410_2001_CryptoPro_XchA_ParamSet, param1['publicKeyParamSet'])
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, param1['digestParamSet'])
+
+ self.assertEqual(8, len(ri['kari']['ukm']))
+
+ alg2 = ri['kari']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc4490.id_GostR3410_2001_CryptoPro_ESDH, alg2['algorithm'])
+ param2, rest = der_decoder(
+ alg2['parameters'], asn1Spec=rfc4357.AlgorithmIdentifier())
+ self.assertFalse(rest)
+ self.assertTrue(param2.prettyPrint())
+ self.assertEqual(alg2['parameters'], der_encoder(param2))
+
+ self.assertEqual(rfc4490.id_Gost28147_89_None_KeyWrap, param2['algorithm'])
+ kwa_p, rest = der_decoder(
+ param2['parameters'], asn1Spec=rfc4490.Gost28147_89_KeyWrapParameters())
+ self.assertFalse(rest)
+ self.assertTrue(kwa_p.prettyPrint())
+ self.assertEqual(param2['parameters'], der_encoder(kwa_p))
+ self.assertEqual(rfc4357.id_Gost28147_89_CryptoPro_A_ParamSet, kwa_p['encryptionParamSet'])
+
+ alg3 = ed['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_Gost28147_89, alg3['algorithm'])
+ param3, rest = der_decoder(alg3['parameters'], asn1Spec=rfc4357.Gost28147_89_Parameters())
+ self.assertFalse(rest)
+ self.assertTrue(param3.prettyPrint())
+ self.assertEqual(alg3['parameters'], der_encoder(param3))
+ self.assertEqual(8, len(param3['iv']))
+ self.assertEqual(rfc4357.id_Gost28147_89_CryptoPro_A_ParamSet, param3['encryptionParamSet'])
+
+ def testOpenTypes(self):
+ openTypeMap = {
+ rfc4357.id_GostR3410_2001: rfc4357.GostR3410_2001_PublicKeyParameters(),
+ rfc4357.id_Gost28147_89: rfc4357.Gost28147_89_Parameters(),
+ rfc4490.id_GostR3410_2001_CryptoPro_ESDH: rfc5280.AlgorithmIdentifier(),
+ }
+
+ substrate = pem.readBase64fromText(self.keyagree_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec,
+ openTypes=openTypeMap, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+
+ ri = asn1Object['content']['recipientInfos'][0]
+ alg1 = ri['kari']['originator']['originatorKey']['algorithm']
+ self.assertEqual(rfc4357.id_GostR3410_2001, alg1['algorithm'])
+ param1 = alg1['parameters']
+ self.assertEqual(rfc4357.id_GostR3410_2001_CryptoPro_XchA_ParamSet, param1['publicKeyParamSet'])
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, param1['digestParamSet'])
+
+ self.assertEqual(8, len(ri['kari']['ukm']))
+
+ alg2 = ri['kari']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc4490.id_GostR3410_2001_CryptoPro_ESDH, alg2['algorithm'])
+ param2 = alg2['parameters']
+ self.assertEqual(rfc4490.id_Gost28147_89_None_KeyWrap, param2['algorithm'])
+ kwa_p = param2['parameters']
+ self.assertEqual(rfc4357.id_Gost28147_89_CryptoPro_A_ParamSet, kwa_p['encryptionParamSet'])
+
+ alg3 = asn1Object['content']['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_Gost28147_89, alg3['algorithm'])
+ param3 = alg3['parameters']
+ self.assertEqual(8, len(param3['iv']))
+ self.assertEqual(rfc4357.id_Gost28147_89_CryptoPro_A_ParamSet, param3['encryptionParamSet'])
+
+class KeyTransportTestCase(unittest.TestCase):
+ keytrans_pem_text = """\
+MIIBpwYJKoZIhvcNAQcDoIIBmDCCAZQCAQAxggFTMIIBTwIBADCBgTBtMR8wHQYD
+VQQDDBZHb3N0UjM0MTAtMjAwMSBleGFtcGxlMRIwEAYDVQQKDAlDcnlwdG9Qcm8x
+CzAJBgNVBAYTAlJVMSkwJwYJKoZIhvcNAQkBFhpHb3N0UjM0MTAtMjAwMUBleGFt
+cGxlLmNvbQIQK/XGHsIRvRfH3NRiZrQuITAcBgYqhQMCAhMwEgYHKoUDAgIkAAYH
+KoUDAgIeAQSBpzCBpDAoBCBqL6ghBpVon5/kR6qey2EVK35BYLxdjfv1PSgbGJr5
+dQQENm2Yt6B4BgcqhQMCAh8BoGMwHAYGKoUDAgITMBIGByqFAwICJAAGByqFAwIC
+HgEDQwAEQE0rLzOQ5tyj3VUqzd/g7/sx93N+Tv+/eImKK8PNMZQESw5gSJYf28dd
+Em/askCKd7W96vLsNMsjn5uL3Z4SwPYECJeV4ywrrSsMMDgGCSqGSIb3DQEHATAd
+BgYqhQMCAhUwEwQIvBCLHwv/NCkGByqFAwICHwGADKqOch3uT7Mu4w+hNw==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.keytrans_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+
+ ed, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.EnvelopedData())
+ self.assertFalse(rest)
+ self.assertTrue(ed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ed))
+
+ ri = ed['recipientInfos'][0]
+ alg1 = ri['ktri']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_GostR3410_2001, alg1['algorithm'])
+ param1, rest = der_decoder(
+ alg1['parameters'], asn1Spec=rfc4357.GostR3410_2001_PublicKeyParameters())
+ self.assertFalse(rest)
+ self.assertTrue(param1.prettyPrint())
+ self.assertEqual(alg1['parameters'], der_encoder(param1))
+ self.assertEqual(rfc4357.id_GostR3410_2001_CryptoPro_XchA_ParamSet, param1['publicKeyParamSet'])
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, param1['digestParamSet'])
+
+ alg2 = ed['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_Gost28147_89, alg2['algorithm'])
+ param2, rest = der_decoder(
+ alg2['parameters'], asn1Spec=rfc4357.Gost28147_89_Parameters())
+ self.assertFalse(rest)
+ self.assertTrue(param2.prettyPrint())
+ self.assertEqual(alg2['parameters'], der_encoder(param2))
+ self.assertEqual(8, len(param2['iv']))
+ self.assertEqual(rfc4357.id_Gost28147_89_CryptoPro_A_ParamSet, param2['encryptionParamSet'])
+
+ def testOpenTypes(self):
+ openTypeMap = {
+ rfc4357.id_GostR3410_2001: rfc4357.GostR3410_2001_PublicKeyParameters(),
+ rfc4357.id_Gost28147_89: rfc4357.Gost28147_89_Parameters(),
+ }
+
+ substrate = pem.readBase64fromText(self.keytrans_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec,
+ openTypes=openTypeMap, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ ri = asn1Object['content']['recipientInfos'][0]
+ alg1 = ri['ktri']['keyEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_GostR3410_2001, alg1['algorithm'])
+ param1 = alg1['parameters']
+ self.assertEqual(rfc4357.id_GostR3410_2001_CryptoPro_XchA_ParamSet, param1['publicKeyParamSet'])
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, param1['digestParamSet'])
+
+ alg2 = asn1Object['content']['encryptedContentInfo']['contentEncryptionAlgorithm']
+ self.assertEqual(rfc4357.id_Gost28147_89, alg2['algorithm'])
+ param2 = alg2['parameters']
+ self.assertEqual(8, len(param2['iv']))
+ self.assertEqual(rfc4357.id_Gost28147_89_CryptoPro_A_ParamSet, param2['encryptionParamSet'])
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4491.py b/tests/test_rfc4491.py
new file mode 100644
index 0000000..24b94a9
--- /dev/null
+++ b/tests/test_rfc4491.py
@@ -0,0 +1,156 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc4491
+from pyasn1_modules import rfc4357
+
+
+class GostR341094CertificateTestCase(unittest.TestCase):
+ gostR3410_94_cert_pem_text = """\
+MIICCzCCAboCECMO42BGlSTOxwvklBgufuswCAYGKoUDAgIEMGkxHTAbBgNVBAMM
+FEdvc3RSMzQxMC05NCBleGFtcGxlMRIwEAYDVQQKDAlDcnlwdG9Qcm8xCzAJBgNV
+BAYTAlJVMScwJQYJKoZIhvcNAQkBFhhHb3N0UjM0MTAtOTRAZXhhbXBsZS5jb20w
+HhcNMDUwODE2MTIzMjUwWhcNMTUwODE2MTIzMjUwWjBpMR0wGwYDVQQDDBRHb3N0
+UjM0MTAtOTQgZXhhbXBsZTESMBAGA1UECgwJQ3J5cHRvUHJvMQswCQYDVQQGEwJS
+VTEnMCUGCSqGSIb3DQEJARYYR29zdFIzNDEwLTk0QGV4YW1wbGUuY29tMIGlMBwG
+BiqFAwICFDASBgcqhQMCAiACBgcqhQMCAh4BA4GEAASBgLuEZuF5nls02CyAfxOo
+GWZxV/6MVCUhR28wCyd3RpjG+0dVvrey85NsObVCNyaE4g0QiiQOHwxCTSs7ESuo
+v2Y5MlyUi8Go/htjEvYJJYfMdRv05YmKCYJo01x3pg+2kBATjeM+fJyR1qwNCCw+
+eMG1wra3Gqgqi0WBkzIydvp7MAgGBiqFAwICBANBABHHCH4S3ALxAiMpR3aPRyqB
+g1DjB8zy5DEjiULIc+HeIveF81W9lOxGkZxnrFjXBSqnjLeFKgF1hffXOAP7zUM=
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.Certificate()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.gostR3410_94_cert_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ sa1 = asn1Object['signatureAlgorithm']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3411_94_with_GostR3410_94, sa1)
+
+ sa2 = asn1Object['tbsCertificate']['signature']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3411_94_with_GostR3410_94, sa2)
+
+ spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3410_94, spki_a['algorithm'])
+
+ pk_p, rest = der_decoder(
+ spki_a['parameters'],
+ asn1Spec=rfc4491.GostR3410_94_PublicKeyParameters())
+
+ self.assertFalse(rest)
+ self.assertTrue(pk_p.prettyPrint())
+ self.assertEqual(spki_a['parameters'], der_encoder(pk_p))
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, pk_p['digestParamSet'])
+
+ def testOpenTypes(self):
+ openTypesMap = {
+ rfc4491.id_GostR3410_94: rfc4491.GostR3410_94_PublicKeyParameters(),
+ }
+
+ substrate = pem.readBase64fromText(self.gostR3410_94_cert_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec,
+ openTypes=openTypesMap, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ sa1 = asn1Object['signatureAlgorithm']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3411_94_with_GostR3410_94, sa1)
+
+ sa2 = asn1Object['tbsCertificate']['signature']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3411_94_with_GostR3410_94, sa2)
+
+ spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3410_94, spki_a['algorithm'])
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, spki_a['parameters']['digestParamSet'])
+
+class GostR34102001CertificateTestCase(unittest.TestCase):
+ gostR3410_2001_cert_pem_text = """\
+MIIB0DCCAX8CECv1xh7CEb0Xx9zUYma0LiEwCAYGKoUDAgIDMG0xHzAdBgNVBAMM
+Fkdvc3RSMzQxMC0yMDAxIGV4YW1wbGUxEjAQBgNVBAoMCUNyeXB0b1BybzELMAkG
+A1UEBhMCUlUxKTAnBgkqhkiG9w0BCQEWGkdvc3RSMzQxMC0yMDAxQGV4YW1wbGUu
+Y29tMB4XDTA1MDgxNjE0MTgyMFoXDTE1MDgxNjE0MTgyMFowbTEfMB0GA1UEAwwW
+R29zdFIzNDEwLTIwMDEgZXhhbXBsZTESMBAGA1UECgwJQ3J5cHRvUHJvMQswCQYD
+VQQGEwJSVTEpMCcGCSqGSIb3DQEJARYaR29zdFIzNDEwLTIwMDFAZXhhbXBsZS5j
+b20wYzAcBgYqhQMCAhMwEgYHKoUDAgIkAAYHKoUDAgIeAQNDAARAhJVodWACGkB1
+CM0TjDGJLP3lBQN6Q1z0bSsP508yfleP68wWuZWIA9CafIWuD+SN6qa7flbHy7Df
+D2a8yuoaYDAIBgYqhQMCAgMDQQA8L8kJRLcnqeyn1en7U23Sw6pkfEQu3u0xFkVP
+vFQ/3cHeF26NG+xxtZPz3TaTVXdoiYkXYiD02rEx1bUcM97i
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.Certificate()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.gostR3410_2001_cert_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ sa1 = asn1Object['signatureAlgorithm']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3411_94_with_GostR3410_2001, sa1)
+
+ sa2 = asn1Object['tbsCertificate']['signature']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3411_94_with_GostR3410_2001, sa2)
+
+ spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3410_2001, spki_a['algorithm'])
+
+ pk_p, rest = der_decoder(
+ spki_a['parameters'], asn1Spec=rfc4491.GostR3410_2001_PublicKeyParameters())
+
+ self.assertFalse(rest)
+ self.assertTrue(pk_p.prettyPrint())
+ self.assertEqual(spki_a['parameters'], der_encoder(pk_p))
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, pk_p['digestParamSet'])
+
+ def testOpenTypes(self):
+ openTypeMap = {
+ rfc4491.id_GostR3410_2001: rfc4491.GostR3410_2001_PublicKeyParameters(),
+ }
+
+ substrate = pem.readBase64fromText(self.gostR3410_2001_cert_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec,
+ openTypes=openTypeMap, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ sa1 = asn1Object['signatureAlgorithm']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3411_94_with_GostR3410_2001, sa1)
+
+ sa2 = asn1Object['tbsCertificate']['signature']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3411_94_with_GostR3410_2001, sa2)
+
+ spki_a = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
+ self.assertEqual(rfc4491.id_GostR3410_2001, spki_a['algorithm'])
+ self.assertEqual(rfc4357.id_GostR3411_94_CryptoProParamSet, spki_a['parameters']['digestParamSet'])
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4683.py b/tests/test_rfc4683.py
new file mode 100644
index 0000000..7935ad8
--- /dev/null
+++ b/tests/test_rfc4683.py
@@ -0,0 +1,122 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+from pyasn1.type import univ
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc4683
+
+
+class SIMCertificateTestCase(unittest.TestCase):
+ cert_pem_text = """\
+MIIDOzCCAsCgAwIBAgIJAKWzVCgbsG5KMAoGCCqGSM49BAMDMD8xCzAJBgNVBAYT
+AlVTMQswCQYDVQQIDAJWQTEQMA4GA1UEBwwHSGVybmRvbjERMA8GA1UECgwIQm9n
+dXMgQ0EwHhcNMTkxMjExMjIzODUwWhcNMjAxMjEwMjIzODUwWjBOMQswCQYDVQQG
+EwJVUzELMAkGA1UECBMCVkExEDAOBgNVBAcTB0hlcm5kb24xEDAOBgNVBAoTB0V4
+YW1wbGUxDjAMBgNVBAMTBUhlbnJ5MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEZj80
+YyLeDb0arJY8ZxBUMMxPEMT9+5WFVBCC1dPpUn25MmEpb82Dz1inv3xmG6sFKIHj
+achlvkNGDXTUzZ1DdCF0O7gU5Z+YctwczGQVSt/2Ox0NWTiHLDpbpyoTyK0Bo4IB
+dzCCAXMwHQYDVR0OBBYEFOjxtcL2ucMoTjS5MNKKpdKzXtz/MG8GA1UdIwRoMGaA
+FPI12zQE2qVV8r1pA5mwYuziFQjBoUOkQTA/MQswCQYDVQQGEwJVUzELMAkGA1UE
+CAwCVkExEDAOBgNVBAcMB0hlcm5kb24xETAPBgNVBAoMCEJvZ3VzIENBggkA6JHW
+BpFPzvIwDwYDVR0TAQH/BAUwAwEB/zALBgNVHQ8EBAMCAYYwQgYJYIZIAYb4QgEN
+BDUWM1RoaXMgY2VydGlmaWNhdGUgY2Fubm90IGJlIHRydXN0ZWQgZm9yIGFueSBw
+dXJwb3NlLjB/BgNVHREEeDB2oGEGCCsGAQUFBwgGoFUwUzANBglghkgBZQMEAgEF
+AAQgnrmI6yL2lM5kmfLVn28A8PVIVgE2S7HEFtfLExhg7HsEIOaAn/Pq8hb4qn/K
+imN3uyZrjAv3Uspg0VYEcetJdHSCgRFoZW5yeUBleGFtcGxlLmNvbTAKBggqhkjO
+PQQDAwNpADBmAjEAiWhD493OGnqfdit6SRdBjn3N6HVaMxyVO0Lfosjf9+9FDWad
+rYt3o64YQqGz9NTMAjEAmahE0EMiu/TyzRDidlG2SxmY2aHg9hQO0t38i1jInJyi
+9LjB81zHEL6noTgBZsan
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.Certificate()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.cert_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ found_PEPSI = False
+ for extn in asn1Object['tbsCertificate']['extensions']:
+ if extn['extnID'] == rfc5280.id_ce_subjectAltName:
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.SubjectAltName())
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
+
+ for gn in extnValue:
+ if gn['otherName'].hasValue():
+ gn_on = gn['otherName']
+ if gn_on['type-id'] == rfc4683.id_on_SIM:
+ self.assertIn(
+ gn_on['type-id'], rfc5280.anotherNameMap)
+
+ spec = rfc5280.anotherNameMap[gn_on['type-id']]
+
+ on, rest = der_decoder(
+ gn_on['value'], asn1Spec=spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(on.prettyPrint())
+ self.assertEqual(gn_on['value'], der_encoder(on))
+
+ self.assertEqual(
+ 'e6809ff3ea', on['pEPSI'].prettyPrint()[2:12])
+
+ found_PEPSI = True
+
+ self.assertTrue(found_PEPSI)
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.cert_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ found_PEPSI = False
+ for extn in asn1Object['tbsCertificate']['extensions']:
+ if extn['extnID'] == rfc5280.id_ce_subjectAltName:
+ extnValue, rest = der_decoder(
+ extn['extnValue'],
+ asn1Spec=rfc5280.SubjectAltName(),
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
+
+ for gn in extnValue:
+ if gn['otherName'].hasValue():
+ pepsi = gn['otherName']['value']['pEPSI']
+ self.assertEqual(
+ 'e6809ff3ea', pepsi.prettyPrint()[2:12])
+
+ found_PEPSI = True
+
+ self.assertTrue(found_PEPSI)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc4985.py b/tests/test_rfc4985.py
index 132b12b..b261ef9 100644
--- a/tests/test_rfc4985.py
+++ b/tests/test_rfc4985.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc4985
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class XMPPCertificateTestCase(unittest.TestCase):
xmpp_server_cert_pem_text = """\
@@ -46,64 +41,73 @@ nOzhcMpnHs2U/eN0lHl/JNgnbftl6Dvnt59xdA==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.xmpp_server_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
count = 0
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectAltName:
- extnValue, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.SubjectAltName())
- assert not rest
- assert extnValue.prettyPrint()
- assert der_encode(extnValue) == extn['extnValue']
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.SubjectAltName())
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
+
for gn in extnValue:
if gn['otherName'].hasValue():
gn_on = gn['otherName']
if gn_on['type-id'] == rfc4985.id_on_dnsSRV:
- assert gn_on['type-id'] in rfc5280.anotherNameMap.keys()
+ self.assertIn(gn_on['type-id'], rfc5280.anotherNameMap)
+
spec = rfc5280.anotherNameMap[gn['otherName']['type-id']]
- on, rest = der_decode(gn_on['value'], asn1Spec=spec)
- assert not rest
- assert on.prettyPrint()
- assert der_encode(on) == gn_on['value']
- assert 'im.example.com' in on
+ on, rest = der_decoder(gn_on['value'], asn1Spec=spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(on.prettyPrint())
+ self.assertEqual(gn_on['value'], der_encoder(on))
+ self.assertIn('im.example.com', on)
+
count += 1
- assert count == 2
+ self.assertEqual(2, count)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.xmpp_server_cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
count = 0
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectAltName:
- extnValue, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.SubjectAltName(), decodeOpenTypes=True)
- assert not rest
- assert extnValue.prettyPrint()
- assert der_encode(extnValue) == extn['extnValue']
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.SubjectAltName(),
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
+
for gn in extnValue:
if gn['otherName'].hasValue():
if gn['otherName']['type-id'] == rfc4985.id_on_dnsSRV:
- assert 'im.example.com' in gn['otherName']['value']
+ self.assertIn('im.example.com', gn['otherName']['value'])
count += 1
- assert count == 2
+ self.assertEqual(2, count)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5035.py b/tests/test_rfc5035.py
index 22f0f36..196a6e4 100644
--- a/tests/test_rfc5035.py
+++ b/tests/test_rfc5035.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc5035
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class SignedMessageTestCase(unittest.TestCase):
signed_message_pem_text = """\
@@ -61,26 +56,28 @@ T9yMtRLN5ZDU14y+Phzq9NKpSw/x5KyXoUKjCMc3Ru6dIW+CgcRQees+dhnvuD5U
def testDerCodec(self):
substrate = pem.readBase64fromText(self.signed_message_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
- sd, rest = der_decode(asn1Object['content'], asn1Spec=rfc5652.SignedData())
- assert not rest
- assert sd.prettyPrint()
- assert der_encode(sd) == asn1Object['content']
+ asn1Object, rest = der_decoder (substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
+ sd, rest = der_decoder(asn1Object['content'], asn1Spec=rfc5652.SignedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(sd.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(sd))
for sa in sd['signerInfos'][0]['signedAttrs']:
sat = sa['attrType']
sav0 = sa['attrValues'][0]
if sat in rfc5652.cmsAttributesMap.keys():
- sav, rest = der_decode(sav0, asn1Spec=rfc5652.cmsAttributesMap[sat])
- assert not rest
- assert sav.prettyPrint()
- assert der_encode(sav) == sav0
+ sav, rest = der_decoder(sav0, asn1Spec=rfc5652.cmsAttributesMap[sat])
+ self.assertFalse(rest)
+ self.assertTrue(sav.prettyPrint())
+ self.assertEqual(sav0, der_encoder(sav))
class SignedReceiptTestCase(unittest.TestCase):
@@ -116,66 +113,80 @@ vFIgX7eIkd8=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.signed_receipt_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
- sd, rest = der_decode (asn1Object['content'], asn1Spec=rfc5652.SignedData())
- assert not rest
- assert sd.prettyPrint()
- assert der_encode(sd) == asn1Object['content']
-
- assert sd['encapContentInfo']['eContentType'] == rfc5035.id_ct_receipt
- receipt, rest = der_decode(sd['encapContentInfo']['eContent'],
- asn1Spec=rfc5035.Receipt())
- assert not rest
- assert receipt.prettyPrint()
- assert der_encode(receipt) == sd['encapContentInfo']['eContent']
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
+ sd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.SignedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(sd.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(sd))
+ self.assertEqual(
+ rfc5035.id_ct_receipt, sd['encapContentInfo']['eContentType'])
+
+ receipt, rest = der_decoder(
+ sd['encapContentInfo']['eContent'], asn1Spec=rfc5035.Receipt())
+
+ self.assertFalse(rest)
+ self.assertTrue(receipt.prettyPrint())
+ self.assertEqual(
+ sd['encapContentInfo']['eContent'], der_encoder(receipt))
for sa in sd['signerInfos'][0]['signedAttrs']:
sat = sa['attrType']
sav0 = sa['attrValues'][0]
if sat in rfc5652.cmsAttributesMap.keys():
- sav, rest = der_decode(sav0, asn1Spec=rfc5652.cmsAttributesMap[sat])
- assert not rest
- assert sav.prettyPrint()
- assert der_encode(sav) == sav0
+ sav, rest = der_decoder(
+ sav0, asn1Spec=rfc5652.cmsAttributesMap[sat])
+ self.assertFalse(rest)
+ self.assertTrue(sav.prettyPrint())
+ self.assertEqual(sav0, der_encoder(sav))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.signed_receipt_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
- assert asn1Object['contentType'] in rfc5652.cmsContentTypesMap.keys()
- assert asn1Object['contentType'] == rfc5652.id_signedData
+ self.assertIn(asn1Object['contentType'], rfc5652.cmsContentTypesMap)
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
sd = asn1Object['content']
- assert sd['version'] == rfc5652.CMSVersion().subtype(value='v3')
- assert sd['encapContentInfo']['eContentType'] in rfc5652.cmsContentTypesMap.keys()
- assert sd['encapContentInfo']['eContentType'] == rfc5035.id_ct_receipt
+
+ self.assertEqual(
+ rfc5652.CMSVersion().subtype(value='v3'), sd['version'])
+ self.assertIn(
+ sd['encapContentInfo']['eContentType'], rfc5652.cmsContentTypesMap)
+ self.assertEqual(
+ rfc5035.id_ct_receipt, sd['encapContentInfo']['eContentType'])
for sa in sd['signerInfos'][0]['signedAttrs']:
- assert sa['attrType'] in rfc5652.cmsAttributesMap.keys()
+ self.assertIn(sa['attrType'], rfc5652.cmsAttributesMap)
if sa['attrType'] == rfc5035.id_aa_msgSigDigest:
- sa['attrValues'][0].prettyPrint()[:10] == '0x167378'
+ self.assertIn(
+ '0x167378', sa['attrValues'][0].prettyPrint()[:10])
# Since receipt is inside an OCTET STRING, decodeOpenTypes=True cannot
# automatically decode it
- receipt, rest = der_decode(sd['encapContentInfo']['eContent'],
+ receipt, rest = der_decoder(
+ sd['encapContentInfo']['eContent'],
asn1Spec=rfc5652.cmsContentTypesMap[sd['encapContentInfo']['eContentType']])
- assert receipt['version'] == 1
+
+ self.assertEqual(1, receipt['version'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5083.py b/tests/test_rfc5083.py
index 4dcfa96..e2eb172 100644
--- a/tests/test_rfc5083.py
+++ b/tests/test_rfc5083.py
@@ -5,22 +5,17 @@
# Copyright (c) 2018, 2019 Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc5083
from pyasn1_modules import rfc5035
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class AuthEnvelopedDataTestCase(unittest.TestCase):
pem_text = """\
@@ -43,10 +38,10 @@ ur76ztut3sr4iIANmvLRbyFUf87+2bPvLQQMoOWSXMGE4BckY8RM
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
class AuthEnvelopedDataOpenTypesTestCase(unittest.TestCase):
@@ -73,28 +68,28 @@ IDAeDBFXYXRzb24sIGNvbWUgaGVyZQYJKoZIhvcNAQcB
def testDerCodec(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] in rfc5652.cmsContentTypesMap
- assert asn1Object['contentType'] == rfc5083.id_ct_authEnvelopedData
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertIn(asn1Object['contentType'], rfc5652.cmsContentTypesMap)
+ self.assertEqual(rfc5083.id_ct_authEnvelopedData, asn1Object['contentType'])
+
authenv = asn1Object['content']
- assert authenv['version'] == 0
+
+ self.assertEqual(0, authenv['version'])
for attr in authenv['unauthAttrs']:
- assert attr['attrType'] in rfc5652.cmsAttributesMap
+ self.assertIn(attr['attrType'], rfc5652.cmsAttributesMap)
if attr['attrType'] == rfc5035.id_aa_contentHint:
- assert 'Watson' in attr['attrValues'][0]['contentDescription']
+ self.assertIn(
+ 'Watson', attr['attrValues'][0]['contentDescription'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5084.py b/tests/test_rfc5084.py
index e685922..c8ad0c2 100644
--- a/tests/test_rfc5084.py
+++ b/tests/test_rfc5084.py
@@ -5,22 +5,17 @@
# Copyright (c) 2018, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5083
from pyasn1_modules import rfc5084
from pyasn1_modules import rfc5652
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class CCMParametersTestCase(unittest.TestCase):
ccm_pem_text = "MBEEDE2HVyIurFKUEX8MEgIBBA=="
@@ -30,10 +25,11 @@ class CCMParametersTestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.ccm_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
class GCMParametersTestCase(unittest.TestCase):
@@ -44,10 +40,11 @@ class GCMParametersTestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.gcm_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
class GCMOpenTypesTestCase(unittest.TestCase):
@@ -95,29 +92,31 @@ BX7T4w681pCD+dOiom75C3UdahrfoFkNsZ2hB88+qNsEEPb/xuGu8ZzSPZhakhl2NS0=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.rfc8591_pem_pext)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] == rfc5083.id_ct_authEnvelopedData
- aed, rest = der_decode(asn1Object['content'],
- asn1Spec=rfc5083.AuthEnvelopedData(),
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(
+ rfc5083.id_ct_authEnvelopedData, asn1Object['contentType'])
+
+ aed, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5083.AuthEnvelopedData(),
decodeOpenTypes=True)
- assert not rest
- assert aed.prettyPrint()
- assert der_encode(aed) == asn1Object['content']
- assert aed['version'] == 0
+ self.assertFalse(rest)
+ self.assertTrue(aed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(aed))
+ self.assertEqual(0, aed['version'])
+
cea = aed['authEncryptedContentInfo']['contentEncryptionAlgorithm']
- assert cea['algorithm'] == rfc5084.id_aes128_GCM
- assert cea['parameters']['aes-ICVlen'] == 16
+
+ self.assertEqual(rfc5084.id_aes128_GCM, cea['algorithm'])
+ self.assertEqual(16, cea['parameters']['aes-ICVlen'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5126.py b/tests/test_rfc5126.py
new file mode 100644
index 0000000..e43af9a
--- /dev/null
+++ b/tests/test_rfc5126.py
@@ -0,0 +1,103 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc4055
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5126
+
+
+class SignedAttributesTestCase(unittest.TestCase):
+ pem_text = """\
+MYIBUzAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMCsGCSqGSIb3DQEJNDEeMBww
+DQYJYIZIAWUDBAIBBQChCwYJKoZIhvcNAQELMC8GCSqGSIb3DQEJBDEiBCCyqtCC
+Gosj/GT4YPPAqKheze4A1QBU5O3tniTsVPGr7jBBBgsqhkiG9w0BCRACETEyMDCg
+BBMCVVOhBBMCVkGiIjAgExExMjMgU29tZXBsYWNlIFdheRMLSGVybmRvbiwgVkEw
+RgYLKoZIhvcNAQkQAi8xNzA1MDMwMTANBglghkgBZQMEAgEFAAQgJPmqUmGQnQ4q
+RkVtUHecJXIkozOzX8+pZQj/UD5JcnQwTgYLKoZIhvcNAQkQAg8xPzA9BgorBgEE
+AYGsYDAUMC8wCwYJYIZIAWUDBAIBBCDWjjVmAeXgZBkE/rG8Pf8pTCs4Ikowc8Vm
+l+AOeKdFgg==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.SignedAttributes()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ found_spid_oid = False
+
+ for attr in asn1Object:
+ if attr['attrType'] in rfc5652.cmsAttributesMap.keys():
+ av, rest = der_decoder(
+ attr['attrValues'][0],
+ asn1Spec=rfc5652.cmsAttributesMap[attr['attrType']])
+
+ self.assertFalse(rest)
+ self.assertTrue(av.prettyPrint())
+ self.assertEqual(attr['attrValues'][0], der_encoder(av))
+
+ if attr['attrType'] == rfc5126.id_aa_ets_sigPolicyId:
+ spid_oid = rfc5126.SigPolicyId('1.3.6.1.4.1.22112.48.20')
+
+ self.assertEqual(
+ spid_oid, av['signaturePolicyId']['sigPolicyId'])
+
+ found_spid_oid = True
+
+ self.assertTrue(found_spid_oid)
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ attr_type_list = []
+ spid_oid = rfc5126.SigPolicyId('1.3.6.1.4.1.22112.48.20')
+
+ for attr in asn1Object:
+ if attr['attrType'] == rfc5126.id_aa_ets_sigPolicyId:
+ spid = attr['attrValues'][0]['signaturePolicyId']
+ self.assertEqual(spid_oid, spid['sigPolicyId'])
+ attr_type_list.append(rfc5126.id_aa_ets_sigPolicyId)
+
+ if attr['attrType'] == rfc5126.id_aa_ets_signerLocation:
+ cn = attr['attrValues'][0]['countryName']
+ self.assertEqual('US', cn['printableString'])
+ attr_type_list.append(rfc5126.id_aa_ets_signerLocation)
+
+ if attr['attrType'] == rfc5126.id_aa_signingCertificateV2:
+ ha = attr['attrValues'][0]['certs'][0]['hashAlgorithm']
+ self.assertEqual(rfc4055.id_sha256, ha['algorithm'])
+ attr_type_list.append(rfc5126.id_aa_signingCertificateV2)
+
+ self.assertIn(rfc5126.id_aa_ets_sigPolicyId, attr_type_list)
+ self.assertIn(rfc5126.id_aa_ets_signerLocation, attr_type_list)
+ self.assertIn(rfc5126.id_aa_signingCertificateV2, attr_type_list)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ import sys
+
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5208.py b/tests/test_rfc5208.py
index 7e962ca..4bb684f 100644
--- a/tests/test_rfc5208.py
+++ b/tests/test_rfc5208.py
@@ -1,10 +1,11 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
@@ -12,12 +13,6 @@ from pyasn1.codec.der import encoder as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5208
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class PrivateKeyInfoTestCase(unittest.TestCase):
pem_text = """\
@@ -38,11 +33,12 @@ VWRpRKqYnOAIXQ==
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
class EncryptedPrivateKeyInfoInfoTestCase(unittest.TestCase):
@@ -64,17 +60,16 @@ dLsZjNQ=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5275.py b/tests/test_rfc5275.py
new file mode 100644
index 0000000..30bce8f
--- /dev/null
+++ b/tests/test_rfc5275.py
@@ -0,0 +1,190 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5275
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc6402
+
+
+class GLUseKEKTestCase(unittest.TestCase):
+ pem_text = """\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+"""
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+
+ layers = { }
+ layers.update(rfc5652.cmsContentTypesMap)
+
+ getNextLayer = {
+ rfc5652.id_ct_contentInfo: lambda x: x['contentType'],
+ rfc5652.id_signedData: lambda x: x['encapContentInfo']['eContentType'],
+ rfc6402.id_cct_PKIData: lambda x: None
+ }
+
+ getNextSubstrate = {
+ rfc5652.id_ct_contentInfo: lambda x: x['content'],
+ rfc5652.id_signedData: lambda x: x['encapContentInfo']['eContent'],
+ rfc6402.id_cct_PKIData: lambda x: None
+ }
+
+ next_layer = rfc5652.id_ct_contentInfo
+ while next_layer:
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=layers[next_layer])
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ substrate = getNextSubstrate[next_layer](asn1Object)
+ next_layer = getNextLayer[next_layer](asn1Object)
+
+ found_gl_use_kek = False
+ for ctrl in asn1Object['controlSequence']:
+ if ctrl['attrType'] == rfc5275.id_skd_glUseKEK:
+ cv, rest = der_decoder(
+ ctrl['attrValues'][0],
+ asn1Spec=rfc5652.cmsAttributesMap[ctrl['attrType']])
+
+ self.assertFalse(rest)
+ self.assertTrue(cv.prettyPrint())
+ self.assertEqual(ctrl['attrValues'][0], der_encoder(cv))
+
+ self.assertIn(
+ 'example.com',
+ cv['glInfo']['glAddress']['rfc822Name'])
+
+ self.assertIn(
+ 'example.com',
+ cv['glOwnerInfo'][0]['glOwnerAddress']['rfc822Name'])
+
+ self.assertEqual(31, cv['glKeyAttributes']['duration'])
+ found_gl_use_kek = True
+
+ self.assertTrue(found_gl_use_kek)
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=rfc5652.ContentInfo(), decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ sd = asn1Object['content']
+ self.assertEqual(
+ rfc6402.id_cct_PKIData, sd['encapContentInfo']['eContentType'])
+
+ pkid, rest = der_decoder(
+ sd['encapContentInfo']['eContent'],
+ asn1Spec=rfc6402.PKIData(),
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(pkid.prettyPrint())
+ self.assertEqual(sd['encapContentInfo']['eContent'], der_encoder(pkid))
+
+ found_gl_use_kek = False
+ for ctrl in pkid['controlSequence']:
+ if ctrl['attrType'] == rfc5275.id_skd_glUseKEK:
+ cv = ctrl['attrValues'][0]
+
+ self.assertIn(
+ 'example.com',
+ cv['glInfo']['glAddress']['rfc822Name'])
+
+ self.assertIn(
+ 'example.com',
+ cv['glOwnerInfo'][0]['glOwnerAddress']['rfc822Name'])
+
+ self.assertEqual(31, cv['glKeyAttributes']['duration'])
+ found_gl_use_kek = True
+
+ self.assertTrue(found_gl_use_kek)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ import sys
+
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5280.py b/tests/test_rfc5280.py
index 9802ef9..ea9e533 100644
--- a/tests/test_rfc5280.py
+++ b/tests/test_rfc5280.py
@@ -1,25 +1,19 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class CertificateTestCase(unittest.TestCase):
pem_text = """\
@@ -48,11 +42,12 @@ PhmcGcwTTYJBtYze4D1gCCAPRX5ron+jjBXu
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
class CertificateListTestCase(unittest.TestCase):
@@ -73,12 +68,12 @@ vjnIhxTFoCb5vA==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
-
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
class CertificateOpenTypeTestCase(unittest.TestCase):
@@ -114,27 +109,29 @@ PhmcGcwTTYJBtYze4D1gCCAPRX5ron+jjBXu
univ.ObjectIdentifier('1.2.840.113549.1.1.11'): univ.Null(""),
}
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- openTypes=openTypesMap,
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, openTypes=openTypesMap,
decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
sig_alg = asn1Object['tbsCertificate']['signature']
- assert sig_alg['parameters'] == univ.Null("")
+
+ self.assertEqual(univ.Null(""), sig_alg['parameters'])
spki_alg = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_alg['parameters'] == univ.Null("")
+
+ self.assertEqual(univ.Null(""), spki_alg['parameters'])
for rdn in asn1Object['tbsCertificate']['subject']['rdnSequence']:
for atv in rdn:
if atv['type'] == rfc5280.id_emailAddress:
- assert "valicert.com" in atv['value']
+ self.assertIn("valicert.com", atv['value'])
else:
atv_ps = str(atv['value']['printableString'])
- assert "valicert" in atv_ps.lower()
+ self.assertIn("valicert", atv_ps.lower())
class CertificateListOpenTypeTestCase(unittest.TestCase):
@@ -162,52 +159,67 @@ vjnIhxTFoCb5vA==
univ.ObjectIdentifier('1.2.840.113549.1.1.11'): univ.Null(""),
}
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- openTypes=openTypesMap,
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, openTypes=openTypesMap,
decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
sig_alg = asn1Object['tbsCertList']['signature']
- assert sig_alg['parameters'] == univ.Null("")
+
+ self.assertEqual(univ.Null(""), sig_alg['parameters'])
for rdn in asn1Object['tbsCertList']['issuer']['rdnSequence']:
for atv in rdn:
if atv['type'] == rfc5280.id_emailAddress:
- assert "snmplabs.com" in atv['value']
+ self.assertIn("snmplabs.com", atv['value'])
+
elif atv['type'] == rfc5280.id_at_countryName:
- assert atv['value'] == 'AU'
+ self.assertEqual('AU', atv['value'])
+
else:
- assert len(atv['value']['printableString']) > 9
+ self.assertLess(9, len(atv['value']['printableString']))
crl_extn_count = 0
+
for extn in asn1Object['tbsCertList']['crlExtensions']:
if extn['extnID'] in rfc5280.certificateExtensionsMap.keys():
- ev, rest = der_decode(extn['extnValue'],
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
+
crl_extn_count += 1
- assert crl_extn_count == 1
+
+ self.assertEqual(1, crl_extn_count)
def testExtensionsMap(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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
cert_extn_count = 0
+
for extn in asn1Object['tbsCertList']['crlExtensions']:
if extn['extnID'] in rfc5280.certificateExtensionsMap.keys():
- extnValue, rest = der_decode(extn['extnValue'],
+ extnValue, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert der_encode(extnValue) == extn['extnValue']
+
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
+
cert_extn_count += 1
- assert cert_extn_count == 1
+
+ self.assertEqual(1, cert_extn_count)
+
class ORAddressOpenTypeTestCase(unittest.TestCase):
oraddress_pem_text = """\
@@ -221,22 +233,21 @@ FDASgAEBoQ0TC1N0ZXZlIEtpbGxl
def testDecodeOpenTypes(self):
substrate = pem.readBase64fromText(self.oraddress_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
ea0 = asn1Object['extension-attributes'][0]
- assert ea0['extension-attribute-type'] == rfc5280.common_name
- assert ea0['extension-attribute-value'] == "Steve Kille"
+
+ self.assertEqual(rfc5280.common_name, ea0['extension-attribute-type'])
+ self.assertEqual("Steve Kille", ea0['extension-attribute-value'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5480.py b/tests/test_rfc5480.py
index fa93553..72ca51a 100755
--- a/tests/test_rfc5480.py
+++ b/tests/test_rfc5480.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc5480
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class ECCertTestCase(unittest.TestCase):
digicert_ec_cert_pem_text = """\
@@ -50,34 +45,37 @@ Ea8/B6hPatJ0ES8q/HO3X8IVQwVs1n3aAr0im0/T+Xc=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.digicert_ec_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
algid = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert algid['algorithm'] == rfc5480.id_ecPublicKey
- param, rest = der_decode(algid['parameters'], asn1Spec=rfc5480.ECParameters())
- assert param.prettyPrint()
- assert param['namedCurve'] == rfc5480.secp384r1
+
+ self.assertEqual(rfc5480.id_ecPublicKey, algid['algorithm'])
+
+ param, rest = der_decoder(algid['parameters'], asn1Spec=rfc5480.ECParameters())
+
+ self.assertTrue(param.prettyPrint())
+ self.assertEqual(rfc5480.secp384r1, param['namedCurve'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.digicert_ec_cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate,
+ asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_alg = asn1Object['tbsCertificate']['subjectPublicKeyInfo']['algorithm']
- assert spki_alg['algorithm'] == rfc5480.id_ecPublicKey
- assert spki_alg['parameters']['namedCurve'] == rfc5480.secp384r1
+
+ self.assertEqual(rfc5480.id_ecPublicKey, spki_alg['algorithm'])
+ self.assertEqual(rfc5480.secp384r1, spki_alg['parameters']['namedCurve'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5636.py b/tests/test_rfc5636.py
new file mode 100644
index 0000000..8f5d90e
--- /dev/null
+++ b/tests/test_rfc5636.py
@@ -0,0 +1,118 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5636
+
+
+class TraceableAnonymousCertificateTestCase(unittest.TestCase):
+ pem_text = """\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+"""
+
+ def testDerCodec(self):
+
+ substrate = pem.readBase64fromText(self.pem_text)
+
+ layers = { }
+ layers.update(rfc5652.cmsContentTypesMap)
+
+ getNextLayer = {
+ rfc5652.id_ct_contentInfo: lambda x: x['contentType'],
+ rfc5652.id_signedData: lambda x: x['encapContentInfo']['eContentType'],
+ rfc5636.id_kisa_tac_token: lambda x: None
+ }
+
+ getNextSubstrate = {
+ rfc5652.id_ct_contentInfo: lambda x: x['content'],
+ rfc5652.id_signedData: lambda x: x['encapContentInfo']['eContent'],
+ rfc5636.id_kisa_tac_token: lambda x: None
+ }
+
+ next_layer = rfc5652.id_ct_contentInfo
+ while next_layer:
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=layers[next_layer])
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ substrate = getNextSubstrate[next_layer](asn1Object)
+ next_layer = getNextLayer[next_layer](asn1Object)
+
+ self.assertEqual('2019', asn1Object['timeout'][:4])
+ self.assertEqual('5dcdf44e', asn1Object['userKey'].prettyPrint()[-8:])
+
+ def testOpenTypes(self):
+ asn1Spec=rfc5652.ContentInfo()
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ substrate = asn1Object['content']['encapContentInfo']['eContent']
+ oid = asn1Object['content']['encapContentInfo']['eContentType']
+ self.assertIn(oid, rfc5652.cmsContentTypesMap)
+
+ tac_token, rest = der_decoder(
+ substrate,
+ asn1Spec=rfc5652.cmsContentTypesMap[oid],
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(tac_token.prettyPrint())
+ self.assertEqual(substrate, der_encoder(tac_token))
+
+ self.assertEqual('2019', tac_token['timeout'][:4])
+ self.assertEqual('5dcdf44e', tac_token['userKey'].prettyPrint()[-8:])
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5639.py b/tests/test_rfc5639.py
new file mode 100644
index 0000000..628b902
--- /dev/null
+++ b/tests/test_rfc5639.py
@@ -0,0 +1,80 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5480
+from pyasn1_modules import rfc5639
+
+
+class ECCertTestCase(unittest.TestCase):
+ brainpool_ec_cert_pem_text = """\
+MIIB0jCCAXmgAwIBAgITPUXQAyl3ZE5iAHYGZYSp1FkqzTAKBggqhkjOPQQDAjA/
+MQswCQYDVQQGEwJVUzELMAkGA1UECAwCVkExEDAOBgNVBAcMB0hlcm5kb24xETAP
+BgNVBAoMCEJvZ3VzIENBMB4XDTE5MTIwOTIxNDM0NFoXDTIxMTIwODIxNDM0NFow
+PzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlZBMRAwDgYDVQQHDAdIZXJuZG9uMREw
+DwYDVQQKDAhCb2d1cyBDQTBaMBQGByqGSM49AgEGCSskAwMCCAEBBwNCAASBvvOk
+WNZlGAf5O3V94qgC3IUUR/6uxFxT6To0ULFmrVVndXiVP6DE5h5QHGXPwKfO+4Yt
+n0OVnGHp68dPS37Go1MwUTAdBgNVHQ4EFgQUiRFFVcdn6Fp9+sEP1GVRtwl9XgIw
+HwYDVR0jBBgwFoAUiRFFVcdn6Fp9+sEP1GVRtwl9XgIwDwYDVR0TAQH/BAUwAwEB
+/zAKBggqhkjOPQQDAgNHADBEAiB3d+P64Dh5YzwyM++uOL6zHUeLbNpW2sF1eJsm
+l3M5uQIgGxpbAXOt/o1xtyhEGLNUBE7ObgQpm7tHMMQGUHo4wV8=
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.Certificate()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.brainpool_ec_cert_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ spki = asn1Object['tbsCertificate']['subjectPublicKeyInfo']
+ algid = spki['algorithm']
+
+ self.assertEqual(rfc5480.id_ecPublicKey, algid['algorithm'])
+
+ param, rest = der_decoder(
+ algid['parameters'], asn1Spec=rfc5480.ECParameters())
+
+ self.assertFalse(rest)
+ self.assertTrue(param.prettyPrint())
+ self.assertEqual(algid['parameters'], der_encoder(param))
+
+ self.assertEqual(rfc5639.brainpoolP256r1, param['namedCurve'])
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.brainpool_ec_cert_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ spki = asn1Object['tbsCertificate']['subjectPublicKeyInfo']
+ algid = spki['algorithm']
+
+ self.assertEqual(rfc5480.id_ecPublicKey, algid['algorithm'])
+ self.assertEqual(
+ rfc5639.brainpoolP256r1, algid['parameters']['namedCurve'])
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5649.py b/tests/test_rfc5649.py
index 9f404ad..c2fa9d1 100644
--- a/tests/test_rfc5649.py
+++ b/tests/test_rfc5649.py
@@ -5,8 +5,8 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
@@ -14,11 +14,6 @@ from pyasn1.codec.der import encoder as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5649
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class AESKeyWrapTestCase(unittest.TestCase):
kw_alg_id_pem_text = "MAsGCWCGSAFlAwQBLQ=="
@@ -28,11 +23,13 @@ class AESKeyWrapTestCase(unittest.TestCase):
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] == rfc5649.id_aes256_wrap
- assert der_encoder.encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc5649.id_aes256_wrap, asn1Object[0])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
class AESKeyWrapWithPadTestCase(unittest.TestCase):
@@ -43,17 +40,17 @@ class AESKeyWrapWithPadTestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.kw_pad_alg_id_pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert asn1Object[0] == rfc5649.id_aes256_wrap_pad
- assert der_encoder.encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc5649.id_aes256_wrap_pad, asn1Object[0])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5652.py b/tests/test_rfc5652.py
index be18914..7055b52 100644
--- a/tests/test_rfc5652.py
+++ b/tests/test_rfc5652.py
@@ -1,29 +1,22 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
-
from pyasn1.type import char
from pyasn1.type import namedtype
from pyasn1.type import univ
from pyasn1_modules import pem
-from pyasn1_modules import rfc5280
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc6402
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class ContentInfoTestCase(unittest.TestCase):
pem_text = """\
@@ -81,9 +74,9 @@ xicQmJP+VoMHo/ZpjFY9fYCjNZUArgKsEwK/s+p9yrVVeB1Nf8Mn
substrate, asn1Spec=layers[next_layer]
)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
substrate = getNextSubstrate[next_layer](asn1Object)
next_layer = getNextLayer[next_layer](asn1Object)
@@ -125,46 +118,52 @@ xicQmJP+VoMHo/ZpjFY9fYCjNZUArgKsEwK/s+p9yrVVeB1Nf8Mn
substrate = pem.readBase64fromText(self.pem_text)
asn1Object, rest = der_decoder.decode(substrate,
asn1Spec=rfc5652.ContentInfo(), decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
eci = asn1Object['content']['encapContentInfo']
- assert eci['eContentType'] in rfc5652.cmsContentTypesMap.keys()
- assert eci['eContentType'] == rfc6402.id_cct_PKIData
+
+ self.assertIn(eci['eContentType'], rfc5652.cmsContentTypesMap)
+ self.assertEqual(rfc6402.id_cct_PKIData, eci['eContentType'])
+
pkid, rest = der_decoder.decode(eci['eContent'],
asn1Spec=rfc5652.cmsContentTypesMap[eci['eContentType']],
openTypes=openTypeMap,
decodeOpenTypes=True)
- assert not rest
- assert pkid.prettyPrint()
- assert der_encoder.encode(pkid) == eci['eContent']
+
+ self.assertFalse(rest)
+ self.assertTrue(pkid.prettyPrint())
+ self.assertEqual(eci['eContent'], der_encoder.encode(pkid))
for req in pkid['reqSequence']:
cr = req['tcr']['certificationRequest']
sig_alg = cr['signatureAlgorithm']
- assert sig_alg['algorithm'] in openTypeMap.keys()
- assert sig_alg['parameters'] == univ.Null("")
+
+ self.assertIn(sig_alg['algorithm'], openTypeMap)
+ self.assertEqual(univ.Null(""), sig_alg['parameters'])
cri = cr['certificationRequestInfo']
spki_alg = cri['subjectPublicKeyInfo']['algorithm']
- assert spki_alg['algorithm'] in openTypeMap.keys()
- assert spki_alg['parameters'] == univ.Null("")
+
+ self.assertIn( spki_alg['algorithm'], openTypeMap)
+ self.assertEqual(univ.Null(""), spki_alg['parameters'])
attrs = cr['certificationRequestInfo']['attributes']
+
for attr in attrs:
- assert attr['attrType'] in openTypeMap.keys()
+ self.assertIn(attr['attrType'], openTypeMap)
+
if attr['attrType'] == univ.ObjectIdentifier('1.3.6.1.4.1.311.13.2.3'):
- assert attr['attrValues'][0] == "6.2.9200.2"
+ self.assertEqual("6.2.9200.2", attr['attrValues'][0])
+
else:
- assert attr['attrValues'][0].hasValue()
+ self.assertTrue(attr['attrValues'][0].hasValue())
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5697.py b/tests/test_rfc5697.py
new file mode 100644
index 0000000..1aa0e2b
--- /dev/null
+++ b/tests/test_rfc5697.py
@@ -0,0 +1,126 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+from pyasn1.type import univ
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5697
+
+
+class OtherCertTestCase(unittest.TestCase):
+ cert_pem_text = """\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+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.Certificate()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.cert_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ other_cert_found = False
+
+ for extn in asn1Object['tbsCertificate']['extensions']:
+ if extn['extnID'] == rfc5697.id_pe_otherCerts:
+ extnValue, rest = der_decoder(
+ extn['extnValue'],
+ asn1Spec=rfc5697.OtherCertificates())
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
+
+ self.assertEqual(
+ 11939979568329289287,
+ extnValue[0]['issuerSerial']['serialNumber'])
+
+ other_cert_found = True
+
+ self.assertTrue(other_cert_found)
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.cert_pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ other_cert_found = False
+
+ for extn in asn1Object['tbsCertificate']['extensions']:
+ if extn['extnID'] == rfc5697.id_pe_otherCerts:
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+
+ extnValue, rest = der_decoder(
+ extn['extnValue'],
+ asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']],
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
+
+ self.assertEqual(
+ 11939979568329289287,
+ extnValue[0]['issuerSerial']['serialNumber'])
+
+ other_cert_found = True
+
+ self.assertTrue(other_cert_found)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5751.py b/tests/test_rfc5751.py
index a89457a..7ce4373 100644
--- a/tests/test_rfc5751.py
+++ b/tests/test_rfc5751.py
@@ -5,23 +5,17 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc5751
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class SignedMessageTestCase(unittest.TestCase):
pem_text = """\
@@ -72,38 +66,38 @@ LQIVALwzN2XE93BcF0kTqkyFyrtSkUhZAhRjlqIUi89X3rBIX2xk3YQESV8cyg==
smimeCapMap.update(rfc5751.smimeCapabilityMap)
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode (substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder (substrate,
+ asn1Spec=self.asn1Spec,
+ decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
- assert asn1Object['contentType'] == rfc5652.id_signedData
- assert asn1Object['content']['version'] == 1
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+ self.assertEqual(1, asn1Object['content']['version'])
for si in asn1Object['content']['signerInfos']:
- assert si['version'] == 1
+ self.assertEqual(1, si['version'])
+
for attr in si['signedAttrs']:
if attr['attrType'] == rfc5751.smimeCapabilities:
for scap in attr['attrValues'][0]:
if scap['capabilityID'] in smimeCapMap.keys():
- scap_p, rest = der_decode(scap['parameters'],
- asn1Spec=smimeCapMap[scap['capabilityID']])
- assert not rest
- assert der_encode(scap_p) == scap['parameters']
- assert 'parameters' in scap_p.prettyPrint()
+ scap_p, rest = der_decoder(scap['parameters'],
+ asn1Spec=smimeCapMap[scap['capabilityID']])
+ self.assertFalse(rest)
+ self.assertEqual(scap['parameters'], der_encoder(scap_p))
+ self.assertIn('parameters', scap_p.prettyPrint())
if attr['attrType'] == rfc5751.id_aa_encrypKeyPref:
ekp_issuer_serial = attr['attrValues'][0]['issuerAndSerialNumber']
- assert ekp_issuer_serial['serialNumber'] == 173360179
+
+ self.assertEqual(173360179, ekp_issuer_serial['serialNumber'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5752.py b/tests/test_rfc5752.py
new file mode 100644
index 0000000..7677632
--- /dev/null
+++ b/tests/test_rfc5752.py
@@ -0,0 +1,207 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc4055
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5752
+
+
+class MultipleSignaturesTestCase(unittest.TestCase):
+ pem_text = """\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+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.SignedAttributes()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+
+ layers = { }
+ layers.update(rfc5652.cmsContentTypesMap)
+
+ getNextLayer = {
+ rfc5652.id_ct_contentInfo: lambda x: x['contentType'],
+ rfc5652.id_signedData: lambda x: x['encapContentInfo']['eContentType'],
+ rfc5652.id_data: lambda x: None
+ }
+
+ getNextSubstrate = {
+ rfc5652.id_ct_contentInfo: lambda x: x['content'],
+ rfc5652.id_signedData: lambda x: x['encapContentInfo']['eContent'],
+ rfc5652.id_data: lambda x: None
+ }
+
+ next_layer = rfc5652.id_ct_contentInfo
+ while not next_layer == rfc5652.id_data:
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=layers[next_layer])
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ if next_layer == rfc5652.id_signedData:
+ signerInfos = asn1Object['signerInfos']
+
+ substrate = getNextSubstrate[next_layer](asn1Object)
+ next_layer = getNextLayer[next_layer](asn1Object)
+
+ found_mult_sig1 = False
+ for attr in signerInfos[0]['signedAttrs']:
+ if attr['attrType'] in rfc5652.cmsAttributesMap:
+ av, rest = der_decoder(
+ attr['attrValues'][0],
+ asn1Spec=rfc5652.cmsAttributesMap[attr['attrType']])
+
+ self.assertFalse(rest)
+ self.assertTrue(av.prettyPrint())
+ self.assertEqual(attr['attrValues'][0], der_encoder(av))
+
+ if attr['attrType'] == rfc5752.id_aa_multipleSignatures:
+ self.assertEqual(
+ av['bodyHashAlg']['algorithm'], rfc4055.id_sha384)
+
+ self.assertEqual(
+ 'dfaf6c0a',
+ av['signAttrsHash']['hash'].prettyPrint()[2:10])
+
+ found_mult_sig1 = True
+
+ found_mult_sig2 = False
+ for attr in signerInfos[1]['signedAttrs']:
+ if attr['attrType'] in rfc5652.cmsAttributesMap:
+ av, rest = der_decoder(
+ attr['attrValues'][0],
+ asn1Spec=rfc5652.cmsAttributesMap[attr['attrType']])
+
+ self.assertFalse(rest)
+ self.assertTrue(av.prettyPrint())
+ self.assertEqual(attr['attrValues'][0], der_encoder(av))
+
+ if attr['attrType'] == rfc5752.id_aa_multipleSignatures:
+ self.assertEqual(
+ av['bodyHashAlg']['algorithm'], rfc4055.id_sha256)
+
+ self.assertEqual(
+ '7329527d',
+ av['signAttrsHash']['hash'].prettyPrint()[2:10])
+
+ found_mult_sig2 = True
+
+ self.assertTrue(found_mult_sig1)
+ self.assertTrue(found_mult_sig2)
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=rfc5652.ContentInfo(), decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ found_mult_sig1 = False
+ for attr in asn1Object['content']['signerInfos'][0]['signedAttrs']:
+ if attr['attrType'] == rfc5752.id_aa_multipleSignatures:
+ av = attr['attrValues'][0]
+
+ self.assertEqual(
+ av['bodyHashAlg']['algorithm'], rfc4055.id_sha384)
+
+ self.assertEqual(
+ 'dfaf6c0a',
+ av['signAttrsHash']['hash'].prettyPrint()[2:10])
+
+ found_mult_sig1 = True
+
+ found_mult_sig2 = False
+ for attr in asn1Object['content']['signerInfos'][1]['signedAttrs']:
+ if attr['attrType'] == rfc5752.id_aa_multipleSignatures:
+ av = attr['attrValues'][0]
+
+ self.assertEqual(
+ av['bodyHashAlg']['algorithm'], rfc4055.id_sha256)
+
+ self.assertEqual(
+ '7329527d',
+ av['signAttrsHash']['hash'].prettyPrint()[2:10])
+
+ found_mult_sig2 = True
+
+ self.assertTrue(found_mult_sig1)
+ self.assertTrue(found_mult_sig2)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ import sys
+
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5753.py b/tests/test_rfc5753.py
new file mode 100644
index 0000000..7bb44ef
--- /dev/null
+++ b/tests/test_rfc5753.py
@@ -0,0 +1,129 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc3565
+from pyasn1_modules import rfc5480
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5753
+
+
+class EnvelopedDataTestCase(unittest.TestCase):
+ pem_text = """\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+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_envelopedData, asn1Object['contentType'])
+
+ ed, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.EnvelopedData())
+ self.assertFalse(rest)
+ self.assertTrue(ed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ed))
+
+ opk_ai_p = rfc5480.ECParameters()
+ opk_ai_p['namedCurve'] = rfc5480.secp384r1
+
+ kwai = rfc5753.KeyWrapAlgorithm()
+ kwai['algorithm'] = rfc3565.id_aes256_wrap
+
+ ukm_found = False
+ self.assertEqual(ed['version'], rfc5652.CMSVersion(value=2))
+ for ri in ed['recipientInfos']:
+ self.assertEqual(ri['kari']['version'], rfc5652.CMSVersion(value=3))
+ opk_alg = ri['kari']['originator']['originatorKey']['algorithm']
+ self.assertEqual(opk_alg['algorithm'], rfc5753.id_ecPublicKey)
+ self.assertEqual(opk_alg['parameters'], der_encoder(opk_ai_p))
+ kek_alg = ri['kari']['keyEncryptionAlgorithm']
+ self.assertEqual(kek_alg['algorithm'], rfc5753.dhSinglePass_stdDH_sha384kdf_scheme)
+ self.assertEqual(kek_alg['parameters'], der_encoder(kwai))
+ ukm = ri['kari']['ukm']
+ self.assertEqual(ukm, rfc5652.UserKeyingMaterial(hexValue='52464335373533'))
+ ukm_found = True
+
+ self.assertTrue(ukm_found)
+
+ def testOpenTypes(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ assert asn1Object['contentType'] == rfc5652.id_envelopedData
+ ed = asn1Object['content']
+
+ ukm_found = False
+ self.assertEqual(ed['version'], rfc5652.CMSVersion(value=2))
+ for ri in ed['recipientInfos']:
+ self.assertEqual(ri['kari']['version'], rfc5652.CMSVersion(value=3))
+ opk_alg = ri['kari']['originator']['originatorKey']['algorithm']
+ self.assertEqual(opk_alg['algorithm'], rfc5753.id_ecPublicKey)
+ self.assertEqual(opk_alg['parameters']['namedCurve'], rfc5480.secp384r1)
+ kek_alg = ri['kari']['keyEncryptionAlgorithm']
+ self.assertEqual(kek_alg['algorithm'], rfc5753.dhSinglePass_stdDH_sha384kdf_scheme)
+ self.assertEqual(kek_alg['parameters']['algorithm'], rfc3565.id_aes256_wrap)
+ ukm = ri['kari']['ukm']
+ self.assertEqual(ukm, rfc5652.UserKeyingMaterial(hexValue='52464335373533'))
+ ukm_found = True
+
+ self.assertTrue(ukm_found)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5755.py b/tests/test_rfc5755.py
index a41f0f9..cf4a05f 100644
--- a/tests/test_rfc5755.py
+++ b/tests/test_rfc5755.py
@@ -5,11 +5,11 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.compat.octets import str2octs
from pyasn1_modules import pem
@@ -17,12 +17,6 @@ from pyasn1_modules import rfc5280
from pyasn1_modules import rfc5755
from pyasn1_modules import rfc3114
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class AttributeCertificateTestCase(unittest.TestCase):
pem_text = """\
@@ -50,42 +44,51 @@ Q4eikPk4LQey
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['acinfo']['version'] == 1
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(1, asn1Object['acinfo']['version'])
count = 0
+
for attr in asn1Object['acinfo']['attributes']:
- assert attr['type'] in rfc5280.certificateAttributesMap.keys()
- av, rest = der_decode(attr['values'][0],
+ self.assertIn(attr['type'], rfc5280.certificateAttributesMap)
+
+ av, rest = der_decoder(
+ attr['values'][0],
asn1Spec=rfc5280.certificateAttributesMap[attr['type']])
- assert not rest
- assert av.prettyPrint()
- assert der_encode(av) == attr['values'][0]
+
+ self.assertFalse(rest)
+ self.assertTrue(av.prettyPrint())
+ self.assertEqual(attr['values'][0], der_encoder(av))
+
count += 1
- assert count == 5
+ self.assertEqual(5, count)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
- assert asn1Object['acinfo']['version'] == 1
+ asn1Object, rest = der_decoder(substrate,
+ asn1Spec=self.asn1Spec,
+ decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(1, asn1Object['acinfo']['version'])
count = 0
+
for attr in asn1Object['acinfo']['attributes']:
- assert attr['type'] in rfc5280.certificateAttributesMap.keys()
+ self.assertIn(attr['type'], rfc5280.certificateAttributesMap)
count += 1
if attr['type'] == rfc5755.id_aca_authenticationInfo:
- assert attr['values'][0]['authInfo'] == str2octs('password')
+ self.assertEqual(
+ str2octs('password'), attr['values'][0]['authInfo'])
+
+ self.assertEqual(5, count)
- assert count == 5
class CertificateWithClearanceTestCase(unittest.TestCase):
cert_pem_text = """\
@@ -117,74 +120,93 @@ FFMC7GjGtCeLtXYqWfBnRdK26dOaHLB2
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
clearance_found = False
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectDirectoryAttributes:
- assert extn['extnID'] in rfc5280.certificateExtensionsMap.keys()
- ev, rest = der_decode(extn['extnValue'],
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
for attr in ev:
if attr['type'] == rfc5755.id_at_clearance:
- assert attr['type'] in rfc5280.certificateAttributesMap.keys()
- av, rest = der_decode(attr['values'][0],
+ self.assertIn(attr['type'], rfc5280.certificateAttributesMap)
+
+ av, rest = der_decoder(
+ attr['values'][0],
asn1Spec=rfc5280.certificateAttributesMap[attr['type']])
- assert av['policyId'] == rfc3114.id_tsp_TEST_Whirlpool
+
+ self.assertEqual(rfc3114.id_tsp_TEST_Whirlpool, av['policyId'])
+
for cat in av['securityCategories']:
- assert cat['type'] == rfc3114.id_tsp_TEST_Whirlpool_Categories
- assert cat['type'] in rfc5755.securityCategoryMap.keys()
- catv, rest = der_decode(cat['value'],
+ self.assertEqual(
+ rfc3114.id_tsp_TEST_Whirlpool_Categories, cat['type'])
+ self.assertIn(
+ cat['type'], rfc5755.securityCategoryMap)
+ catv, rest = der_decoder(
+ cat['value'],
asn1Spec=rfc5755.securityCategoryMap[cat['type']])
- assert u'USE ONLY' in catv[0]
+
+ self.assertIn('USE ONLY', catv[0])
+
clearance_found = True
- assert clearance_found
+ self.assertTrue(clearance_found)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
clearance_found = False
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectDirectoryAttributes:
- assert extn['extnID'] in rfc5280.certificateExtensionsMap.keys()
- ev, rest = der_decode(extn['extnValue'],
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']],
decodeOpenTypes=True)
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
for attr in ev:
if attr['type'] == rfc5755.id_at_clearance:
spid = rfc3114.id_tsp_TEST_Whirlpool
catid = rfc3114.id_tsp_TEST_Whirlpool_Categories
- assert attr['values'][0]['policyId'] == spid
+
+ self.assertEqual(spid, attr['values'][0]['policyId'])
+
for cat in attr['values'][0]['securityCategories']:
- assert cat['type'] == catid
- assert u'USE ONLY' in cat['value'][0]
+ self.assertEqual(catid, cat['type'])
+ self.assertIn( u'USE ONLY', cat['value'][0])
+
clearance_found = True
- assert clearance_found
+ self.assertTrue(clearance_found)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5913.py b/tests/test_rfc5913.py
index f140d92..ef59086 100644
--- a/tests/test_rfc5913.py
+++ b/tests/test_rfc5913.py
@@ -5,11 +5,11 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
@@ -17,11 +17,6 @@ from pyasn1_modules import rfc5913
from pyasn1_modules import rfc5755
from pyasn1_modules import rfc3114
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class ClearanceTestCase(unittest.TestCase):
cert_pem_text = """\
@@ -51,62 +46,75 @@ AgTwMBEGCyqGSIb3DQEJEAcBAwIF4DAKBggqhkjOPQQDAwNnADBkAjAZSD+BVqzc
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
cat_value_found = False
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5913.id_pe_clearanceConstraints:
- assert extn['extnID'] in rfc5280.certificateExtensionsMap.keys()
- ev, rest = der_decode(extn['extnValue'],
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
for c in ev:
if c['policyId'] == rfc3114.id_tsp_TEST_Whirlpool:
for sc in c['securityCategories']:
- assert sc['type'] in rfc5755.securityCategoryMap.keys()
- scv, rest = der_decode(sc['value'],
+ self.assertIn(sc['type'], rfc5755.securityCategoryMap)
+
+ scv, rest = der_decoder(
+ sc['value'],
asn1Spec=rfc5755.securityCategoryMap[sc['type']])
+
for cat in scv:
- assert u'USE ONLY' in cat
+ self.assertIn('USE ONLY', cat)
cat_value_found = True
- assert cat_value_found
+ self.assertTrue(cat_value_found)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
cat_value_found = False
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5913.id_pe_clearanceConstraints:
- assert extn['extnID'] in rfc5280.certificateExtensionsMap.keys()
- ev, rest = der_decode(extn['extnValue'],
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']],
decodeOpenTypes=True)
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
for c in ev:
if c['policyId'] == rfc3114.id_tsp_TEST_Whirlpool:
for sc in c['securityCategories']:
- assert sc['type'] in rfc5755.securityCategoryMap.keys()
+ self.assertIn(sc['type'], rfc5755.securityCategoryMap)
for cat in sc['value']:
- assert u'USE ONLY' in cat
+ self.assertIn('USE ONLY', cat)
cat_value_found = True
- assert cat_value_found
+ self.assertTrue(cat_value_found)
+
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc5914.py b/tests/test_rfc5914.py
index 3fc5df9..3a70ec8 100644
--- a/tests/test_rfc5914.py
+++ b/tests/test_rfc5914.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5914
from pyasn1_modules import rfc5652
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class TrustAnchorListTestCase(unittest.TestCase):
trust_anchor_list_pem_text = """\
@@ -63,18 +58,19 @@ IEVDQyBTZWN1cmUgU2VydmVyIENBggIFIIICZW4=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.trust_anchor_list_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5914.id_ct_trustAnchorList, asn1Object['contentType'])
- assert asn1Object['contentType'] == rfc5914.id_ct_trustAnchorList
- tal, rest = der_decode(asn1Object['content'], rfc5914.TrustAnchorList())
- assert not rest
- assert tal.prettyPrint()
- assert der_encode(tal) == asn1Object['content']
+ tal, rest = der_decoder(asn1Object['content'], rfc5914.TrustAnchorList())
- assert sum (1 for _ in tal) == 3
+ self.assertFalse(rest)
+ self.assertTrue(tal.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(tal))
+ self.assertEqual(3, sum(1 for _ in tal))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc5915.py b/tests/test_rfc5915.py
index bcb8198..6e54e5a 100644
--- a/tests/test_rfc5915.py
+++ b/tests/test_rfc5915.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5915
from pyasn1_modules import rfc5480
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class MUDCertTestCase(unittest.TestCase):
private_key_pem_text = """\
@@ -34,18 +29,17 @@ yDYOFDuqz/C2jyEwqgWCRyxyohuJXtk=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.private_key_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert asn1Object['parameters']['namedCurve'] == rfc5480.secp384r1
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(
+ rfc5480.secp384r1, asn1Object['parameters']['namedCurve'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5916.py b/tests/test_rfc5916.py
index 2e7ba7f..a653b8c 100644
--- a/tests/test_rfc5916.py
+++ b/tests/test_rfc5916.py
@@ -5,23 +5,17 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc5916
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class DeviceCertTestCase(unittest.TestCase):
cert_pem_text = """\
@@ -47,64 +41,67 @@ pogu5Q9Vp28CMQC5YVF8dShC1tk9YImRftiVl8C6pbj//1K/+MwmR6nRk/WU+hKl
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
found_dev_owner = False
- der_dev_own_oid = der_encode(univ.ObjectIdentifier('1.3.6.1.4.1.22112.48.24'))
+ der_dev_own_oid = der_encoder(univ.ObjectIdentifier('1.3.6.1.4.1.22112.48.24'))
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectDirectoryAttributes:
- assert extn['extnID'] in rfc5280.certificateExtensionsMap.keys()
- ev, rest = der_decode(extn['extnValue'],
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
for attr in ev:
if attr['type'] == rfc5916.id_deviceOwner:
- assert attr['values'][0] == der_dev_own_oid
+ self.assertEqual(der_dev_own_oid, attr['values'][0])
found_dev_owner = True
- assert found_dev_owner
+ self.assertTrue(found_dev_owner)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate,
+ asn1Spec=self.asn1Spec,
+ decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
found_dev_owner = False
dev_own_oid = univ.ObjectIdentifier('1.3.6.1.4.1.22112.48.24')
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectDirectoryAttributes:
- assert extn['extnID'] in rfc5280.certificateExtensionsMap.keys()
- ev, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']],
- decodeOpenTypes=True)
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+ ev, rest = der_decoder(
+ extn['extnValue'],
+ asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']],
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
for attr in ev:
if attr['type'] == rfc5916.id_deviceOwner:
- assert attr['values'][0] == dev_own_oid
+ self.assertEqual(dev_own_oid, attr['values'][0])
found_dev_owner = True
- assert found_dev_owner
+ self.assertTrue(found_dev_owner)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5917.py b/tests/test_rfc5917.py
index 459895d..1023fb8 100644
--- a/tests/test_rfc5917.py
+++ b/tests/test_rfc5917.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc5917
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class ClearanceSponsorTestCase(unittest.TestCase):
cert_pem_text = """\
@@ -51,59 +46,71 @@ FFMC7GjGtCeLtXYqWfBnRdK26dOaHLB2
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
cs = rfc5917.DirectoryString()
cs['utf8String'] = u'Human Resources Department'
- encoded_cs = der_encode(cs)
+ encoded_cs = der_encoder(cs)
clearance_sponsor_found = False
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectDirectoryAttributes:
- assert extn['extnID'] in rfc5280.certificateExtensionsMap.keys()
- ev, rest = der_decode(extn['extnValue'],
+
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
for attr in ev:
if attr['type'] == rfc5917.id_clearanceSponsor:
- assert attr['values'][0] == encoded_cs
+ self.assertEqual(encoded_cs, attr['values'][0])
clearance_sponsor_found = True
- assert clearance_sponsor_found
+ self.assertTrue(clearance_sponsor_found)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
clearance_sponsor_found = False
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectDirectoryAttributes:
- assert extn['extnID'] in rfc5280.certificateExtensionsMap.keys()
- ev, rest = der_decode(extn['extnValue'],
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']],
decodeOpenTypes=True)
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
for attr in ev:
if attr['type'] == rfc5917.id_clearanceSponsor:
hrd = u'Human Resources Department'
- assert attr['values'][0]['utf8String'] == hrd
+
+ self.assertEqual(hrd, attr['values'][0]['utf8String'])
+
clearance_sponsor_found = True
- assert clearance_sponsor_found
+ self.assertTrue(clearance_sponsor_found)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc5924.py b/tests/test_rfc5924.py
index ca623fa..f1ae64a 100644
--- a/tests/test_rfc5924.py
+++ b/tests/test_rfc5924.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc5924
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class SIPDomainCertTestCase(unittest.TestCase):
cert_pem_text = """\
@@ -44,30 +39,36 @@ UwZ6TjS0Rfr+dRvlyilVjP+hPVwbyb7ZOSZR6zk=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
found_kp_sipDomain = False
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_extKeyUsage:
- assert extn['extnID'] in rfc5280.certificateExtensionsMap.keys()
- ev, rest = der_decode(extn['extnValue'],
+ self.assertIn(
+ extn['extnID'], rfc5280.certificateExtensionsMap)
+
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
- assert rfc5924.id_kp_sipDomain in ev
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
+ self.assertIn(rfc5924.id_kp_sipDomain, ev)
+
found_kp_sipDomain = True
- assert found_kp_sipDomain
+ self.assertTrue(found_kp_sipDomain)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5934.py b/tests/test_rfc5934.py
index 662ccf1..ba18b56 100644
--- a/tests/test_rfc5934.py
+++ b/tests/test_rfc5934.py
@@ -6,11 +6,11 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
@@ -18,12 +18,6 @@ from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc5934
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class TAMPStatusResponseTestCase(unittest.TestCase):
tsr_pem_text = """\
@@ -156,44 +150,48 @@ iPxQyqz7LIQe9/5ynJV5/CPUDBL9QK2vSCOQaihWCg==
next_layer = rfc5652.id_ct_contentInfo
while next_layer:
- asn1Object, rest = der_decode(substrate, asn1Spec=layers[next_layer])
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=layers[next_layer])
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
substrate = getNextSubstrate[next_layer](asn1Object)
next_layer = getNextLayer[next_layer](asn1Object)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.tsr_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=rfc5652.ContentInfo(),
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=rfc5652.ContentInfo(), decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
eci = asn1Object['content']['encapContentInfo']
- assert eci['eContentType'] in rfc5652.cmsContentTypesMap.keys()
- assert eci['eContentType'] == rfc5934.id_ct_TAMP_statusResponse
- tsr, rest = der_decode(eci['eContent'],
+
+ self.assertIn(eci['eContentType'], rfc5652.cmsContentTypesMap)
+ self.assertEqual(rfc5934.id_ct_TAMP_statusResponse, eci['eContentType'])
+
+ tsr, rest = der_decoder(
+ eci['eContent'],
asn1Spec=rfc5652.cmsContentTypesMap[eci['eContentType']],
decodeOpenTypes=True)
- assert not rest
- assert tsr.prettyPrint()
- assert der_encode(tsr) == eci['eContent']
- assert tsr['version'] == 2
- assert tsr['query']['target'] == univ.Null("")
- assert tsr['query']['seqNum'] == 1568307071
- assert tsr['usesApex'] == False
+ self.assertFalse(rest)
+ self.assertTrue(tsr.prettyPrint())
+ self.assertEqual(eci['eContent'], der_encoder(tsr))
+ self.assertEqual(2, tsr['version'])
+ self.assertEqual(univ.Null(""), tsr['query']['target'])
+ self.assertEqual(1568307071, tsr['query']['seqNum'])
+ self.assertFalse(tsr['usesApex'])
count = 0
+
for tai in tsr['response']['verboseResponse']['taInfo']:
count += 1
- assert tai['taInfo']['version'] == 1
+ self.assertEqual(1, tai['taInfo']['version'])
- assert count == 3
+ self.assertEqual(3, count)
class TrustAnchorUpdateTestCase(unittest.TestCase):
@@ -257,48 +255,45 @@ ZidB8vj4jIZT3S2gqWhtBLMUc11j+kWlXEZEigSL8WgCbAu7lqhItMwz2dy4C5aAWq8r"""
next_layer = rfc5652.id_ct_contentInfo
while next_layer:
- asn1Object, rest = der_decode(substrate, asn1Spec=layers[next_layer])
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=layers[next_layer])
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
substrate = getNextSubstrate[next_layer](asn1Object)
next_layer = getNextLayer[next_layer](asn1Object)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.tau_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=rfc5652.ContentInfo(),
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=rfc5652.ContentInfo(),
decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
eci = asn1Object['content']['encapContentInfo']
- assert eci['eContentType'] in rfc5652.cmsContentTypesMap.keys()
- assert eci['eContentType'] == rfc5934.id_ct_TAMP_update
- tau, rest = der_decode(eci['eContent'],
+ self.assertIn(eci['eContentType'], rfc5652.cmsContentTypesMap)
+ self.assertEqual(rfc5934.id_ct_TAMP_update, eci['eContentType'])
+
+ tau, rest = der_decoder(
+ eci['eContent'],
asn1Spec=rfc5652.cmsContentTypesMap[eci['eContentType']],
decodeOpenTypes=True)
- assert not rest
- assert tau.prettyPrint()
- assert der_encode(tau) == eci['eContent']
-
- assert tau['version'] == 2
- assert tau['msgRef']['target'] == univ.Null("")
- assert tau['msgRef']['seqNum'] == 1568307088
- count = 0
- for u in tau['updates']:
- count += 1
-
- assert count == 1
+ self.assertFalse(rest)
+ self.assertTrue(tau.prettyPrint())
+ self.assertEqual(eci['eContent'], der_encoder(tau))
+ self.assertEqual(2, tau['version'])
+ self.assertEqual(univ.Null(""), tau['msgRef']['target'])
+ self.assertEqual(1568307088, tau['msgRef']['seqNum'])
+ self.assertEqual(1, len(tau['updates']))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5940.py b/tests/test_rfc5940.py
index 293b565..d55ba6e 100644
--- a/tests/test_rfc5940.py
+++ b/tests/test_rfc5940.py
@@ -5,11 +5,10 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-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.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc2560
@@ -17,11 +16,6 @@ from pyasn1_modules import rfc5940
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc5280
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class CRLandOCSPResponseTestCase(unittest.TestCase):
pem_text = """\
@@ -73,61 +67,75 @@ ttTMEpl2prH8bbwo1g==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ sd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.SignedData())
- assert asn1Object['contentType'] == rfc5652.id_signedData
- sd, rest = der_decode(asn1Object['content'],
- asn1Spec=rfc5652.SignedData())
- assert sd.prettyPrint()
+ self.assertTrue(sd.prettyPrint())
+
+ self.assertEqual(
+ rfc5652.id_data, sd['encapContentInfo']['eContentType'])
+ self.assertTrue(sd['encapContentInfo']['eContent'])
- assert sd['encapContentInfo']['eContentType'] == rfc5652.id_data
- assert sd['encapContentInfo']['eContent']
v2 = rfc5280.Version(value='v2')
- assert sd['crls'][0]['crl']['tbsCertList']['version'] == v2
+
+ self.assertEqual(v2, sd['crls'][0]['crl']['tbsCertList']['version'])
+
ocspr_oid = rfc5940.id_ri_ocsp_response
- assert sd['crls'][1]['other']['otherRevInfoFormat'] == ocspr_oid
- ocspr, rest = der_decode(sd['crls'][1]['other']['otherRevInfo'],
+ self.assertEqual(ocspr_oid, sd['crls'][1]['other']['otherRevInfoFormat'])
+
+ ocspr, rest = der_decoder(
+ sd['crls'][1]['other']['otherRevInfo'],
asn1Spec=rfc5940.OCSPResponse())
- assert ocspr.prettyPrint()
+
+ self.assertTrue(ocspr.prettyPrint())
+
success = rfc2560.OCSPResponseStatus(value='successful')
- assert ocspr['responseStatus'] == success
+
+ self.assertEqual(success, ocspr['responseStatus'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] == rfc5652.id_signedData
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
sd_eci = asn1Object['content']['encapContentInfo']
- assert sd_eci['eContentType'] == rfc5652.id_data
- assert sd_eci['eContent'].hasValue()
+
+ self.assertEqual(rfc5652.id_data, sd_eci['eContentType'])
+ self.assertTrue(sd_eci['eContent'].hasValue())
for ri in asn1Object['content']['crls']:
if ri.getName() == 'crl':
v2 = rfc5280.Version(value='v2')
- assert ri['crl']['tbsCertList']['version'] == v2
+ self.assertEqual(v2, ri['crl']['tbsCertList']['version'])
+
if ri.getName() == 'other':
ori = ri['other']
ocspr_oid = rfc5940.id_ri_ocsp_response
- assert ori['otherRevInfoFormat'] == ocspr_oid
+
+ self.assertEqual(ocspr_oid, ori['otherRevInfoFormat'])
+
ocspr_status = ori['otherRevInfo']['responseStatus']
success = rfc2560.OCSPResponseStatus(value='successful')
- assert ocspr_status == success
+
+ self.assertEqual(success, ocspr_status)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5958.py b/tests/test_rfc5958.py
index a38a696..980a11e 100644
--- a/tests/test_rfc5958.py
+++ b/tests/test_rfc5958.py
@@ -5,12 +5,11 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
@@ -18,11 +17,6 @@ from pyasn1_modules import rfc5652
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 = """\
@@ -36,15 +30,19 @@ Z9w7lshQhqowtrbLDFw4rXAxZuE=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.priv_key_pem_text)
- asn1Object, rest = der_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_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(
+ rfc8410.id_Ed25519, asn1Object['privateKeyAlgorithm']['algorithm'])
+ self.assertTrue(asn1Object['privateKey'].isValue)
+ self.assertEqual(
+ "0x0420d4ee", asn1Object['privateKey'].prettyPrint()[0:10])
+ self.assertTrue(asn1Object['publicKey'].isValue)
+ self.assertEqual(
+ "1164575857", asn1Object['publicKey'].prettyPrint()[0:10])
+ self.assertEqual(substrate, der_encoder(asn1Object))
class PrivateKeyOpenTypesTestCase(unittest.TestCase):
@@ -59,23 +57,28 @@ YWlyc4EhABm/RAlphM3+hUG6wWfcO5bIUIaqMLa2ywxcOK1wMWbh
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.asymmetric_key_pkg_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertIn(
+ rfc5958.id_ct_KP_aKeyPackage, rfc5652.cmsContentTypesMap)
- assert rfc5958.id_ct_KP_aKeyPackage in rfc5652.cmsContentTypesMap.keys()
oneKey = asn1Object['content'][0]
- assert oneKey['privateKeyAlgorithm']['algorithm'] == rfc8410.id_Ed25519
+
+ self.assertEqual(
+ rfc8410.id_Ed25519, oneKey['privateKeyAlgorithm']['algorithm'])
+
pkcs_9_at_friendlyName = univ.ObjectIdentifier('1.2.840.113549.1.9.9.20')
- assert oneKey['attributes'][0]['attrType'] == pkcs_9_at_friendlyName
+
+ self.assertEqual(
+ pkcs_9_at_friendlyName, oneKey['attributes'][0]['attrType'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc5990.py b/tests/test_rfc5990.py
index 9f7e45b..7d51d67 100755
--- a/tests/test_rfc5990.py
+++ b/tests/test_rfc5990.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc5990
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class RSAKEMTestCase(unittest.TestCase):
pem_text = """\
@@ -32,51 +27,61 @@ YIZIAWUDBAIBAgEQMAsGCWCGSAFlAwQBBQ==
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5990.id_rsa_kem, asn1Object['algorithm'])
- assert asn1Object['algorithm'] == rfc5990.id_rsa_kem
- rsa_kem_p, rest = der_decode(asn1Object['parameters'],
+ rsa_kem_p, rest = der_decoder(
+ asn1Object['parameters'],
asn1Spec=rfc5280.algorithmIdentifierMap[rfc5990.id_rsa_kem])
- assert not rest
- assert rsa_kem_p.prettyPrint()
- assert der_encode(rsa_kem_p) == asn1Object['parameters']
- assert rsa_kem_p['kem']['algorithm'] == rfc5990.id_kem_rsa
- kem_rsa_p, rest = der_decode(rsa_kem_p['kem']['parameters'],
+ self.assertFalse(rest)
+ self.assertTrue(rsa_kem_p.prettyPrint())
+ self.assertEqual(asn1Object['parameters'], der_encoder(rsa_kem_p))
+ self.assertEqual(rfc5990.id_kem_rsa, rsa_kem_p['kem']['algorithm'])
+
+ kem_rsa_p, rest = der_decoder(
+ rsa_kem_p['kem']['parameters'],
asn1Spec=rfc5280.algorithmIdentifierMap[rfc5990.id_kem_rsa])
- assert not rest
- assert kem_rsa_p.prettyPrint()
- assert der_encode(kem_rsa_p) == rsa_kem_p['kem']['parameters']
- assert kem_rsa_p['keyLength'] == 16
- assert kem_rsa_p['keyDerivationFunction']['algorithm'] == rfc5990.id_kdf_kdf3
- kdf_p, rest = der_decode(kem_rsa_p['keyDerivationFunction']['parameters'],
+ self.assertFalse(rest)
+ self.assertTrue(kem_rsa_p.prettyPrint())
+ self.assertEqual(
+ rsa_kem_p['kem']['parameters'], der_encoder(kem_rsa_p))
+ self.assertEqual(16, kem_rsa_p['keyLength'])
+ self.assertEqual(
+ rfc5990.id_kdf_kdf3, kem_rsa_p['keyDerivationFunction']['algorithm'])
+
+ kdf_p, rest = der_decoder(
+ kem_rsa_p['keyDerivationFunction']['parameters'],
asn1Spec=rfc5280.algorithmIdentifierMap[rfc5990.id_kdf_kdf3])
- assert not rest
- assert kdf_p.prettyPrint()
- assert der_encode(kdf_p) == kem_rsa_p['keyDerivationFunction']['parameters']
+
+ self.assertFalse(rest)
+ self.assertTrue(kdf_p.prettyPrint())
+ self.assertEqual(
+ kem_rsa_p['keyDerivationFunction']['parameters'],
+ der_encoder(kdf_p))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert asn1Object['algorithm'] == rfc5990.id_rsa_kem
- assert asn1Object['parameters']['kem']['algorithm'] == rfc5990.id_kem_rsa
- assert asn1Object['parameters']['kem']['parameters']['keyLength'] == 16
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5990.id_rsa_kem, asn1Object['algorithm'])
+ self.assertEqual(
+ rfc5990.id_kem_rsa, asn1Object['parameters']['kem']['algorithm'])
+ self.assertEqual(
+ 16, asn1Object['parameters']['kem']['parameters']['keyLength'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc6010.py b/tests/test_rfc6010.py
index 072c1ac..1726a8d 100644
--- a/tests/test_rfc6010.py
+++ b/tests/test_rfc6010.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc6010
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class UnconstrainedCCCExtensionTestCase(unittest.TestCase):
unconstrained_pem_text = "MB0GCCsGAQUFBwESBBEwDzANBgsqhkiG9w0BCRABAA=="
@@ -29,19 +24,23 @@ class UnconstrainedCCCExtensionTestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.unconstrained_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert asn1Object['extnID'] == rfc6010.id_pe_cmsContentConstraints
- evalue, rest = der_decode(asn1Object['extnValue'],
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(
+ rfc6010.id_pe_cmsContentConstraints, asn1Object['extnID'])
+
+ evalue, rest = der_decoder(
+ asn1Object['extnValue'],
asn1Spec=rfc6010.CMSContentConstraints())
- assert not rest
- assert evalue.prettyPrint()
- assert der_encode(evalue) == asn1Object['extnValue']
- assert evalue[0]['contentType'] == rfc6010.id_ct_anyContentType
+ self.assertFalse(rest)
+ self.assertTrue(evalue.prettyPrint())
+ self.assertEqual(asn1Object['extnValue'], der_encoder(evalue))
+ self.assertEqual(
+ rfc6010.id_ct_anyContentType, evalue[0]['contentType'])
class ConstrainedCCCExtensionTestCase(unittest.TestCase):
@@ -57,21 +56,26 @@ KoZIhvcNAQkQDAsxEQwPa3RhLmV4YW1wbGUuY29tMA4GCSqGSIb3DQEHAQoBAQ==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.constrained_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(
+ rfc6010.id_pe_cmsContentConstraints, asn1Object['extnID'])
- assert asn1Object['extnID'] == rfc6010.id_pe_cmsContentConstraints
- evalue, rest = der_decode(asn1Object['extnValue'],
+ evalue, rest = der_decoder(
+ asn1Object['extnValue'],
asn1Spec=rfc6010.CMSContentConstraints())
- assert not rest
- assert evalue.prettyPrint()
- assert der_encode(evalue) == asn1Object['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(evalue.prettyPrint())
+ self.assertEqual(asn1Object['extnValue'], der_encoder(evalue))
constraint_count = 0
attribute_count = 0
cannot_count = 0
+
for ccc in evalue:
constraint_count += 1
if ccc['canSource'] == 1:
@@ -79,14 +83,16 @@ KoZIhvcNAQkQDAsxEQwPa3RhLmV4YW1wbGUuY29tMA4GCSqGSIb3DQEHAQoBAQ==
if ccc['attrConstraints'].hasValue():
for attr in ccc['attrConstraints']:
attribute_count += 1
- assert constraint_count == 4
- assert attribute_count == 3
- assert cannot_count == 1
+
+ self.assertEqual(4, constraint_count)
+ self.assertEqual(3, attribute_count)
+ self.assertEqual(1, cannot_count)
def testExtensionsMap(self):
substrate = pem.readBase64fromText(self.constrained_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert asn1Object['extnID'] in rfc5280.certificateExtensionsMap.keys()
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertIn(asn1Object['extnID'], rfc5280.certificateExtensionsMap)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc6019.py b/tests/test_rfc6019.py
index 46cd75d..2e08670 100644
--- a/tests/test_rfc6019.py
+++ b/tests/test_rfc6019.py
@@ -5,21 +5,15 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-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.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc6019
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class BinarySigningTimeTestCase(unittest.TestCase):
pem_text = "MBUGCyqGSIb3DQEJEAIuMQYCBFy/hlQ="
@@ -30,34 +24,33 @@ class BinarySigningTimeTestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc6019.id_aa_binarySigningTime, asn1Object['attrType'])
- assert asn1Object['attrType'] == rfc6019.id_aa_binarySigningTime
- bintime, rest = der_decode(asn1Object['attrValues'][0],
- asn1Spec=rfc6019.BinaryTime())
- assert bintime == 0x5cbf8654
+ bintime, rest = der_decoder(
+ asn1Object['attrValues'][0], asn1Spec=rfc6019.BinaryTime())
+
+ self.assertEqual(0x5cbf8654, bintime)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec,
+ decodeOpenTypes=True)
- assert asn1Object['attrType'] in rfc5652.cmsAttributesMap.keys()
- assert asn1Object['attrValues'][0] == 0x5cbf8654
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertIn(asn1Object['attrType'], rfc5652.cmsAttributesMap)
+ self.assertEqual(0x5cbf8654, asn1Object['attrValues'][0])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc6031.py b/tests/test_rfc6031.py
index 176285f..29a8d86 100644
--- a/tests/test_rfc6031.py
+++ b/tests/test_rfc6031.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc6031
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class SymmetricKeyPkgTestCase(unittest.TestCase):
key_pkg_pem_text = """\
@@ -34,50 +29,57 @@ DARIT1RQMCAGCyqGSIb3DQEJEAwLMREMD2t0YS5leGFtcGxlLmNvbQQEMTIzNA==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.key_pkg_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] in rfc5652.cmsContentTypesMap
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertIn(asn1Object['contentType'], rfc5652.cmsContentTypesMap)
+
asn1Spec = rfc5652.cmsContentTypesMap[asn1Object['contentType']]
- skp, rest = der_decode(asn1Object['content'], asn1Spec=asn1Spec)
- assert not rest
- assert skp.prettyPrint()
- assert der_encode(skp) == asn1Object['content']
+ skp, rest = der_decoder(asn1Object['content'], asn1Spec=asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(skp.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(skp))
for attr in skp['sKeyPkgAttrs']:
- assert attr['attrType'] in rfc6031.sKeyPkgAttributesMap.keys()
+ self.assertIn(attr['attrType'], rfc6031.sKeyPkgAttributesMap)
for osk in skp['sKeys']:
for attr in osk['sKeyAttrs']:
- assert attr['attrType'] in rfc6031.sKeyAttributesMap.keys()
+ self.assertIn(attr['attrType'], rfc6031.sKeyAttributesMap)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.key_pkg_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] in rfc5652.cmsContentTypesMap
- assert asn1Object['content'].hasValue()
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertIn(asn1Object['contentType'], rfc5652.cmsContentTypesMap)
+ self.assertTrue(asn1Object['content'].hasValue())
+
keypkg = asn1Object['content']
- assert keypkg['version'] == rfc6031.KeyPkgVersion().subtype(value='v1')
+
+ self.assertEqual(
+ rfc6031.KeyPkgVersion().subtype(value='v1'), keypkg['version'])
for attr in keypkg['sKeyPkgAttrs']:
- assert attr['attrType'] in rfc6031.sKeyPkgAttributesMap.keys()
- assert attr['attrValues'][0].prettyPrint()[:2] != '0x'
+ self.assertIn(attr['attrType'], rfc6031.sKeyPkgAttributesMap)
+ self.assertNotEqual('0x', attr['attrValues'][0].prettyPrint()[:2])
+
# decodeOpenTypes=True did not decode if the value is shown in hex ...
if attr['attrType'] == rfc6031.id_pskc_manufacturer:
attr['attrValues'][0] == 'Vigil Security LLC'
for osk in keypkg['sKeys']:
for attr in osk['sKeyAttrs']:
- assert attr['attrType'] in rfc6031.sKeyAttributesMap.keys()
- assert attr['attrValues'][0].prettyPrint()[:2] != '0x'
+ self.assertIn(attr['attrType'], rfc6031.sKeyAttributesMap)
+ self.assertNotEqual(
+ '0x', attr['attrValues'][0].prettyPrint()[:2])
+
# decodeOpenTypes=True did not decode if the value is shown in hex ...
if attr['attrType'] == rfc6031.id_pskc_issuer:
attr['attrValues'][0] == 'kta.example.com'
diff --git a/tests/test_rfc6032.py b/tests/test_rfc6032.py
index ad56823..287bad8 100644
--- a/tests/test_rfc6032.py
+++ b/tests/test_rfc6032.py
@@ -5,23 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.compat.octets import str2octs
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc6032
-from pyasn1_modules import rfc3565
-
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
class EncryptedKeyPkgTestCase(unittest.TestCase):
@@ -39,47 +32,62 @@ YIZIAWUCAQVCMRAEDnB0Zi1rZGMtODEyMzc0
def testDerCodec(self):
substrate = pem.readBase64fromText(self.encrypted_key_pkg_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
- assert asn1Object['contentType'] == rfc6032.id_ct_KP_encryptedKeyPkg
-
- content, rest = der_decode(asn1Object['content'], rfc6032.EncryptedKeyPackage())
- assert not rest
- assert content.prettyPrint()
- assert der_encode(content) == asn1Object['content']
- assert content.getName() == 'encrypted'
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(
+ rfc6032.id_ct_KP_encryptedKeyPkg, asn1Object['contentType'])
+
+ content, rest = der_decoder(
+ asn1Object['content'], rfc6032.EncryptedKeyPackage())
+
+ self.assertFalse(rest)
+ self.assertTrue(content.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(content))
+ self.assertEqual('encrypted', content.getName())
+
eci = content['encrypted']['encryptedContentInfo']
- assert eci['contentType'] == rfc6032.id_ct_KP_encryptedKeyPkg
+
+ self.assertEqual(
+ rfc6032.id_ct_KP_encryptedKeyPkg, eci['contentType'])
+
attrType = content['encrypted']['unprotectedAttrs'][0]['attrType']
- assert attrType == rfc6032.id_aa_KP_contentDecryptKeyID
+
+ self.assertEqual(rfc6032.id_aa_KP_contentDecryptKeyID, attrType)
attrVal0 = content['encrypted']['unprotectedAttrs'][0]['attrValues'][0]
- keyid, rest = der_decode(attrVal0, rfc6032.ContentDecryptKeyID())
- assert not rest
- assert keyid.prettyPrint()
- assert der_encode(keyid) == attrVal0
- assert keyid == b'ptf-kdc-812374'
+ keyid, rest = der_decoder(attrVal0, rfc6032.ContentDecryptKeyID())
+
+ self.assertFalse(rest)
+ self.assertTrue(keyid.prettyPrint())
+ self.assertEqual(attrVal0, der_encoder(keyid))
+ self.assertEqual(str2octs('ptf-kdc-812374'), keyid)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.encrypted_key_pkg_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] in rfc5652.cmsContentTypesMap
+ asn1Object, rest = der_decoder(substrate,
+ asn1Spec=self.asn1Spec,
+ decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertIn(asn1Object['contentType'], rfc5652.cmsContentTypesMap)
+
eci = asn1Object['content']['encrypted']['encryptedContentInfo']
- assert eci['contentType'] in rfc5652.cmsContentTypesMap
+
+ self.assertIn(eci['contentType'], rfc5652.cmsContentTypesMap)
for attr in asn1Object['content']['encrypted']['unprotectedAttrs']:
- assert attr['attrType'] in rfc5652.cmsAttributesMap.keys()
- assert attr['attrValues'][0].prettyPrint()[:2] != '0x'
+ self.assertIn(attr['attrType'], rfc5652.cmsAttributesMap)
+ self.assertNotEqual('0x', attr['attrValues'][0].prettyPrint()[:2])
+
if attr['attrType'] == rfc6032.id_aa_KP_contentDecryptKeyID:
- assert attr['attrValues'][0] == str2octs('ptf-kdc-812374')
+ self.assertEqual(str2octs(
+ 'ptf-kdc-812374'), attr['attrValues'][0])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc6120.py b/tests/test_rfc6120.py
index 820f7a3..bdedab8 100644
--- a/tests/test_rfc6120.py
+++ b/tests/test_rfc6120.py
@@ -5,21 +5,17 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+from pyasn1.compat.octets import str2octs
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc6120
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class XMPPCertificateTestCase(unittest.TestCase):
xmpp_server_cert_pem_text = """\
@@ -46,64 +42,74 @@ nOzhcMpnHs2U/eN0lHl/JNgnbftl6Dvnt59xdA==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.xmpp_server_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
count = 0
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectAltName:
- extnValue, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.SubjectAltName())
- assert not rest
- assert extnValue.prettyPrint()
- assert der_encode(extnValue) == extn['extnValue']
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.SubjectAltName())
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
+
for gn in extnValue:
if gn['otherName'].hasValue():
gn_on = gn['otherName']
if gn_on['type-id'] == rfc6120.id_on_xmppAddr:
- assert gn_on['type-id'] in rfc5280.anotherNameMap.keys()
+ self.assertIn(gn_on['type-id'], rfc5280.anotherNameMap)
+
spec = rfc5280.anotherNameMap[gn['otherName']['type-id']]
- on, rest = der_decode(gn_on['value'], asn1Spec=spec)
- assert not rest
- assert on.prettyPrint()
- assert der_encode(on) == gn_on['value']
- assert on == u'im.example.com'
+ on, rest = der_decoder(gn_on['value'], asn1Spec=spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(on.prettyPrint())
+ self.assertEqual(gn_on['value'], der_encoder(on))
+ self.assertEqual('im.example.com', on)
+
count += 1
- assert count == 1
+ self.assertEqual(1, count)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.xmpp_server_cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate,
+ asn1Spec=self.asn1Spec,
+ decodeOpenTypes=True)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
count = 0
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectAltName:
- extnValue, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.SubjectAltName(), decodeOpenTypes=True)
- assert not rest
- assert extnValue.prettyPrint()
- assert der_encode(extnValue) == extn['extnValue']
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.SubjectAltName(),
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
+
for gn in extnValue:
if gn['otherName'].hasValue():
if gn['otherName']['type-id'] == rfc6120.id_on_xmppAddr:
- assert gn['otherName']['value'] == u'im.example.com'
+ self.assertEqual(
+ 'im.example.com', gn['otherName']['value'])
count += 1
- assert count == 1
+ self.assertEqual(1, count)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc6187.py b/tests/test_rfc6187.py
index e821d77..75c1e91 100644
--- a/tests/test_rfc6187.py
+++ b/tests/test_rfc6187.py
@@ -5,19 +5,15 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc6187
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class SSHClientCertificateTestCase(unittest.TestCase):
cert_pem_text = """\
@@ -47,27 +43,28 @@ voNP0ODFhhlpFo6lwVHd8Gu+6hShC2PKdAfs4QFDS9ZKgQeZ
]
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
count = 0
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_extKeyUsage:
- extnValue, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.ExtKeyUsageSyntax())
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.ExtKeyUsageSyntax())
+
for oid in extnValue:
if oid in ssh_eku_oids:
count += 1
- assert count == 1
+ self.assertEqual(1, count)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc6210.py b/tests/test_rfc6210.py
index a04423a..54d8b66 100644
--- a/tests/test_rfc6210.py
+++ b/tests/test_rfc6210.py
@@ -5,22 +5,17 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc6210
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class AuthenticatedDataTestCase(unittest.TestCase):
pem_text = """\
@@ -43,33 +38,36 @@ EIbVbg2xql
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert asn1Object['contentType'] == rfc5652.id_ct_authData
- ad, rest = der_decode (asn1Object['content'], asn1Spec=rfc5652.AuthenticatedData())
- assert not rest
- assert ad.prettyPrint()
- assert der_encode(ad) == asn1Object['content']
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_ct_authData, asn1Object['contentType'])
- assert ad['version'] == 0
- assert ad['digestAlgorithm']['algorithm'] == rfc6210.id_alg_MD5_XOR_EXPERIMENT
+ ad, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.AuthenticatedData())
- mac_alg_p, rest = der_decode (ad['digestAlgorithm']['parameters'],
+ self.assertFalse(rest)
+ self.assertTrue(ad.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ad))
+ self.assertEqual(0, ad['version'])
+ self.assertEqual(
+ rfc6210.id_alg_MD5_XOR_EXPERIMENT, ad['digestAlgorithm']['algorithm'])
+
+ mac_alg_p, rest = der_decoder(
+ ad['digestAlgorithm']['parameters'],
asn1Spec=rfc5280.algorithmIdentifierMap[ad['digestAlgorithm']['algorithm']])
- assert not rest
- assert mac_alg_p.prettyPrint()
- assert der_encode(mac_alg_p) == ad['digestAlgorithm']['parameters']
- assert mac_alg_p.prettyPrint()[:10] == "0x01020304"
+ self.assertFalse(rest)
+ self.assertTrue(mac_alg_p.prettyPrint())
+ self.assertEqual(
+ ad['digestAlgorithm']['parameters'], der_encoder(mac_alg_p))
+ self.assertEqual("0x01020304", mac_alg_p.prettyPrint()[:10])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc6211.py b/tests/test_rfc6211.py
index 103838a..040b17a 100644
--- a/tests/test_rfc6211.py
+++ b/tests/test_rfc6211.py
@@ -5,23 +5,17 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
from pyasn1.type import univ
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc6211
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class SignedMessageTestCase(unittest.TestCase):
signed_message_pem_text = """\
@@ -58,60 +52,71 @@ fIUedSwWYrcSnSa1pq2s3Wue+pNBfecEjYECMGrUNu1UpWdafEJulP9Vz76qOPMa
def testDerCodec(self):
substrate = pem.readBase64fromText(self.signed_message_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
- sd, rest = der_decode(asn1Object['content'], asn1Spec=rfc5652.SignedData())
- assert not rest
- assert sd.prettyPrint()
- assert der_encode(sd) == asn1Object['content']
+ asn1Object, rest = der_decoder (substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
+ sd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.SignedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(sd.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(sd))
for sa in sd['signerInfos'][0]['signedAttrs']:
sat = sa['attrType']
sav0 = sa['attrValues'][0]
if sat in rfc6211.id_aa_cmsAlgorithmProtect:
- sav, rest = der_decode(sav0, asn1Spec=rfc6211.CMSAlgorithmProtection())
- assert not rest
- assert sav.prettyPrint()
- assert der_encode(sav) == sav0
+ sav, rest = der_decoder(
+ sav0, asn1Spec=rfc6211.CMSAlgorithmProtection())
+
+ self.assertFalse(rest)
+ self.assertTrue(sav.prettyPrint())
+ self.assertEqual(sav0, der_encoder(sav))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.signed_message_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
- assert asn1Object['contentType'] in rfc5652.cmsContentTypesMap.keys()
- assert asn1Object['contentType'] == rfc5652.id_signedData
+ self.assertIn(asn1Object['contentType'], rfc5652.cmsContentTypesMap)
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
sd = asn1Object['content']
- assert sd['version'] == rfc5652.CMSVersion().subtype(value='v1')
+
+ self.assertEqual(
+ rfc5652.CMSVersion().subtype(value='v1'), sd['version'])
ect = sd['encapContentInfo']['eContentType']
- assert ect in rfc5652.cmsContentTypesMap.keys()
- assert ect == rfc5652.id_data
+
+ self.assertIn(ect, rfc5652.cmsContentTypesMap)
+ self.assertEqual(rfc5652.id_data, ect)
for sa in sd['signerInfos'][0]['signedAttrs']:
if sa['attrType'] == rfc6211.id_aa_cmsAlgorithmProtect:
- assert sa['attrType'] in rfc5652.cmsAttributesMap.keys()
+ self.assertIn(sa['attrType'], rfc5652.cmsAttributesMap)
sav0 = sa['attrValues'][0]
digest_oid = univ.ObjectIdentifier('2.16.840.1.101.3.4.2.2')
sig_oid = univ.ObjectIdentifier('1.2.840.10045.4.3.3')
- assert sav0['digestAlgorithm']['algorithm'] == digest_oid
- assert sav0['signatureAlgorithm']['algorithm'] == sig_oid
+
+ self.assertEqual(
+ digest_oid, sav0['digestAlgorithm']['algorithm'])
+ self.assertEqual(
+ sig_oid, sav0['signatureAlgorithm']['algorithm'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc6402.py b/tests/test_rfc6402.py
index 1532b38..e970dfa 100755
--- a/tests/test_rfc6402.py
+++ b/tests/test_rfc6402.py
@@ -5,26 +5,19 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import char
from pyasn1.type import namedtype
from pyasn1.type import univ
from pyasn1_modules import pem
-from pyasn1_modules import rfc5280
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc6402
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class BackwardCompatibilityTestCase(unittest.TestCase):
pem_text = """\
@@ -69,10 +62,10 @@ xicQmJP+VoMHo/ZpjFY9fYCjNZUArgKsEwK/s+p9yrVVeB1Nf8Mn
next_layer = rfc5652.id_ct_contentInfo
while next_layer:
- asn1Object, rest = der_decode(substrate, asn1Spec=layers[next_layer])
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=layers[next_layer])
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
substrate = getNextSubstrate[next_layer](asn1Object)
next_layer = getNextLayer[next_layer](asn1Object)
@@ -113,43 +106,49 @@ xicQmJP+VoMHo/ZpjFY9fYCjNZUArgKsEwK/s+p9yrVVeB1Nf8Mn
openTypeMap.update(rfc6402.cmcControlAttributesMap)
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=rfc5652.ContentInfo(),
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=rfc5652.ContentInfo(), decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
eci = asn1Object['content']['encapContentInfo']
- assert eci['eContentType'] == rfc6402.id_cct_PKIData
+
+ self.assertEqual(rfc6402.id_cct_PKIData, eci['eContentType'])
+
substrate = eci['eContent']
- asn1Object, rest = der_decode(substrate,
- asn1Spec=rfc6402.PKIData(),
- openTypes=openTypeMap,
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=rfc6402.PKIData(), openTypes=openTypeMap,
decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for req in asn1Object['reqSequence']:
cr = req['tcr']['certificationRequest']
sig_alg = cr['signatureAlgorithm']
- assert sig_alg['algorithm'] in openTypeMap.keys()
- assert sig_alg['parameters'] == univ.Null("")
+
+ self.assertIn(sig_alg['algorithm'], openTypeMap)
+ self.assertEqual(univ.Null(""), sig_alg['parameters'])
cri = cr['certificationRequestInfo']
spki_alg = cri['subjectPublicKeyInfo']['algorithm']
- assert spki_alg['algorithm'] in openTypeMap.keys()
- assert spki_alg['parameters'] == univ.Null("")
+
+ self.assertIn(spki_alg['algorithm'], openTypeMap)
+ self.assertEqual(univ.Null(""), spki_alg['parameters'])
attrs = cr['certificationRequestInfo']['attributes']
for attr in attrs:
- assert attr['attrType'] in openTypeMap.keys()
+ self.assertIn( attr['attrType'], openTypeMap)
+
if attr['attrType'] == univ.ObjectIdentifier('1.3.6.1.4.1.311.13.2.3'):
- assert attr['attrValues'][0] == "6.2.9200.2"
+ self.assertEqual("6.2.9200.2", attr['attrValues'][0])
+
else:
- assert attr['attrValues'][0].hasValue()
+ self.assertTrue(attr['attrValues'][0].hasValue())
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc6482.py b/tests/test_rfc6482.py
index 731cbd9..c2f6a94 100644
--- a/tests/test_rfc6482.py
+++ b/tests/test_rfc6482.py
@@ -5,19 +5,15 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc6482
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class RPKIROATestCase(unittest.TestCase):
roa_pem_text = """\
@@ -59,7 +55,7 @@ IzU1
def testDerCodec(self):
substrate = pem.readBase64fromText(self.roa_pem_text)
- layers = { }
+ layers = {}
layers.update(rfc5652.cmsContentTypesMap)
getNextLayer = {
@@ -76,44 +72,45 @@ IzU1
next_layer = rfc5652.id_ct_contentInfo
while next_layer:
- asn1Object, rest = der_decode(substrate, asn1Spec=layers[next_layer])
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=layers[next_layer])
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
substrate = getNextSubstrate[next_layer](asn1Object)
next_layer = getNextLayer[next_layer](asn1Object)
- assert asn1Object['version'] == 0
- assert asn1Object['asID'] == 58363
+ self.assertEqual(0, asn1Object['version'])
+ self.assertEqual(58363, asn1Object['asID'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.roa_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=rfc5652.ContentInfo(),
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=rfc5652.ContentInfo(), decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
- oid = asn1Object['content']['encapContentInfo']['eContentType']
+ oid = asn1Object['content']['encapContentInfo']['eContentType']
substrate = asn1Object['content']['encapContentInfo']['eContent']
- assert oid in rfc5652.cmsContentTypesMap.keys()
- asn1Object, rest = der_decode(substrate,
- asn1Spec=rfc5652.cmsContentTypesMap[oid],
+
+ self.assertIn(oid, rfc5652.cmsContentTypesMap)
+
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=rfc5652.cmsContentTypesMap[oid],
decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
- assert asn1Object['version'] == 0
- assert asn1Object['asID'] == 58363
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(0, asn1Object['version'])
+ self.assertEqual(58363, asn1Object['asID'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc6486.py b/tests/test_rfc6486.py
index 70e9160..1e0075c 100644
--- a/tests/test_rfc6486.py
+++ b/tests/test_rfc6486.py
@@ -5,19 +5,15 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc6486
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class SignedManifestTestCase(unittest.TestCase):
manifest_pem_text = """\
@@ -61,8 +57,7 @@ C9ijmXiajracUe+7eCluqgXRE8yRtnscWoA/9fVFz1lPwgEeNHLoaK7Sqew=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.manifest_pem_text)
- layers = { }
- layers.update(rfc5652.cmsContentTypesMap)
+ layers = rfc5652.cmsContentTypesMap.copy()
getNextLayer = {
rfc5652.id_ct_contentInfo: lambda x: x['contentType'],
@@ -77,47 +72,51 @@ C9ijmXiajracUe+7eCluqgXRE8yRtnscWoA/9fVFz1lPwgEeNHLoaK7Sqew=
}
next_layer = rfc5652.id_ct_contentInfo
+
while next_layer:
- asn1Object, rest = der_decode(substrate, asn1Spec=layers[next_layer])
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=layers[next_layer])
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
substrate = getNextSubstrate[next_layer](asn1Object)
next_layer = getNextLayer[next_layer](asn1Object)
- assert asn1Object['version'] == 0
+ self.assertEqual(0, asn1Object['version'])
+
for f in asn1Object['fileList']:
- assert f['file'] == 'ZXSGBDBkL82TFGHuE4VOYtJP-E4.crl'
+ self.assertEqual('ZXSGBDBkL82TFGHuE4VOYtJP-E4.crl', f['file'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.manifest_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=rfc5652.ContentInfo(),
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=rfc5652.ContentInfo(), decodeOpenTypes=True)
- oid = asn1Object['content']['encapContentInfo']['eContentType']
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ oid = asn1Object['content']['encapContentInfo']['eContentType']
substrate = asn1Object['content']['encapContentInfo']['eContent']
- assert oid in rfc5652.cmsContentTypesMap.keys()
- asn1Object, rest = der_decode(substrate,
- asn1Spec=rfc5652.cmsContentTypesMap[oid],
+
+ self.assertIn(oid, rfc5652.cmsContentTypesMap)
+
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=rfc5652.cmsContentTypesMap[oid],
decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
- assert asn1Object['version'] == 0
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(0, asn1Object['version'])
+
for f in asn1Object['fileList']:
- assert f['file'] == 'ZXSGBDBkL82TFGHuE4VOYtJP-E4.crl'
+ self.assertEqual('ZXSGBDBkL82TFGHuE4VOYtJP-E4.crl', f['file'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc6487.py b/tests/test_rfc6487.py
index f9f30a2..9e42d07 100644
--- a/tests/test_rfc6487.py
+++ b/tests/test_rfc6487.py
@@ -5,19 +5,15 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc6487
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class CertificateWithManifestTestCase(unittest.TestCase):
rpki_cert_pem_text = """\
@@ -62,23 +58,26 @@ HDFd3u1ztO8WGjH/LOehoO30xsm52kbxZjc4SJWubgBgxTMIWyjPHbKqCF44NwYev/6eFcOC
]
substrate = pem.readBase64fromText(self.rpki_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
count = 0
+
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_pe_subjectInfoAccess:
- extnValue, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.SubjectInfoAccessSyntax())
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.SubjectInfoAccessSyntax())
for ad in extnValue:
if ad['accessMethod'] in access_methods:
uri = ad['accessLocation']['uniformResourceIdentifier']
- assert 'rpki.apnic.net' in uri
+ self.assertIn('rpki.apnic.net', uri)
count += 1
- assert count == 1
+ self.assertEqual(1, count)
+
class CertificateWithSignedObjectTestCase(unittest.TestCase):
rpki_cert_pem_text = """\
@@ -120,29 +119,28 @@ WYtY4rWNeHcfgNTz
]
substrate = pem.readBase64fromText(self.rpki_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
count = 0
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_pe_subjectInfoAccess:
- extnValue, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.SubjectInfoAccessSyntax())
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.SubjectInfoAccessSyntax())
for ad in extnValue:
if ad['accessMethod'] in access_methods:
uri = ad['accessLocation']['uniformResourceIdentifier']
- assert 'ca.rg.net' in uri
+ self.assertIn('ca.rg.net', uri)
count += 1
- assert count == 1
+ self.assertEqual(1, count)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc6664.py b/tests/test_rfc6664.py
index 38d0a54..83278a7 100644
--- a/tests/test_rfc6664.py
+++ b/tests/test_rfc6664.py
@@ -5,21 +5,16 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5480
-from pyasn1_modules import rfc5652
from pyasn1_modules import rfc5751
from pyasn1_modules import rfc6664
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class SMIMECapabilitiesTestCase(unittest.TestCase):
smime_capabilities_pem_text = """\
@@ -42,51 +37,52 @@ PQMBBwYFK4EEACIGBSuBBAAjMBoGCSqGSIb3DQEBCDANBglghkgBZQMEAgEFAA==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
- asn1Object, rest = der_decode (substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
count = 0
for cap in asn1Object:
if cap['capabilityID'] in rfc5751.smimeCapabilityMap.keys():
substrate = cap['parameters']
- cap_p, rest = der_decode (substrate,
- asn1Spec=rfc5751.smimeCapabilityMap[cap['capabilityID']])
- assert not rest
- assert cap_p.prettyPrint()
- assert der_encode(cap_p) == substrate
+ cap_p, rest = der_decoder(
+ substrate, asn1Spec=rfc5751.smimeCapabilityMap[cap['capabilityID']])
+ self.assertFalse(rest)
+ self.assertTrue(cap_p.prettyPrint())
+ self.assertEqual(substrate, der_encoder(cap_p))
count += 1
- assert count == 8
+ self.assertEqual(8, count)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
parameterValue = {
- rfc6664.rsaEncryption: lambda x: x['maxKeySize'],
- rfc6664.id_RSAES_OAEP: lambda x: x['maxKeySize'],
- rfc6664.id_RSASSA_PSS: lambda x: x['minKeySize'],
- rfc6664.id_dsa: lambda x: x['keySizes']['maxKeySize'],
+ rfc6664.rsaEncryption: lambda x: x['maxKeySize'],
+ rfc6664.id_RSAES_OAEP: lambda x: x['maxKeySize'],
+ rfc6664.id_RSASSA_PSS: lambda x: x['minKeySize'],
+ rfc6664.id_dsa: lambda x: x['keySizes']['maxKeySize'],
rfc6664.dhpublicnumber: lambda x: x['keyParams']['q'] % 1023,
rfc6664.id_ecPublicKey: lambda x: x[0]['namedCurve'],
- rfc6664.id_ecMQV: lambda x: x[1]['namedCurve'],
+ rfc6664.id_ecMQV: lambda x: x[1]['namedCurve'],
}
expectedValue = {
- rfc6664.rsaEncryption: 4096,
- rfc6664.id_RSAES_OAEP: 4096,
- rfc6664.id_RSASSA_PSS: 1024,
- rfc6664.id_dsa: 3072,
+ rfc6664.rsaEncryption: 4096,
+ rfc6664.id_RSAES_OAEP: 4096,
+ rfc6664.id_RSASSA_PSS: 1024,
+ rfc6664.id_dsa: 3072,
rfc6664.dhpublicnumber: 257,
rfc6664.id_ecPublicKey: rfc5480.secp256r1,
- rfc6664.id_ecMQV: rfc5480.secp384r1,
+ rfc6664.id_ecMQV: rfc5480.secp384r1,
}
count = 0
@@ -94,16 +90,14 @@ PQMBBwYFK4EEACIGBSuBBAAjMBoGCSqGSIb3DQEBCDANBglghkgBZQMEAgEFAA==
if cap['capabilityID'] in parameterValue.keys():
pValue = parameterValue[cap['capabilityID']](cap['parameters'])
eValue = expectedValue[cap['capabilityID']]
- assert pValue == eValue
+ self.assertEqual(eValue, pValue)
count += 1
- assert count == 7
+ self.assertEqual(7, count)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc6955.py b/tests/test_rfc6955.py
index eb4d5cf..443d70d 100644
--- a/tests/test_rfc6955.py
+++ b/tests/test_rfc6955.py
@@ -5,12 +5,11 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
@@ -19,12 +18,6 @@ from pyasn1_modules import rfc5480
from pyasn1_modules import rfc6402
from pyasn1_modules import rfc6955
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class CertificationRequestTestCase(unittest.TestCase):
pem_text = """\
@@ -53,47 +46,56 @@ Xo9l9a+tyVybAsCoiClhYw==
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['certificationRequestInfo']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc5480.dhpublicnumber
- assert spki_a['algorithm'] in rfc5280.algorithmIdentifierMap.keys()
- params, rest = der_decode(spki_a['parameters'], asn1Spec=rfc6955.DomainParameters())
- assert not rest
- assert params.prettyPrint()
- assert der_encode(params) == spki_a['parameters']
- assert params['validationParms']['pgenCounter'] == 55
+
+ self.assertEqual(rfc5480.dhpublicnumber, spki_a['algorithm'])
+ self.assertIn(spki_a['algorithm'], rfc5280.algorithmIdentifierMap)
+
+ params, rest = der_decoder(
+ spki_a['parameters'], asn1Spec=rfc6955.DomainParameters())
+
+ self.assertFalse(rest)
+ self.assertTrue(params.prettyPrint())
+ self.assertEqual(spki_a['parameters'], der_encoder(params))
+ self.assertEqual(55, params['validationParms']['pgenCounter'])
sig_a = asn1Object['signatureAlgorithm']
- assert sig_a['algorithm'] == rfc6955.id_dhPop_static_sha1_hmac_sha1
- assert sig_a['algorithm'] in rfc5280.algorithmIdentifierMap.keys()
- assert sig_a['parameters'] == der_encode(univ.Null(""))
+
+ self.assertEqual(
+ rfc6955.id_dhPop_static_sha1_hmac_sha1, sig_a['algorithm'])
+ self.assertIn(sig_a['algorithm'], rfc5280.algorithmIdentifierMap)
+ self.assertEqual(sig_a['parameters'], der_encoder(univ.Null("")))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
spki_a = asn1Object['certificationRequestInfo']['subjectPublicKeyInfo']['algorithm']
- assert spki_a['algorithm'] == rfc5480.dhpublicnumber
- assert spki_a['parameters']['validationParms']['pgenCounter'] == 55
+
+ self.assertEqual(rfc5480.dhpublicnumber, spki_a['algorithm'])
+ self.assertEqual(
+ 55, spki_a['parameters']['validationParms']['pgenCounter'])
sig_a = asn1Object['signatureAlgorithm']
- assert sig_a['algorithm'] == rfc6955.id_dhPop_static_sha1_hmac_sha1
- assert sig_a['parameters'] == univ.Null("")
+
+ self.assertEqual(
+ rfc6955.id_dhPop_static_sha1_hmac_sha1, sig_a['algorithm'])
+ self.assertEqual(univ.Null(""), sig_a['parameters'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc6960.py b/tests/test_rfc6960.py
index 33acbb9..151c934 100644
--- a/tests/test_rfc6960.py
+++ b/tests/test_rfc6960.py
@@ -5,12 +5,11 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
@@ -18,12 +17,6 @@ from pyasn1_modules import rfc5280
from pyasn1_modules import rfc4055
from pyasn1_modules import rfc6960
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class OCSPRequestTestCase(unittest.TestCase):
ocsp_req_pem_text = """\
@@ -36,39 +29,43 @@ isWVpesQdXMCBDXe9M+iIzAhMB8GCSsGAQUFBzABAgQSBBBjdJOiIW9EKJGELNNf/rdA
def testDerCodec(self):
substrate = pem.readBase64fromText(self.ocsp_req_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert asn1Object['tbsRequest']['version'] == 0
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(0, asn1Object['tbsRequest']['version'])
count = 0
for extn in asn1Object['tbsRequest']['requestExtensions']:
- assert extn['extnID'] in rfc5280.certificateExtensionsMap.keys()
- ev, rest = der_decode(extn['extnValue'],
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
+
count += 1
- assert count == 1
+ self.assertEqual(1, count)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.ocsp_req_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['tbsRequest']['version'] == 0
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(0, asn1Object['tbsRequest']['version'])
+
for req in asn1Object['tbsRequest']['requestList']:
ha = req['reqCert']['hashAlgorithm']
- assert ha['algorithm'] == rfc4055.id_sha1
- assert ha['parameters'] == univ.Null("")
+ self.assertEqual(rfc4055.id_sha1, ha['algorithm'])
+ self.assertEqual(univ.Null(""), ha['parameters'])
class OCSPResponseTestCase(unittest.TestCase):
@@ -102,68 +99,78 @@ HAESdf7nebz1wtqAOXE1jWF/y8g=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.ocsp_resp_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(0, asn1Object['responseStatus'])
- assert asn1Object['responseStatus'] == 0
rb = asn1Object['responseBytes']
- assert rb['responseType'] in rfc6960.ocspResponseMap.keys()
- resp, rest = der_decode(rb['response'],
- asn1Spec=rfc6960.ocspResponseMap[rb['responseType']])
- assert not rest
- assert resp.prettyPrint()
- assert der_encode(resp) == rb['response']
-
- resp['tbsResponseData']['version'] == 0
+
+ self.assertIn(rb['responseType'], rfc6960.ocspResponseMap)
+
+ resp, rest = der_decoder(
+ rb['response'], asn1Spec=rfc6960.ocspResponseMap[rb['responseType']])
+
+ self.assertFalse(rest)
+ self.assertTrue(resp.prettyPrint())
+ self.assertEqual(rb['response'], der_encoder(resp))
+ self.assertEqual(0, resp['tbsResponseData']['version'])
+
count = 0
for extn in resp['tbsResponseData']['responseExtensions']:
- assert extn['extnID'] in rfc5280.certificateExtensionsMap.keys()
- ev, rest = der_decode(extn['extnValue'],
+ self.assertIn(extn['extnID'], rfc5280.certificateExtensionsMap)
+
+ ev, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert ev.prettyPrint()
- assert der_encode(ev) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(ev))
+
count += 1
- assert count == 1
+ self.assertEqual(1, count)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.ocsp_resp_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(0, asn1Object['responseStatus'])
- assert asn1Object['responseStatus'] == 0
rb = asn1Object['responseBytes']
- assert rb['responseType'] in rfc6960.ocspResponseMap.keys()
- resp, rest = der_decode(rb['response'],
- asn1Spec=rfc6960.ocspResponseMap[rb['responseType']],
- decodeOpenTypes=True)
- assert not rest
- assert resp.prettyPrint()
- assert der_encode(resp) == rb['response']
-
- resp['tbsResponseData']['version'] == 0
+
+ self.assertIn(rb['responseType'], rfc6960.ocspResponseMap)
+
+ resp, rest = der_decoder(
+ rb['response'],
+ asn1Spec=rfc6960.ocspResponseMap[rb['responseType']],
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(resp.prettyPrint())
+ self.assertEqual(rb['response'], der_encoder(resp))
+ self.assertEqual(0, resp['tbsResponseData']['version'])
+
for rdn in resp['tbsResponseData']['responderID']['byName']['rdnSequence']:
for attr in rdn:
if attr['type'] == rfc5280.id_emailAddress:
- assert attr['value'] == 'info@snmplabs.com'
+ self.assertEqual('info@snmplabs.com', attr['value'])
for r in resp['tbsResponseData']['responses']:
ha = r['certID']['hashAlgorithm']
- assert ha['algorithm'] == rfc4055.id_sha1
- assert ha['parameters'] == univ.Null("")
+ self.assertEqual(rfc4055.id_sha1, ha['algorithm'])
+ self.assertEqual(univ.Null(""), ha['parameters'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc7030.py b/tests/test_rfc7030.py
index c351922..7d011f0 100644
--- a/tests/test_rfc7030.py
+++ b/tests/test_rfc7030.py
@@ -5,23 +5,17 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+from pyasn1.type import univ
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc7030
-from pyasn1.type import univ
-
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class CSRAttrsTestCase(unittest.TestCase):
pem_text = """\
@@ -29,60 +23,64 @@ MEEGCSqGSIb3DQEJBzASBgcqhkjOPQIBMQcGBSuBBAAiMBYGCSqGSIb3DQEJDjEJ
BgcrBgEBAQEWBggqhkjOPQQDAw==
"""
- the_oids = (univ.ObjectIdentifier('1.2.840.113549.1.9.7'),
- univ.ObjectIdentifier('1.2.840.10045.4.3.3'),
+ the_oids = (
+ univ.ObjectIdentifier('1.2.840.113549.1.9.7'),
+ univ.ObjectIdentifier('1.2.840.10045.4.3.3')
)
- the_attrTypes = (univ.ObjectIdentifier('1.2.840.10045.2.1'),
- univ.ObjectIdentifier('1.2.840.113549.1.9.14'),
+ the_attrTypes = (
+ univ.ObjectIdentifier('1.2.840.10045.2.1'),
+ univ.ObjectIdentifier('1.2.840.113549.1.9.14'),
)
- the_attrVals = ('1.3.132.0.34',
- '1.3.6.1.1.1.1.22',
+ the_attrVals = (
+ '1.3.132.0.34',
+ '1.3.6.1.1.1.1.22',
)
-
def setUp(self):
self.asn1Spec = rfc7030.CsrAttrs()
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for attr_or_oid in asn1Object:
if attr_or_oid.getName() == 'oid':
- assert attr_or_oid['oid'] in self.the_oids
+ self.assertIn(attr_or_oid['oid'], self.the_oids)
if attr_or_oid.getName() == 'attribute':
- assert attr_or_oid['attribute']['attrType'] in self.the_attrTypes
+ self.assertIn(
+ attr_or_oid['attribute']['attrType'], self.the_attrTypes)
def testOpenTypes(self):
- openTypesMap = { }
- openTypesMap.update(rfc5652.cmsAttributesMap)
+ openTypesMap = rfc5652.cmsAttributesMap.copy()
+
for at in self.the_attrTypes:
- openTypesMap.update({ at: univ.ObjectIdentifier(), })
+ openTypesMap.update({at: univ.ObjectIdentifier()})
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- openTypes=openTypesMap,
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, openTypes=openTypesMap,
decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for attr_or_oid in asn1Object:
if attr_or_oid.getName() == 'attribute':
valString = attr_or_oid['attribute']['attrValues'][0].prettyPrint()
-
+
if attr_or_oid['attribute']['attrType'] == self.the_attrTypes[0]:
- assert valString == self.the_attrVals[0]
-
+ self.assertEqual(self.the_attrVals[0], valString)
+
if attr_or_oid['attribute']['attrType'] == self.the_attrTypes[1]:
- assert valString == self.the_attrVals[1]
+ self.assertEqual(self.the_attrVals[1], valString)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc7191.py b/tests/test_rfc7191.py
index 9352c1f..40afbd4 100644
--- a/tests/test_rfc7191.py
+++ b/tests/test_rfc7191.py
@@ -7,21 +7,15 @@
#
import sys
+import unittest
-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.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc7191
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class ReceiptRequestTestCase(unittest.TestCase):
message1_pem_text = """\
@@ -63,48 +57,52 @@ goRV+bq4fdgOOj25JFqa80xnXGtQqjm/7NSII5SbdJk+DT7KCkSbkElkbgQ=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.message1_pem_text)
- asn1Object, rest = der_decode (substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
- assert asn1Object['contentType'] == rfc5652.id_signedData
- sd, rest = der_decode (asn1Object['content'],
- asn1Spec=rfc5652.SignedData())
+ sd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.SignedData())
for sa in sd['signerInfos'][0]['signedAttrs']:
sat = sa['attrType']
sav0 = sa['attrValues'][0]
if sat == rfc7191.id_aa_KP_keyPkgIdAndReceiptReq:
- sav, rest = der_decode(sav0,
- asn1Spec=rfc7191.KeyPkgIdentifierAndReceiptReq())
- assert not rest
- assert sav.prettyPrint()
- assert der_encode(sav) == sav0
-
+ sav, rest = der_decoder(
+ sav0, asn1Spec=rfc7191.KeyPkgIdentifierAndReceiptReq())
+
+ self.assertFalse(rest)
+ self.assertTrue(sav.prettyPrint())
+ self.assertEqual(sav0, der_encoder(sav))
+
package_id_pem_text = "J7icVjsWIlGdF4cceb+siG3f+D0="
package_id = pem.readBase64fromText(package_id_pem_text)
- assert sav['pkgID'] == package_id
+
+ self.assertEqual(package_id, sav['pkgID'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.message1_pem_text)
- asn1Object, rest = der_decode (substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] == rfc5652.id_signedData
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
v3 = rfc5652.CMSVersion().subtype(value='v3')
- assert asn1Object['content']['version'] == v3
+
+ self.assertEqual(v3, asn1Object['content']['version'])
for sa in asn1Object['content']['signerInfos'][0]['signedAttrs']:
if sa['attrType'] == rfc7191.id_aa_KP_keyPkgIdAndReceiptReq:
package_id_pem_text = "J7icVjsWIlGdF4cceb+siG3f+D0="
package_id = pem.readBase64fromText(package_id_pem_text)
- assert sa['attrValues'][0]['pkgID'] == package_id
+ self.assertEqual(package_id, sa['attrValues'][0]['pkgID'])
class ReceiptTestCase(unittest.TestCase):
@@ -138,60 +136,73 @@ bUcOYuCdivgxVuhlAgIxAPR9JavxziwCbVyBUWOAiKKYfglTgG3AwNmrKDj0NtXUQ9qDmGAc
def testDerCodec(self):
substrate = pem.readBase64fromText(self.message2_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
- sd, rest = der_decode (asn1Object['content'],
- asn1Spec=rfc5652.SignedData())
- assert not rest
- assert sd.prettyPrint()
- assert der_encode(sd) == asn1Object['content']
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
+ sd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.SignedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(sd.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(sd))
oid = sd['encapContentInfo']['eContentType']
- assert oid == rfc7191.id_ct_KP_keyPackageReceipt
- receipt, rest = der_decode(sd['encapContentInfo']['eContent'],
+
+ self.assertEqual(rfc7191.id_ct_KP_keyPackageReceipt, oid)
+
+ receipt, rest = der_decoder(
+ sd['encapContentInfo']['eContent'],
asn1Spec=rfc7191.KeyPackageReceipt())
- assert not rest
- assert receipt.prettyPrint()
- assert der_encode(receipt) == sd['encapContentInfo']['eContent']
+
+ self.assertFalse(rest)
+ self.assertTrue(receipt.prettyPrint())
+ self.assertEqual(sd['encapContentInfo']['eContent'], der_encoder(receipt))
package_id_pem_text = "J7icVjsWIlGdF4cceb+siG3f+D0="
package_id = pem.readBase64fromText(package_id_pem_text)
- assert receipt['receiptOf']['pkgID'] == package_id
+
+ self.assertEqual(package_id, receipt['receiptOf']['pkgID'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.message2_pem_text)
- asn1Object, rest = der_decode (substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] == rfc5652.id_signedData
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
v3 = rfc5652.CMSVersion().subtype(value='v3')
- assert asn1Object['content']['version'] == v3
+
+ self.assertEqual(v3, asn1Object['content']['version'])
for sa in asn1Object['content']['signerInfos'][0]['signedAttrs']:
- assert sa['attrType'] in rfc5652.cmsAttributesMap.keys()
+ self.assertIn( sa['attrType'], rfc5652.cmsAttributesMap)
if sa['attrType'] == rfc5652.id_messageDigest:
- assert '0x412598a6ae2' in sa['attrValues'][0].prettyPrint()
+ self.assertIn(
+ '0x412598a6ae2', sa['attrValues'][0].prettyPrint())
ct_oid = asn1Object['content']['encapContentInfo']['eContentType']
- assert ct_oid in rfc5652.cmsContentTypesMap
- assert ct_oid == rfc7191.id_ct_KP_keyPackageReceipt
+
+ self.assertIn(ct_oid, rfc5652.cmsContentTypesMap)
+ self.assertEqual(ct_oid, rfc7191.id_ct_KP_keyPackageReceipt)
# Since receipt is inside an OCTET STRING, decodeOpenTypes=True cannot
# automatically decode it
sd_eci = asn1Object['content']['encapContentInfo']
- receipt, rest = der_decode(sd_eci['eContent'],
+ receipt, rest = der_decoder(
+ sd_eci['eContent'],
asn1Spec=rfc5652.cmsContentTypesMap[sd_eci['eContentType']])
package_id_pem_text = "J7icVjsWIlGdF4cceb+siG3f+D0="
package_id = pem.readBase64fromText(package_id_pem_text)
- assert receipt['receiptOf']['pkgID'] == package_id
+
+ self.assertEqual(package_id, receipt['receiptOf']['pkgID'])
+
class ErrorTestCase(unittest.TestCase):
message3_pem_text = """\
@@ -224,68 +235,79 @@ iNF8uKtW/lk0AjA7z2q40N0lamXkSU7ECasiWOYV1X4cWGiQwMZDKknBPDqXqB6Es6p4J+qe
def testDerCodec(self):
substrate = pem.readBase64fromText(self.message3_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
- sd, rest = der_decode (asn1Object['content'],
- asn1Spec=rfc5652.SignedData())
- assert not rest
- assert sd.prettyPrint()
- assert der_encode(sd) == asn1Object['content']
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
+ sd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.SignedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(sd.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(sd))
oid = sd['encapContentInfo']['eContentType']
- assert oid == rfc7191.id_ct_KP_keyPackageError
- kpe, rest = der_decode(sd['encapContentInfo']['eContent'],
+
+ self.assertEqual(rfc7191.id_ct_KP_keyPackageError, oid)
+
+ kpe, rest = der_decoder(
+ sd['encapContentInfo']['eContent'],
asn1Spec=rfc7191.KeyPackageError())
- assert not rest
- assert kpe.prettyPrint()
- assert der_encode(kpe) == sd['encapContentInfo']['eContent']
+
+ self.assertFalse(rest)
+ self.assertTrue(kpe.prettyPrint())
+ self.assertEqual(sd['encapContentInfo']['eContent'], der_encoder(kpe))
package_id_pem_text = "J7icVjsWIlGdF4cceb+siG3f+D0="
package_id = pem.readBase64fromText(package_id_pem_text)
- assert kpe['errorOf']['pkgID'] == package_id
- assert kpe['errorCode'] == rfc7191.EnumeratedErrorCode(value=10)
+
+ self.assertEqual(package_id, kpe['errorOf']['pkgID'])
+ self.assertEqual(
+ rfc7191.EnumeratedErrorCode(value=10), kpe['errorCode'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.message3_pem_text)
- asn1Object, rest = der_decode (substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['contentType'] == rfc5652.id_signedData
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
v3 = rfc5652.CMSVersion().subtype(value='v3')
- assert asn1Object['content']['version'] == v3
+
+ self.assertEqual(v3, asn1Object['content']['version'])
for sa in asn1Object['content']['signerInfos'][0]['signedAttrs']:
- assert sa['attrType'] in rfc5652.cmsAttributesMap.keys()
+ self.assertIn(sa['attrType'], rfc5652.cmsAttributesMap)
if sa['attrType'] == rfc5652.id_messageDigest:
- assert '0xa05c54d4737' in sa['attrValues'][0].prettyPrint()
+ self.assertIn(
+ '0xa05c54d4737', sa['attrValues'][0].prettyPrint())
ct_oid = asn1Object['content']['encapContentInfo']['eContentType']
- assert ct_oid in rfc5652.cmsContentTypesMap.keys()
- assert ct_oid == rfc7191.id_ct_KP_keyPackageError
+
+ self.assertIn(ct_oid, rfc5652.cmsContentTypesMap)
+ self.assertEqual(rfc7191.id_ct_KP_keyPackageError, ct_oid)
# Since receipt is inside an OCTET STRING, decodeOpenTypes=True cannot
# automatically decode it
sd_eci = asn1Object['content']['encapContentInfo']
- kpe, rest = der_decode(sd_eci['eContent'],
+ kpe, rest = der_decoder(
+ sd_eci['eContent'],
asn1Spec=rfc5652.cmsContentTypesMap[sd_eci['eContentType']])
package_id_pem_text = "J7icVjsWIlGdF4cceb+siG3f+D0="
package_id = pem.readBase64fromText(package_id_pem_text)
- assert kpe['errorOf']['pkgID'] == package_id
- assert kpe['errorCode'] == rfc7191.EnumeratedErrorCode(value=10)
+
+ self.assertEqual(package_id, kpe['errorOf']['pkgID'])
+ self.assertEqual(rfc7191.EnumeratedErrorCode(value=10), kpe['errorCode'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc7229.py b/tests/test_rfc7229.py
index 6d1c578..915b9be 100644
--- a/tests/test_rfc7229.py
+++ b/tests/test_rfc7229.py
@@ -5,22 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc7229
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class CertificatePolicyTestCase(unittest.TestCase):
pem_text = """\
@@ -59,19 +53,23 @@ PZs8K3IjUA5+U73pA8lpaTOPscLY22WL9pAGmyVUyEJ8lM7E+r4iDg==
]
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
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
count = 0
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] in rfc5280.certificateExtensionsMap.keys():
s = extn['extnValue']
- ev, rest = der_decode(s, rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert ev.prettyPrint()
- assert s == der_encode(ev)
+ ev, rest = der_decoder(
+ s, rfc5280.certificateExtensionsMap[extn['extnID']])
+
+ self.assertFalse(rest)
+ self.assertTrue(ev.prettyPrint())
+ self.assertEqual(s, der_encoder(ev))
if extn['extnID'] == rfc5280.id_ce_certificatePolicies:
for pol in ev:
@@ -85,13 +83,11 @@ PZs8K3IjUA5+U73pA8lpaTOPscLY22WL9pAGmyVUyEJ8lM7E+r4iDg==
if pmap['subjectDomainPolicy'] in test_oids:
count += 1
- assert count == 6
+ self.assertEqual(6, count)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc7292.py b/tests/test_rfc7292.py
index 8bebef3..583d396 100644
--- a/tests/test_rfc7292.py
+++ b/tests/test_rfc7292.py
@@ -5,23 +5,17 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc7292
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class PKCS12TestCase(unittest.TestCase):
pfx_pem_text = """\
@@ -79,91 +73,108 @@ rqr03dPnboinBBSU7mxdpB5LTCvorCI8Tk5OMiUzjgICB9A=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.pfx_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(3, asn1Object['version'])
- assert asn1Object['version'] == univ.Integer(3)
oid = asn1Object['macData']['mac']['digestAlgorithm']['algorithm']
- assert oid == univ.ObjectIdentifier('1.3.14.3.2.26')
+
+ self.assertEqual(univ.ObjectIdentifier('1.3.14.3.2.26'), oid)
+
md_hex = asn1Object['macData']['mac']['digest'].prettyPrint()
- assert md_hex == '0xa5608ffdf651d132b90701aeaaf4ddd3e76e88a7'
- assert asn1Object['authSafe']['contentType'] == rfc5652.id_data
- data, rest = der_decode(asn1Object['authSafe']['content'],
- asn1Spec=univ.OctetString())
- assert not rest
+ self.assertEqual('0xa5608ffdf651d132b90701aeaaf4ddd3e76e88a7', md_hex)
+ self.assertEqual(
+ rfc5652.id_data, asn1Object['authSafe']['contentType'])
+
+ data, rest = der_decoder(
+ asn1Object['authSafe']['content'], asn1Spec=univ.OctetString())
+
+ self.assertFalse(rest)
+
+ authsafe, rest = der_decoder(data, asn1Spec=rfc7292.AuthenticatedSafe())
- authsafe, rest = der_decode(data, asn1Spec=rfc7292.AuthenticatedSafe())
- assert not rest
- assert authsafe.prettyPrint()
- assert der_encode(authsafe) == data
+ self.assertFalse(rest)
+ self.assertTrue(authsafe.prettyPrint())
+ self.assertEqual(data, der_encoder(authsafe))
for ci in authsafe:
- assert ci['contentType'] == rfc5652.id_data
- data, rest = der_decode(ci['content'], asn1Spec=univ.OctetString())
- assert not rest
+ self.assertEqual(rfc5652.id_data, ci['contentType'])
- sc, rest = der_decode(data, asn1Spec=rfc7292.SafeContents())
- assert not rest
- assert sc.prettyPrint()
- assert der_encode(sc) == data
+ data, rest = der_decoder(ci['content'], asn1Spec=univ.OctetString())
+
+ self.assertFalse(rest)
+
+ sc, rest = der_decoder(data, asn1Spec=rfc7292.SafeContents())
+
+ self.assertFalse(rest)
+ self.assertTrue(sc.prettyPrint())
+ self.assertEqual(data, der_encoder(sc))
for sb in sc:
if sb['bagId'] in rfc7292.pkcs12BagTypeMap:
- bv, rest = der_decode(sb['bagValue'],
- asn1Spec=rfc7292.pkcs12BagTypeMap[sb['bagId']])
- assert not rest
- assert bv.prettyPrint()
- assert der_encode(bv) == sb['bagValue']
+ bv, rest = der_decoder(
+ sb['bagValue'],
+ asn1Spec=rfc7292.pkcs12BagTypeMap[sb['bagId']])
+
+ self.assertFalse(rest)
+ self.assertTrue(bv.prettyPrint())
+ self.assertEqual(sb['bagValue'], der_encoder(bv))
for attr in sb['bagAttributes']:
if attr['attrType'] in rfc5652.cmsAttributesMap:
- av, rest = der_decode(attr['attrValues'][0],
+ av, rest = der_decoder(
+ attr['attrValues'][0],
asn1Spec=rfc5652.cmsAttributesMap[attr['attrType']])
- assert not rest
- assert av.prettyPrint()
- assert der_encode(av) == attr['attrValues'][0]
+ self.assertFalse(rest)
+ self.assertTrue(av.prettyPrint())
+ self.assertEqual(
+ attr['attrValues'][0], der_encoder(av))
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pfx_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True
- )
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
digest_alg = asn1Object['macData']['mac']['digestAlgorithm']
- assert not digest_alg['parameters'].hasValue()
- authsafe, rest = der_decode(asn1Object['authSafe']['content'],
+ self.assertFalse(digest_alg['parameters'].hasValue())
+
+ authsafe, rest = der_decoder(
+ asn1Object['authSafe']['content'],
asn1Spec=rfc7292.AuthenticatedSafe(),
- decodeOpenTypes=True
- )
- assert not rest
- assert authsafe.prettyPrint()
- assert der_encode(authsafe) == asn1Object['authSafe']['content']
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(authsafe.prettyPrint())
+ self.assertEqual(
+ asn1Object['authSafe']['content'], der_encoder(authsafe))
for ci in authsafe:
- assert ci['contentType'] == rfc5652.id_data
- sc, rest = der_decode(ci['content'],
- asn1Spec=rfc7292.SafeContents(),
- decodeOpenTypes=True
- )
- assert not rest
- assert sc.prettyPrint()
- assert der_encode(sc) == ci['content']
-
+ self.assertEqual(rfc5652.id_data, ci['contentType'])
+ sc, rest = der_decoder(
+ ci['content'], asn1Spec=rfc7292.SafeContents(),
+ decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(sc.prettyPrint())
+ self.assertEqual(ci['content'], der_encoder(sc))
+
for sb in sc:
if sb['bagId'] == rfc7292.id_pkcs8ShroudedKeyBag:
bv = sb['bagValue']
enc_alg = bv['encryptionAlgorithm']['algorithm']
- assert enc_alg == rfc7292.pbeWithSHAAnd3_KeyTripleDES_CBC
+ self.assertEqual(
+ rfc7292.pbeWithSHAAnd3_KeyTripleDES_CBC, enc_alg)
enc_alg_param = bv['encryptionAlgorithm']['parameters']
- assert enc_alg_param['iterations'] == 2000
+ self.assertEqual(2000, enc_alg_param['iterations'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc7296.py b/tests/test_rfc7296.py
index 90dc0a3..4bc7577 100644
--- a/tests/test_rfc7296.py
+++ b/tests/test_rfc7296.py
@@ -5,23 +5,15 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
-from pyasn1_modules import rfc5280
from pyasn1_modules import rfc7296
-from pyasn1.type.univ import noValue
-
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class CertBundleTestCase(unittest.TestCase):
cert_bundle_pem_text = """\
@@ -137,25 +129,29 @@ m9Y=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_bundle_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
cert_count = 0
crl_count = 0
unk_count = 0
+
for item in asn1Object:
if item.getName() == 'cert':
cert_count += 1
+
elif item.getName() == 'crl':
crl_count += 1
+
else:
unk_count += 1
- assert cert_count == 3
- assert crl_count == 2
- assert unk_count == 0
+ self.assertEqual(3, cert_count)
+ self.assertEqual(2, crl_count)
+ self.assertEqual(0, unk_count)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc7508.py b/tests/test_rfc7508.py
index 07f0d86..914e6d8 100644
--- a/tests/test_rfc7508.py
+++ b/tests/test_rfc7508.py
@@ -7,21 +7,15 @@
#
import sys
+import unittest
-from pyasn1.type import univ
-
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc7508
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class SignedMessageTestCase(unittest.TestCase):
signed_message_pem_text = """\
@@ -59,74 +53,82 @@ bEtkkWCao1uNm5TOzphK0NbxzOsD854aC5ReKPSDAjAm1U0siLQw5p4qzGwyxDw9
def testDerCodec(self):
substrate = pem.readBase64fromText(self.signed_message_pem_text)
- asn1Object, rest = der_decode (substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
secure_header_field_attr_found = False
- assert asn1Object['contentType'] == rfc5652.id_signedData
- sd, rest = der_decode (asn1Object['content'], asn1Spec=rfc5652.SignedData())
+
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
+
+ sd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.SignedData())
+
for sa in sd['signerInfos'][0]['signedAttrs']:
sat = sa['attrType']
sav0 = sa['attrValues'][0]
if sat == rfc7508.id_aa_secureHeaderFieldsIdentifier:
- assert sat in rfc5652.cmsAttributesMap.keys()
- sav, rest = der_decode(sav0, asn1Spec=rfc5652.cmsAttributesMap[sat])
- assert not rest
- assert sav.prettyPrint()
- assert der_encode(sav) == sav0
+ self.assertIn(sat, rfc5652.cmsAttributesMap)
+ sav, rest = der_decoder(
+ sav0, asn1Spec=rfc5652.cmsAttributesMap[sat])
+
+ self.assertFalse(rest)
+ self.assertTrue(sav.prettyPrint())
+ self.assertEqual(sav0, der_encoder(sav))
from_field = rfc7508.HeaderFieldName('From')
alice_email = rfc7508.HeaderFieldValue('alice@example.com')
for shf in sav['secHeaderFields']:
if shf['field-Name'] == from_field:
- assert shf['field-Value'] == alice_email
+ self.assertEqual(alice_email, shf['field-Value'])
secure_header_field_attr_found = True
- assert secure_header_field_attr_found
+ self.assertTrue(secure_header_field_attr_found)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.signed_message_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert asn1Object['contentType'] in rfc5652.cmsContentTypesMap.keys()
- assert asn1Object['contentType'] == rfc5652.id_signedData
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertIn(asn1Object['contentType'], rfc5652.cmsContentTypesMap)
+ self.assertEqual(asn1Object['contentType'], rfc5652.id_signedData)
sd = asn1Object['content']
- assert sd['version'] == rfc5652.CMSVersion().subtype(value='v1')
+
+ self.assertEqual(
+ rfc5652.CMSVersion().subtype(value='v1'), sd['version'])
ect = sd['encapContentInfo']['eContentType']
- assert ect in rfc5652.cmsContentTypesMap.keys()
- assert ect == rfc5652.id_data
+
+ self.assertIn(ect, rfc5652.cmsContentTypesMap)
+ self.assertEqual(rfc5652.id_data, ect)
for sa in sd['signerInfos'][0]['signedAttrs']:
if sa['attrType'] == rfc7508.id_aa_secureHeaderFieldsIdentifier:
- assert sa['attrType'] in rfc5652.cmsAttributesMap.keys()
+ self.assertIn(sa['attrType'], rfc5652.cmsAttributesMap)
secure_header_field_attr_found = False
for sa in sd['signerInfos'][0]['signedAttrs']:
if sa['attrType'] == rfc7508.id_aa_secureHeaderFieldsIdentifier:
- assert sa['attrType'] in rfc5652.cmsAttributesMap.keys()
+ self.assertIn(sa['attrType'], rfc5652.cmsAttributesMap)
from_field = rfc7508.HeaderFieldName('From')
alice_email = rfc7508.HeaderFieldValue('alice@example.com')
for shf in sa['attrValues'][0]['secHeaderFields']:
if shf['field-Name'] == from_field:
- assert shf['field-Value'] == alice_email
+ self.assertEqual(alice_email, shf['field-Value'])
secure_header_field_attr_found = True
- assert secure_header_field_attr_found
+ self.assertTrue(secure_header_field_attr_found)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc7585.py b/tests/test_rfc7585.py
index ecbd72a..5e53834 100644
--- a/tests/test_rfc7585.py
+++ b/tests/test_rfc7585.py
@@ -5,23 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-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.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc7585
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class NAIRealmCertTestCase(unittest.TestCase):
cert_pem_text = """\
@@ -56,69 +49,78 @@ Jiw8B0yjkokwojxyRGftMT8uxNjWQVsMDbxl
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
nai_realm_oid = rfc7585.id_on_naiRealm
nai_realm_found = False
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectAltName:
- extnValue, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.SubjectAltName())
- assert not rest
- assert extnValue.prettyPrint()
- assert der_encode(extnValue) == extn['extnValue']
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.SubjectAltName())
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
for gn in extnValue:
if gn['otherName'].hasValue():
- assert gn['otherName']['type-id'] == nai_realm_oid
- onValue, rest = der_decode(gn['otherName']['value'],
- asn1Spec=rfc7585.NAIRealm())
- assert not rest
- assert onValue.prettyPrint()
- assert der_encode(onValue) == gn['otherName']['value']
- assert 'example' in onValue
+ self.assertEqual(
+ nai_realm_oid, gn['otherName']['type-id'])
+
+ onValue, rest = der_decoder(
+ gn['otherName']['value'], asn1Spec=rfc7585.NAIRealm())
+
+ self.assertFalse(rest)
+ self.assertTrue(onValue.prettyPrint())
+ self.assertEqual(
+ gn['otherName']['value'], der_encoder(onValue))
+ self.assertIn('example', onValue)
+
nai_realm_found = True
- assert nai_realm_found
+ self.assertTrue(nai_realm_found)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
nai_realm_oid = rfc7585.id_on_naiRealm
nai_realm_found = False
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] == rfc5280.id_ce_subjectAltName:
- extnValue, rest = der_decode(extn['extnValue'],
- asn1Spec=rfc5280.SubjectAltName(),
+ extnValue, rest = der_decoder(
+ extn['extnValue'], asn1Spec=rfc5280.SubjectAltName(),
decodeOpenTypes=True)
- assert not rest
- assert extnValue.prettyPrint()
- assert der_encode(extnValue) == extn['extnValue']
+
+ self.assertFalse(rest)
+ self.assertTrue(extnValue.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
for gn in extnValue:
if gn['otherName'].hasValue():
- assert gn['otherName']['type-id'] == nai_realm_oid
- assert 'example' in gn['otherName']['value']
+ self.assertEqual(
+ nai_realm_oid, gn['otherName']['type-id'])
+ self.assertIn('example', gn['otherName']['value'])
+
nai_realm_found = True
- assert nai_realm_found
+ self.assertTrue(nai_realm_found)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc7633.py b/tests/test_rfc7633.py
index de17cda..64e874e 100644
--- a/tests/test_rfc7633.py
+++ b/tests/test_rfc7633.py
@@ -5,22 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc7633
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class TLSFeaturesExtnTestCase(unittest.TestCase):
pem_text = """\
@@ -55,32 +49,32 @@ AOQSxhs011emVxyBIXT0ZGbmBY8LFRh6eGIOCAJbkM5T
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ extn_list = []
- extn_list = [ ]
for extn in asn1Object['tbsCertificate']['extensions']:
extn_list.append(extn['extnID'])
if extn['extnID'] == rfc7633.id_pe_tlsfeature:
s = extn['extnValue']
- features, rest = der_decode(s,
- rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert features.prettyPrint()
- assert s == der_encode(features)
+ features, rest = der_decoder(
+ s, rfc5280.certificateExtensionsMap[extn['extnID']])
- assert len(features) == 1
- assert features[0] == 5
+ self.assertFalse(rest)
+ self.assertTrue(features.prettyPrint())
+ self.assertEqual(s, der_encoder(features))
+ self.assertEqual(1, len(features))
+ self.assertEqual(5, features[0])
- assert rfc7633.id_pe_tlsfeature in extn_list
+ self.assertIn(rfc7633.id_pe_tlsfeature, extn_list)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc7773.py b/tests/test_rfc7773.py
index 37765f0..2b4e50b 100644
--- a/tests/test_rfc7773.py
+++ b/tests/test_rfc7773.py
@@ -5,22 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc7773
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
class AuthenticationContextExtnTestCase(unittest.TestCase):
pem_text = """\
@@ -87,33 +81,33 @@ tAGXsYdcuQpglUngmo/FV4Z9qjIDkYQ=
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ extn_list = []
- extn_list = [ ]
for extn in asn1Object['tbsCertificate']['extensions']:
extn_list.append(extn['extnID'])
if extn['extnID'] == rfc7773.id_ce_authContext:
s = extn['extnValue']
- acs, rest = der_decode(s,
- asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert acs.prettyPrint()
- assert s == der_encode(acs)
-
- assert u'id.elegnamnden.se' in acs[0]['contextType']
- assert u'AuthContextInfo IdentityProvider' in acs[0]['contextInfo']
+ acs, rest = der_decoder(
+ s, asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
+ self.assertFalse(rest)
+ self.assertTrue(acs.prettyPrint())
+ self.assertEqual(s, der_encoder(acs))
+ self.assertIn('id.elegnamnden.se', acs[0]['contextType'])
+ self.assertIn(
+ 'AuthContextInfo IdentityProvider', acs[0]['contextInfo'])
- assert rfc7773.id_ce_authContext in extn_list
+ self.assertIn(rfc7773.id_ce_authContext, extn_list)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc7894.py b/tests/test_rfc7894.py
index 243b4c9..3d38155 100644
--- a/tests/test_rfc7894.py
+++ b/tests/test_rfc7894.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc6402
from pyasn1_modules import rfc7894
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class AlternativeChallengePasswordTestCase(unittest.TestCase):
otp_pem_text = """\
@@ -45,42 +40,45 @@ NmaF8Y2Sl/MgvC5tjs0Ck0/r3lsoLQ==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.otp_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert asn1Object['certificationRequestInfo']['version'] == 0
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(0, asn1Object['certificationRequestInfo']['version'])
for attr in asn1Object['certificationRequestInfo']['attributes']:
- assert attr['attrType'] in rfc6402.cmcControlAttributesMap.keys()
- av, rest = der_decode(attr['attrValues'][0],
+ self.assertIn(
+ attr['attrType'], rfc6402.cmcControlAttributesMap)
+
+ av, rest = der_decoder(
+ attr['attrValues'][0],
rfc6402.cmcControlAttributesMap[attr['attrType']])
- assert not rest
- assert der_encode(av) == attr['attrValues'][0]
+
+ self.assertFalse(rest)
+ self.assertEqual(attr['attrValues'][0], der_encoder(av))
if attr['attrType'] == rfc7894.id_aa_otpChallenge:
- assert av['printableString'] == '90503846'
+ self.assertEqual('90503846', av['printableString'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.otp_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for attr in asn1Object['certificationRequestInfo']['attributes']:
- assert attr['attrType'] in rfc6402.cmcControlAttributesMap.keys()
+ self.assertIn(attr['attrType'], rfc6402.cmcControlAttributesMap)
if attr['attrType'] == rfc7894.id_aa_otpChallenge:
- assert attr['attrValues'][0]['printableString'] == '90503846'
+ self.assertEqual(
+ '90503846', attr['attrValues'][0]['printableString'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
- sys.exit(not result.wasSuccessful())
\ No newline at end of file
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc7906.py b/tests/test_rfc7906.py
index 8e4a6ee..3806987 100644
--- a/tests/test_rfc7906.py
+++ b/tests/test_rfc7906.py
@@ -5,12 +5,11 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
@@ -19,11 +18,6 @@ from pyasn1_modules import rfc5652
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc7906
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class AttributeSetTestCase(unittest.TestCase):
attr_set_pem_text = """\
@@ -128,45 +122,47 @@ toMsV8fLBpBjA5YGQvd3TAcSw1lNbWpArL+hje1dzQ7pxslnkklv3CTxAjBuVebz
def testDerCodec(self):
substrate = pem.readBase64fromText(self.attr_set_pem_text)
- asn1Object, rest = der_decode (substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for attr in asn1Object:
- assert attr['type'] in rfc5652.cmsAttributesMap.keys()
- av, rest = der_decode(attr['values'][0],
+ self.assertIn(attr['type'], rfc5652.cmsAttributesMap)
+
+ av, rest = der_decoder(
+ attr['values'][0],
asn1Spec=rfc5652.cmsAttributesMap[attr['type']])
- assert not rest
- assert av.prettyPrint()
- assert der_encode(av) == attr['values'][0]
+
+ self.assertFalse(rest)
+ self.assertTrue(av.prettyPrint())
+ self.assertEqual(attr['values'][0], der_encoder(av))
if attr['type'] == rfc7906.id_aa_KP_contentDecryptKeyID:
- assert av == univ.OctetString(hexValue='7906')
+ self.assertEqual(univ.OctetString(hexValue='7906'), av)
def testOpenTypes(self):
- openTypesMap = { }
- openTypesMap.update(rfc5280.certificateAttributesMap)
+ openTypesMap = rfc5280.certificateAttributesMap.copy()
openTypesMap.update(rfc5652.cmsAttributesMap)
substrate = pem.readBase64fromText(self.attr_set_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- openTypes=openTypesMap,
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, openTypes=openTypesMap,
decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for attr in asn1Object:
if attr['type'] == rfc7906.id_aa_KP_contentDecryptKeyID:
- assert attr['values'][0] == univ.OctetString(hexValue='7906')
+ self.assertEqual(
+ univ.OctetString(hexValue='7906'), attr['values'][0])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc7914.py b/tests/test_rfc7914.py
index 1ab8b8f..e0b1cb3 100644
--- a/tests/test_rfc7914.py
+++ b/tests/test_rfc7914.py
@@ -5,11 +5,11 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
@@ -17,12 +17,6 @@ from pyasn1_modules import rfc5958
from pyasn1_modules import rfc7914
from pyasn1_modules import rfc8018
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
-
# From RFC 7914, Section 13
@@ -40,56 +34,64 @@ iBGY/Dls7B1TsWeGObE0sS1MXEpuREuloZjcsNVcNXWPlLdZtkSH6uwWzR0PyG/Z
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
ea = asn1Object['encryptionAlgorithm']
- assert ea['algorithm'] == rfc8018.id_PBES2
- assert ea['algorithm'] in rfc5280.algorithmIdentifierMap.keys()
- params, rest = der_decode(ea['parameters'],
+ self.assertEqual(rfc8018.id_PBES2, ea['algorithm'])
+ self.assertIn(ea['algorithm'], rfc5280.algorithmIdentifierMap)
+
+ params, rest = der_decoder(
+ ea['parameters'],
asn1Spec=rfc5280.algorithmIdentifierMap[ea['algorithm']])
- assert not rest
- assert params.prettyPrint()
- assert der_encode(params) == ea['parameters']
+
+ self.assertFalse(rest)
+ self.assertTrue(params.prettyPrint())
+ self.assertEqual(ea['parameters'], der_encoder(params))
kdf = params['keyDerivationFunc']
- assert kdf['algorithm'] == rfc7914.id_scrypt
- assert kdf['algorithm'] in rfc5280.algorithmIdentifierMap.keys()
- kdfp, rest = der_decode(kdf['parameters'],
+ self.assertEqual(rfc7914.id_scrypt, kdf['algorithm'])
+ self.assertIn(kdf['algorithm'], rfc5280.algorithmIdentifierMap)
+
+ kdfp, rest = der_decoder(
+ kdf['parameters'],
asn1Spec=rfc5280.algorithmIdentifierMap[kdf['algorithm']])
- assert not rest
- assert kdfp.prettyPrint()
- assert der_encode(kdfp) == kdf['parameters']
- assert kdfp['costParameter'] == 1048576
+ self.assertFalse(rest)
+ self.assertTrue(kdfp.prettyPrint())
+ self.assertTrue(kdf['parameters'], der_encoder(kdfp))
+ self.assertEqual(1048576, kdfp['costParameter'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
ea = asn1Object['encryptionAlgorithm']
- assert ea['algorithm'] == rfc8018.id_PBES2
+
+ self.assertEqual(rfc8018.id_PBES2, ea['algorithm'])
params = asn1Object['encryptionAlgorithm']['parameters']
- assert params['keyDerivationFunc']['algorithm'] == rfc7914.id_scrypt
+
+ self.assertEqual(
+ rfc7914.id_scrypt, params['keyDerivationFunc']['algorithm'])
kdfp = params['keyDerivationFunc']['parameters']
- assert kdfp['costParameter'] == 1048576
+
+ self.assertEqual(1048576, kdfp['costParameter'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8017.py b/tests/test_rfc8017.py
index f05706e..9601997 100644
--- a/tests/test_rfc8017.py
+++ b/tests/test_rfc8017.py
@@ -5,12 +5,11 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
@@ -18,11 +17,6 @@ from pyasn1_modules import rfc5280
from pyasn1_modules import rfc8017
from pyasn1_modules import rfc2985
-try:
- import unittest2 as unittest
-
-except ImportError:
- import unittest
class SMIMECapabilitiesTestCase(unittest.TestCase):
smime_capabilities_pem_text = """\
@@ -39,39 +33,47 @@ hvcNAQEPBQAwDQYJKoZIhvcNAQEQBQA=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for cap in asn1Object:
- assert cap['algorithm'] in rfc5280.algorithmIdentifierMap.keys()
+ self.assertIn(cap['algorithm'], rfc5280.algorithmIdentifierMap)
+
if cap['parameters'].hasValue():
- p, rest = der_decode(cap['parameters'],
+ p, rest = der_decoder(
+ cap['parameters'],
asn1Spec=rfc5280.algorithmIdentifierMap[cap['algorithm']])
- assert not rest
+
+ self.assertFalse(rest)
if not p == univ.Null(""):
- assert p.prettyPrint()
- assert der_encode(p) == cap['parameters']
+ self.assertTrue(p.prettyPrint())
+ self.assertEqual(cap['parameters'], der_encoder(p))
if cap['algorithm'] == rfc8017.id_RSAES_OAEP:
- assert p['hashFunc']['algorithm'] == rfc8017.id_sha384
- assert p['maskGenFunc']['algorithm'] == rfc8017.id_mgf1
+ self.assertEqual(
+ rfc8017.id_sha384, p['hashFunc']['algorithm'])
+ self.assertEqual(
+ rfc8017.id_mgf1, p['maskGenFunc']['algorithm'])
def OpenTypesCodec(self):
substrate = pem.readBase64fromText(self.smime_capabilities_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for cap in asn1Object:
if cap['algorithm'] == rfc8017.id_RSAES_OAEP:
p = cap['parameters']
- assert p['hashFunc']['algorithm'] == rfc8017.id_sha384
- assert p['maskGenFunc']['algorithm'] == rfc8017.id_mgf1
+ self.assertEqual(
+ rfc8017.id_sha384, p['hashFunc']['algorithm'])
+ self.assertEqual(
+ rfc8017.id_mgf1, p['maskGenFunc']['algorithm'])
class MultiprimeRSAPrivateKeyTestCase(unittest.TestCase):
@@ -109,16 +111,15 @@ EeEs9dusHakg1ERXAg4Vo1YowPW8kuVbZ9faxeVrmuER5NcCuZzS5X/obGUw
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8018.py b/tests/test_rfc8018.py
index f899b54..f354c63 100644
--- a/tests/test_rfc8018.py
+++ b/tests/test_rfc8018.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc8018
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class PWRITestCase(unittest.TestCase):
rfc3211_ex1_pem_text = """\
@@ -32,23 +27,30 @@ AwIHBAjv5ZjvIbM9bQQQuBslZe43PKbe3KJqF4sMEA==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.rfc3211_ex1_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
alg_oid = asn1Object['pwri']['keyDerivationAlgorithm']['algorithm']
- assert alg_oid == rfc8018.id_PBKDF2
+
+ self.assertEqual(rfc8018.id_PBKDF2, alg_oid)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.rfc3211_ex1_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
- icount = asn1Object['pwri']['keyDerivationAlgorithm']['parameters']['iterationCount']
- assert icount == 5
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ icount = (asn1Object['pwri']['keyDerivationAlgorithm']
+ ['parameters']['iterationCount'])
+
+ self.assertEqual(5, icount)
+
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc8103.py b/tests/test_rfc8103.py
index 921b9db..002f5c9 100644
--- a/tests/test_rfc8103.py
+++ b/tests/test_rfc8103.py
@@ -5,8 +5,8 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
@@ -15,11 +15,6 @@ from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc8103
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class CAEADChaCha20Poly1305TestCase(unittest.TestCase):
alg_id_pem_text = "MBsGCyqGSIb3DQEJEAMSBAzK/rq++s7brd7K+Ig="
@@ -29,22 +24,29 @@ class CAEADChaCha20Poly1305TestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.alg_id_pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert asn1Object[0] == rfc8103.id_alg_AEADChaCha20Poly1305
- param, rest = der_decoder.decode(asn1Object[1], rfc8103.AEADChaCha20Poly1305Nonce())
- assert not rest
- assert param.prettyPrint()
- assert param == rfc8103.AEADChaCha20Poly1305Nonce(value='\xca\xfe\xba\xbe\xfa\xce\xdb\xad\xde\xca\xf8\x88')
- assert der_encoder.encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc8103.id_alg_AEADChaCha20Poly1305, asn1Object[0])
+
+ param, rest = der_decoder.decode(
+ asn1Object[1], rfc8103.AEADChaCha20Poly1305Nonce())
+
+ self.assertFalse(rest)
+ self.assertTrue(param.prettyPrint())
+ self.assertEqual(
+ rfc8103.AEADChaCha20Poly1305Nonce(value='\xca\xfe\xba\xbe\xfa'
+ '\xce\xdb\xad\xde\xca'
+ '\xf8\x88'),
+ param)
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8209.py b/tests/test_rfc8209.py
index 4c72f76..1afd77f 100644
--- a/tests/test_rfc8209.py
+++ b/tests/test_rfc8209.py
@@ -5,20 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc8209
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
class CertificateTestCase(unittest.TestCase):
cert_pem_text = """\
@@ -38,23 +34,27 @@ OCRdZCk1KI3uDDgp
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ extn_list = []
- extn_list = [ ]
for extn in asn1Object['tbsCertificate']['extensions']:
extn_list.append(extn['extnID'])
if extn['extnID'] in rfc5280.certificateExtensionsMap.keys():
- extnValue, rest = der_decode(extn['extnValue'],
+ extnValue, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert der_encode(extnValue) == extn['extnValue']
+
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
if extn['extnID'] == rfc5280.id_ce_extKeyUsage:
- assert rfc8209.id_kp_bgpsec_router in extnValue
+ self.assertIn(rfc8209.id_kp_bgpsec_router, extnValue)
- assert rfc5280.id_ce_extKeyUsage in extn_list
+ self.assertIn(rfc5280.id_ce_extKeyUsage, extn_list)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
diff --git a/tests/test_rfc8226.py b/tests/test_rfc8226.py
index 8993ae1..aa5257c 100644
--- a/tests/test_rfc8226.py
+++ b/tests/test_rfc8226.py
@@ -5,8 +5,8 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
@@ -15,38 +15,39 @@ from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc8226
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class JWTClaimConstraintsTestCase(unittest.TestCase):
- jwtcc_pem_text = "MD2gBzAFFgNmb2+hMjAwMBkWA2ZvbzASDARmb28xDARmb28yDARmb28zMBMWA2JhcjAMDARiYXIxDARiYXIy"
+ jwtcc_pem_text = ("MD2gBzAFFgNmb2+hMjAwMBkWA2ZvbzASDARmb28xDARmb28yDARmb2"
+ "8zMBMWA2JhcjAMDARiYXIxDARiYXIy")
def setUp(self):
self.asn1Spec = rfc8226.JWTClaimConstraints()
def testDerCodec(self):
substrate = pem.readBase64fromText(self.jwtcc_pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
class TNAuthorizationListTestCase(unittest.TestCase):
- tnal_pem_text = "MCugBxYFYm9ndXOhEjAQFgo1NzE1NTUxMjEyAgIDFKIMFgo3MDM1NTUxMjEy"
+ tnal_pem_text = ("MCugBxYFYm9ndXOhEjAQFgo1NzE1NTUxMjEyAgIDFKIMFgo3MDM1NTU"
+ "xMjEy")
def setUp(self):
self.asn1Spec = rfc8226.TNAuthorizationList()
def testDerCodec(self):
substrate = pem.readBase64fromText(self.tnal_pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
class CertificateOpenTypesTestCase(unittest.TestCase):
@@ -72,28 +73,32 @@ yEFWA6G95b/HbtPMTjLpPKtrOjhofc4LyVCDYhFhKzpvHh1qeA==
def testDerCodec(self):
substrate = pem.readBase64fromText(self.cert_pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
- extn_list = [ ]
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+
+ extn_list = []
for extn in asn1Object['tbsCertificate']['extensions']:
extn_list.append(extn['extnID'])
if extn['extnID'] in rfc5280.certificateExtensionsMap.keys():
- extnValue, rest = der_decoder.decode(extn['extnValue'],
+ extnValue, rest = der_decoder.decode(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert der_encoder.encode(extnValue) == extn['extnValue']
+
+ self.assertEqual(
+ extn['extnValue'], der_encoder.encode(extnValue))
if extn['extnID'] == rfc8226.id_pe_TNAuthList:
- assert extnValue[0]['spc'] == 'fake'
+ self.assertEqual('fake', extnValue[0]['spc'])
+
+ self.assertIn(rfc8226.id_pe_TNAuthList, extn_list)
- assert rfc8226.id_pe_TNAuthList in extn_list
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8358.py b/tests/test_rfc8358.py
index bbe37e0..48a01ce 100644
--- a/tests/test_rfc8358.py
+++ b/tests/test_rfc8358.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5652
from pyasn1_modules import rfc8358
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class P7STestCase(unittest.TestCase):
pem_text_list = (
@@ -173,28 +168,28 @@ dZlmZDkyeXJLpkNjRAsG6V82raZd9g==
oids = [ ]
for pem_text in self.pem_text_list:
substrate = pem.readBase64fromText(pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc5652.id_signedData, asn1Object['contentType'])
- assert asn1Object['contentType'] == rfc5652.id_signedData
- sd, rest = der_decode(asn1Object['content'], asn1Spec=rfc5652.SignedData())
- assert not rest
- assert sd.prettyPrint()
- assert der_encode(sd) == asn1Object['content']
+ sd, rest = der_decoder(asn1Object['content'], asn1Spec=rfc5652.SignedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(sd.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(sd))
oids.append(sd['encapContentInfo']['eContentType'])
- assert rfc8358.id_ct_asciiTextWithCRLF in oids
- assert rfc8358.id_ct_pdf in oids
- assert rfc8358.id_ct_xml in oids
+ self.assertIn(rfc8358.id_ct_asciiTextWithCRLF, oids)
+ self.assertIn(rfc8358.id_ct_pdf, oids)
+ self.assertIn(rfc8358.id_ct_xml, oids)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8360.py b/tests/test_rfc8360.py
index 95e2c80..56a76cf 100644
--- a/tests/test_rfc8360.py
+++ b/tests/test_rfc8360.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc8360
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class CertExtnsTestCase(unittest.TestCase):
extns_pem_text = """\
@@ -441,28 +436,29 @@ AgMA++8wCgIDAwAAAgMDNZs=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.extns_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
- oids = [ ]
+ oids = []
for extn in asn1Object:
oids.append(extn['extnID'])
- extn_value, rest = der_decode(extn['extnValue'],
+ extn_value, rest = der_decoder(
+ extn['extnValue'],
rfc5280.certificateExtensionsMap[extn['extnID']])
- assert not rest
- assert extn_value.prettyPrint()
- assert der_encode(extn_value) == extn['extnValue']
- assert rfc8360.id_pe_ipAddrBlocks_v2 in oids
- assert rfc8360.id_pe_autonomousSysIds_v2 in oids
+ self.assertFalse(rest)
+ self.assertTrue(extn_value.prettyPrint())
+ self.assertEqual(extn['extnValue'], der_encoder(extn_value))
+
+ self.assertIn(rfc8360.id_pe_ipAddrBlocks_v2, oids)
+ self.assertIn(rfc8360.id_pe_autonomousSysIds_v2, oids)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8398.py b/tests/test_rfc8398.py
index 0b27d4a..b524831 100644
--- a/tests/test_rfc8398.py
+++ b/tests/test_rfc8398.py
@@ -5,19 +5,15 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc8398
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class EAITestCase(unittest.TestCase):
pem_text = "oCAGCCsGAQUFBwgJoBQMEuiAgeW4q0BleGFtcGxlLmNvbQ=="
@@ -27,41 +23,44 @@ class EAITestCase(unittest.TestCase):
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['otherName']['type-id'] in rfc5280.anotherNameMap.keys()
- assert asn1Object['otherName']['type-id'] == rfc8398.id_on_SmtpUTF8Mailbox
-
- eai, rest = der_decode(asn1Object['otherName']['value'],
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertIn(asn1Object['otherName']['type-id'],
+ rfc5280.anotherNameMap)
+ self.assertEqual(rfc8398.id_on_SmtpUTF8Mailbox,
+ asn1Object['otherName']['type-id'])
+
+ eai, rest = der_decoder(
+ asn1Object['otherName']['value'],
asn1Spec=rfc5280.anotherNameMap[asn1Object['otherName']['type-id']])
- assert not rest
- assert eai.prettyPrint()
- assert der_encode(eai) == asn1Object['otherName']['value']
- assert eai[0] == u'\u8001'
- assert eai[1] == u'\u5E2B'
+ self.assertFalse(rest)
+ self.assertTrue(eai.prettyPrint())
+ self.assertEqual(asn1Object['otherName']['value'], der_encoder(eai))
+ self.assertEqual(u'\u8001', eai[0])
+ self.assertEqual(u'\u5E2B', eai[1])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
- assert asn1Object['otherName']['type-id'] == rfc8398.id_on_SmtpUTF8Mailbox
- assert asn1Object['otherName']['value'][0] == u'\u8001'
- assert asn1Object['otherName']['value'][1] == u'\u5E2B'
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(
+ rfc8398.id_on_SmtpUTF8Mailbox, asn1Object['otherName']['type-id'])
+ self.assertEqual(u'\u8001', asn1Object['otherName']['value'][0])
+
+ self.assertEqual(u'\u5E2B', asn1Object['otherName']['value'][1])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8410.py b/tests/test_rfc8410.py
index e37bad0..d6df485 100644
--- a/tests/test_rfc8410.py
+++ b/tests/test_rfc8410.py
@@ -5,8 +5,8 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
@@ -15,14 +15,10 @@ 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"
+ no_pub_key_pem_text = ("MC4CAQAwBQYDK2VwBCIEINTuctv5E1hK1bbY8fdp+K06/nwo"
+ "y/HU++CXqI9EdVhC")
def setUp(self):
self.asn1Spec = rfc5208.PrivateKeyInfo()
@@ -30,18 +26,19 @@ class PrivateKeyTestCase(unittest.TestCase):
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
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(
+ rfc8410.id_Ed25519, asn1Object['privateKeyAlgorithm']['algorithm'])
+ self.assertTrue(asn1Object['privateKey'].isValue)
+ self.assertEqual(
+ "0x0420d4ee", asn1Object['privateKey'].prettyPrint()[0:10])
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8418.py b/tests/test_rfc8418.py
index 46ac689..b5e8d3e 100644
--- a/tests/test_rfc8418.py
+++ b/tests/test_rfc8418.py
@@ -5,8 +5,8 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
@@ -15,11 +15,6 @@ 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=="
@@ -29,18 +24,20 @@ class KeyAgreeAlgTestCase(unittest.TestCase):
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
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(
+ rfc8418.dhSinglePass_stdDH_hkdf_sha384_scheme,
+ asn1Object['algorithm'])
+ self.assertTrue(asn1Object['parameters'].isValue)
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8419.py b/tests/test_rfc8419.py
index ee566c5..3ad05cb 100644
--- a/tests/test_rfc8419.py
+++ b/tests/test_rfc8419.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc8419
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class Ed25519TestCase(unittest.TestCase):
alg_id_1_pem_text = "MAUGAytlcA=="
@@ -29,12 +24,13 @@ class Ed25519TestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.alg_id_1_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert asn1Object['algorithm'] == rfc8419.id_Ed25519
- assert not asn1Object['parameters'].isValue
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc8419.id_Ed25519, asn1Object['algorithm'])
+ self.assertFalse(asn1Object['parameters'].isValue)
+ self.assertEqual(substrate, der_encoder(asn1Object))
class Ed448TestCase(unittest.TestCase):
@@ -45,12 +41,14 @@ class Ed448TestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.alg_id_2_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert asn1Object['algorithm'] == rfc8419.id_Ed448
- assert not asn1Object['parameters'].isValue
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc8419.id_Ed448, asn1Object['algorithm'])
+ self.assertFalse(asn1Object['parameters'].isValue)
+ self.assertEqual(substrate, der_encoder(asn1Object))
class SHA512TestCase(unittest.TestCase):
@@ -61,12 +59,14 @@ class SHA512TestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.alg_id_3_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert asn1Object['algorithm'] == rfc8419.id_sha512
- assert not asn1Object['parameters'].isValue
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc8419.id_sha512, asn1Object['algorithm'])
+ self.assertFalse(asn1Object['parameters'].isValue)
+ self.assertEqual(substrate, der_encoder(asn1Object))
class SHAKE256TestCase(unittest.TestCase):
@@ -77,12 +77,13 @@ class SHAKE256TestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.alg_id_4_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert asn1Object['algorithm'] == rfc8419.id_shake256
- assert not asn1Object['parameters'].isValue
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc8419.id_shake256, asn1Object['algorithm'])
+ self.assertFalse(asn1Object['parameters'].isValue)
+ self.assertEqual(substrate, der_encoder(asn1Object))
class SHAKE256LENTestCase(unittest.TestCase):
@@ -93,36 +94,37 @@ class SHAKE256LENTestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.alg_id_5_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert asn1Object['algorithm'] == rfc8419.id_shake256_len
- assert asn1Object['parameters'].isValue
- assert der_encode(asn1Object) == substrate
-
- param, rest = der_decode(asn1Object['parameters'],
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc8419.id_shake256_len, asn1Object['algorithm'])
+ self.assertTrue(asn1Object['parameters'].isValue)
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ param, rest = der_decoder(
+ asn1Object['parameters'],
asn1Spec=rfc5280.algorithmIdentifierMap[asn1Object['algorithm']])
- assert not rest
- assert param.prettyPrint()
- assert der_encode(param) == asn1Object['parameters']
- assert param == 512
+
+ self.assertFalse(rest)
+ self.assertTrue(param.prettyPrint())
+ self.assertEqual(asn1Object['parameters'], der_encoder(param))
+ self.assertEqual(512, param)
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.alg_id_5_pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert asn1Object['algorithm'] == rfc8419.id_shake256_len
- assert asn1Object['parameters'] == 512
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(rfc8419.id_shake256_len, asn1Object['algorithm'])
+ self.assertEqual(512, asn1Object['parameters'])
+ self.assertEqual(substrate, der_encoder(asn1Object))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8479.py b/tests/test_rfc8479.py
index 60e0ea2..e5b135f 100644
--- a/tests/test_rfc8479.py
+++ b/tests/test_rfc8479.py
@@ -5,10 +5,10 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
-
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1.type import univ
from pyasn1_modules import pem
@@ -17,11 +17,6 @@ from pyasn1_modules import rfc5652
from pyasn1_modules import rfc5958
from pyasn1_modules import rfc8479
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class ValidationParmTestCase(unittest.TestCase):
pem_text = """\
@@ -59,46 +54,55 @@ BCCK9DKMh7687DHjA7j1U37/y2qR2UcITZmjaYI7NvAUYg==
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for attr in asn1Object['attributes']:
- assert attr['attrType'] in rfc5652.cmsAttributesMap.keys()
+ self.assertIn(attr['attrType'], rfc5652.cmsAttributesMap)
+
if attr['attrType'] == rfc8479.id_attr_validation_parameters:
- av, rest = der_decode(attr['attrValues'][0],
+ av, rest = der_decoder(
+ attr['attrValues'][0],
asn1Spec=rfc5652.cmsAttributesMap[attr['attrType']])
- assert not rest
- assert av.prettyPrint()
- assert der_encode(av) == attr['attrValues'][0]
+ self.assertFalse(rest)
+ self.assertTrue(av.prettyPrint())
+ self.assertEqual(attr['attrValues'][0], der_encoder(av))
+ self.assertEqual(rfc4055.id_sha384, av['hashAlg'])
+
+ seed = univ.OctetString(hexValue='8af4328c87bebcec31e303b8f55'
+ '37effcb6a91d947084d99a36982'
+ '3b36f01462')
- assert av['hashAlg'] == rfc4055.id_sha384
- seed = univ.OctetString(hexValue='8af4328c87bebcec31e303b8f5537effcb6a91d947084d99a369823b36f01462')
- assert av['seed'] == seed
+ self.assertEqual(seed, av['seed'])
def testOpenTypes(self):
substrate = pem.readBase64fromText(self.pem_text)
- asn1Object, rest = der_decode(substrate,
- asn1Spec=self.asn1Spec,
- decodeOpenTypes=True)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=self.asn1Spec, decodeOpenTypes=True)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for attr in asn1Object['attributes']:
- assert attr['attrType'] in rfc5652.cmsAttributesMap.keys()
+ self.assertIn(attr['attrType'], rfc5652.cmsAttributesMap)
if attr['attrType'] == rfc8479.id_attr_validation_parameters:
av = attr['attrValues'][0]
- assert av['hashAlg'] == rfc4055.id_sha384
- seed = univ.OctetString(hexValue='8af4328c87bebcec31e303b8f5537effcb6a91d947084d99a369823b36f01462')
- assert av['seed'] == seed
+
+ self.assertEqual(av['hashAlg'], rfc4055.id_sha384)
+
+ seed = univ.OctetString(hexValue='8af4328c87bebcec31e303b8f553'
+ '7effcb6a91d947084d99a369823b'
+ '36f01462')
+
+ self.assertEqual(seed, av['seed'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8494.py b/tests/test_rfc8494.py
index a2db6a0..2951e39 100644
--- a/tests/test_rfc8494.py
+++ b/tests/test_rfc8494.py
@@ -5,18 +5,14 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc8494
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class CompresssedDataTestCase(unittest.TestCase):
pem_text = """\
@@ -35,21 +31,25 @@ EiIPVQPtvBuLBxjW5qx3TbXXo6vHJ1OhhLY=
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
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(
+ 0, asn1Object['compressionAlgorithm']['algorithmID-ShortForm'])
- assert asn1Object['compressionAlgorithm']['algorithmID-ShortForm'] == 0
cci = asn1Object['compressedContentInfo']
- assert cci['unnamed']['contentType-ShortForm'] == 25
- assert cci['compressedContent'].prettyPrint()[:12] == '0x789c6d8fd1'
+
+ self.assertEqual(
+ 25, cci['unnamed']['contentType-ShortForm'])
+ self.assertEqual(
+ '0x789c6d8fd1', cci['compressedContent'].prettyPrint()[:12])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8520.py b/tests/test_rfc8520.py
index 884ef09..da615dc 100644
--- a/tests/test_rfc8520.py
+++ b/tests/test_rfc8520.py
@@ -5,21 +5,16 @@
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
-
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc8520
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class MUDCertTestCase(unittest.TestCase):
mud_cert_pem_text = """\
@@ -58,54 +53,63 @@ izaUuU1EEwgOMELjeFL62Ssvq8X+x6hZFCLygI7GNeitlblNhCXhFFurqMs=
def testDerCodec(self):
substrate = pem.readBase64fromText(self.mud_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
- extn_list = [ ]
+ extn_list = []
for extn in asn1Object['tbsCertificate']['extensions']:
extn_list.append(extn['extnID'])
if extn['extnID'] == rfc8520.id_pe_mudsigner:
- mudsigner, rest = der_decode(extn['extnValue'], rfc8520.MUDsignerSyntax())
- assert der_encode(mudsigner) == extn['extnValue']
+ mudsigner, rest = der_decoder(
+ extn['extnValue'], rfc8520.MUDsignerSyntax())
+
+ self.assertEqual(extn['extnValue'], der_encoder(mudsigner))
c = rfc5280.X520countryName(value="CH")
- assert mudsigner[0][0][0]['value'] == der_encode(c)
+
+ self.assertEqual(mudsigner[0][0][0]['value'], der_encoder(c))
+
e = rfc5280.EmailAddress(value="ascertia@ofcourseimright.com")
- assert mudsigner[0][1][0]['value'] == der_encode(e)
+
+ self.assertEqual(mudsigner[0][1][0]['value'], der_encoder(e))
+
cn = rfc5280.X520CommonName()
cn['printableString'] = "Eliot Lear"
- assert mudsigner[0][2][0]['value'] == der_encode(cn)
+
+ self.assertEqual(mudsigner[0][2][0]['value'], der_encoder(cn))
if extn['extnID'] == rfc8520.id_pe_mud_url:
- mudurl, rest = der_decode(extn['extnValue'], rfc8520.MUDURLSyntax())
- assert der_encode(mudurl) == extn['extnValue']
+ mudurl, rest = der_decoder(
+ extn['extnValue'], rfc8520.MUDURLSyntax())
- assert mudurl[-5:] == ".json"
+ self.assertEqual(extn['extnValue'], der_encoder(mudurl))
+ self.assertEqual(".json", mudurl[-5:])
- assert rfc8520.id_pe_mudsigner in extn_list
- assert rfc8520.id_pe_mud_url in extn_list
+ self.assertIn(rfc8520.id_pe_mudsigner, extn_list)
+ self.assertIn(rfc8520.id_pe_mud_url, extn_list)
def testExtensionsMap(self):
substrate = pem.readBase64fromText(self.mud_cert_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
for extn in asn1Object['tbsCertificate']['extensions']:
if extn['extnID'] in rfc5280.certificateExtensionsMap.keys():
- extnValue, rest = der_decode(extn['extnValue'],
+ extnValue, rest = der_decoder(
+ extn['extnValue'],
asn1Spec=rfc5280.certificateExtensionsMap[extn['extnID']])
- assert der_encode(extnValue) == extn['extnValue']
+ self.assertEqual(extn['extnValue'], der_encoder(extnValue))
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8619.py b/tests/test_rfc8619.py
index 05eee6a..cd54db6 100644
--- a/tests/test_rfc8619.py
+++ b/tests/test_rfc8619.py
@@ -5,6 +5,7 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
from pyasn1.codec.der import decoder as der_decoder
from pyasn1.codec.der import encoder as der_encoder
@@ -13,11 +14,6 @@ from pyasn1_modules import pem
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc8619
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class HKDFSHA256TestCase(unittest.TestCase):
alg_id_1_pem_text = "MA0GCyqGSIb3DQEJEAMc"
@@ -28,14 +24,15 @@ class HKDFSHA256TestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.alg_id_1_pem_text)
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
-
- assert asn1Object['algorithm'] == rfc8619.id_alg_hkdf_with_sha256
+ self.assertEqual(
+ rfc8619.id_alg_hkdf_with_sha256, asn1Object['algorithm'])
class HKDFSHA384TestCase(unittest.TestCase):
@@ -47,14 +44,13 @@ class HKDFSHA384TestCase(unittest.TestCase):
def testDerCodec(self):
substrate = pem.readBase64fromText(self.alg_id_1_pem_text)
-
asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
-
- assert asn1Object['algorithm'] == rfc8619.id_alg_hkdf_with_sha384
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+ self.assertEqual(
+ rfc8619.id_alg_hkdf_with_sha384, asn1Object['algorithm'])
class HKDFSHA512TestCase(unittest.TestCase):
@@ -67,19 +63,18 @@ class HKDFSHA512TestCase(unittest.TestCase):
substrate = pem.readBase64fromText(self.alg_id_1_pem_text)
- asn1Object, rest = der_decoder.decode(substrate, asn1Spec=self.asn1Spec)
+ asn1Object, rest = der_decoder.decode(
+ substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encoder.encode(asn1Object) == substrate
-
- assert asn1Object['algorithm'] == rfc8619.id_alg_hkdf_with_sha512
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder.encode(asn1Object))
+ self.assertEqual(
+ rfc8619.id_alg_hkdf_with_sha512, asn1Object['algorithm'])
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8649.py b/tests/test_rfc8649.py
index e7ca72b..67f8f9f 100644
--- a/tests/test_rfc8649.py
+++ b/tests/test_rfc8649.py
@@ -5,20 +5,16 @@
# License: http://snmplabs.com/pyasn1/license.html
#
import sys
+import unittest
-from pyasn1.codec.der.decoder import decode as der_decode
-from pyasn1.codec.der.encoder import encode as der_encode
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
from pyasn1_modules import pem
from pyasn1_modules import rfc4055
from pyasn1_modules import rfc5280
from pyasn1_modules import rfc8649
-try:
- import unittest2 as unittest
-except ImportError:
- import unittest
-
class RootCertificateExtnTestCase(unittest.TestCase):
extn_pem_text = """\
@@ -32,33 +28,33 @@ GANG
def testDerCodec(self):
substrate = pem.readBase64fromText(self.extn_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
- assert asn1Object.prettyPrint()
- assert der_encode(asn1Object) == substrate
-
- assert asn1Object['extnID'] == rfc8649.id_ce_hashOfRootKey
- hashed_root_key, rest = der_decode(asn1Object['extnValue'],
- rfc8649.HashedRootKey())
- assert not rest
- assert hashed_root_key.prettyPrint()
- assert der_encode(hashed_root_key) == asn1Object['extnValue']
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+ self.assertEqual(rfc8649.id_ce_hashOfRootKey, asn1Object['extnID'])
- assert hashed_root_key['hashAlg']['algorithm'] == rfc4055.id_sha512
+ hashed_root_key, rest = der_decoder(
+ asn1Object['extnValue'], rfc8649.HashedRootKey())
+
+ self.assertFalse(rest)
+ self.assertTrue(hashed_root_key.prettyPrint())
+ self.assertEqual(asn1Object['extnValue'], der_encoder(hashed_root_key))
+ self.assertEqual(
+ rfc4055.id_sha512, hashed_root_key['hashAlg']['algorithm'])
def testExtensionsMap(self):
substrate = pem.readBase64fromText(self.extn_pem_text)
- asn1Object, rest = der_decode(substrate, asn1Spec=self.asn1Spec)
- assert not rest
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
- assert asn1Object['extnID'] == rfc8649.id_ce_hashOfRootKey
- assert asn1Object['extnID'] in rfc5280.certificateExtensionsMap.keys()
+ self.assertFalse(rest)
+ self.assertEqual(rfc8649.id_ce_hashOfRootKey, asn1Object['extnID'])
+ self.assertIn(asn1Object['extnID'], rfc5280.certificateExtensionsMap)
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
if __name__ == '__main__':
- import sys
-
result = unittest.TextTestRunner(verbosity=2).run(suite)
sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8692.py b/tests/test_rfc8692.py
new file mode 100644
index 0000000..416b59c
--- /dev/null
+++ b/tests/test_rfc8692.py
@@ -0,0 +1,55 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5751
+from pyasn1_modules import rfc8692
+
+
+class AlgorithmIdentifierTestCase(unittest.TestCase):
+ pem_text = """\
+MEowCwYJYIZIAWUDBAILMAsGCWCGSAFlAwQCDDAKBggrBgEFBQcGHjAKBggrBgEF
+BQcGHzAKBggrBgEFBQcGIDAKBggrBgEFBQcGIQ==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5751.SMIMECapabilities()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ oid_list = (
+ rfc8692.id_shake128,
+ rfc8692.id_shake256,
+ rfc8692.id_RSASSA_PSS_SHAKE128,
+ rfc8692.id_RSASSA_PSS_SHAKE256,
+ rfc8692.id_ecdsa_with_shake128,
+ rfc8692.id_ecdsa_with_shake256,
+ )
+
+ count = 0
+ for algid in asn1Object:
+ self.assertTrue(algid['capabilityID'] in oid_list)
+ count += 1
+
+ self.assertTrue(len(oid_list), count)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8696.py b/tests/test_rfc8696.py
new file mode 100644
index 0000000..119f658
--- /dev/null
+++ b/tests/test_rfc8696.py
@@ -0,0 +1,193 @@
+#
+# 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
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1.type import univ
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5083
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc8696
+
+
+class KeyTransPSKTestCase(unittest.TestCase):
+ key_trans_psk_pem_text = """\
+MIICigYLKoZIhvcNAQkQARegggJ5MIICdQIBADGCAiekggIjBgsqhkiG9w0BCRANATCCAhIC
+AQAEE3B0Zi1rbWM6MTM2MTQxMjIxMTIwDQYLKoZIhvcNAQkQAx0wCwYJYIZIAWUDBAEtMIIB
+sDCCAawCAQKAFJ7rZ8m5WnTUTS8WOWaA6AG1y6ScMA0GCSqGSIb3DQEBAQUABIIBgKo/Hkhu
+eoOdn1/cIEpt38NbEEdSC586IWcG+0l+ND9pcmQvvKvscpvFFVAjqLjvoXGatmSazr2Q4BVS
+yWKm0JqlyVWEAhRsU7wNlD7zRAKI8+obWpU57gjEKs13D8gb1PI2YPZWajN1Ye+yHSF6h+fb
+7YtaQepxTGHYF0LgHaAC8cqtgwIRW8N4Gnvl0Uuz+YEZXUX0I8fvJG6MKCEFzwHvfrfPb3rW
+B8k7BHfekRpY+793JNrjSP2lY+W0fhqBN8dALDKGqlbUCyojMQkQiD/iXSBRbZWiJ1CE92iT
+x7Ji9irq8rhYDNoDP2vghJUaepoZgIJwPWqhoTH+KRPqHTjLnnbi/TGzEdeO5h0C9Gc0DVzs
+9OHvHknQ7mSxPT9xKMXGztVT+P3a9ct6TaMotpMqL9cuZxTYGpHMYNkLSUXFSadAGFrgP7QV
+FGwC/Z/YomEzSLPgZi8HnVHsAGkJzXxmM/PJBu4dAXcKjEv/GgpmaS2B7gKHUpTyyAgdsBsy
+2AQo6glHJQ+mbNUlWV5Sppqq3ojvzxsPEIq+KRBgORsc31kH82tAZ+RTQjA3BgkqhkiG9w0B
+BwEwGwYJYIZIAWUDBAEuMA4EDMr+ur76ztut3sr4iIANmvLRbyFUf87+2bPvLQQMoOWSXMGE
+4BckY8RM
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.key_trans_psk_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(
+ rfc5083.id_ct_authEnvelopedData, asn1Object['contentType'])
+
+ aed, rest = der_decoder(
+ asn1Object['content'],
+ asn1Spec=rfc5083.AuthEnvelopedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(aed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(aed))
+ self.assertEqual(0, aed['version'])
+
+ ri = aed['recipientInfos'][0]
+ self.assertEqual(rfc8696.id_ori_keyTransPSK, ri['ori']['oriType'])
+
+ ktpsk, rest = der_decoder(
+ ri['ori']['oriValue'],
+ asn1Spec=rfc8696.KeyTransPSKRecipientInfo())
+
+ self.assertFalse(rest)
+ self.assertTrue(ktpsk.prettyPrint())
+ self.assertEqual(ri['ori']['oriValue'], der_encoder(ktpsk))
+ self.assertEqual(0, ktpsk['version'])
+
+ ktri = ktpsk['ktris'][0]
+ self.assertEqual(2, ktri['version'])
+
+ def testOtherRecipientInfoMap(self):
+ substrate = pem.readBase64fromText(self.key_trans_psk_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(
+ rfc5083.id_ct_authEnvelopedData, asn1Object['contentType'])
+
+ aed, rest = der_decoder(
+ asn1Object['content'],
+ asn1Spec=rfc5083.AuthEnvelopedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(aed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(aed))
+ self.assertEqual(0, aed['version'])
+
+ ri = aed['recipientInfos'][0]
+ self.assertIn(ri['ori']['oriType'], rfc5652.otherRecipientInfoMap)
+
+ ori, rest = der_decoder(
+ ri['ori']['oriValue'],
+ asn1Spec=rfc5652.otherRecipientInfoMap[ri['ori']['oriType']])
+
+ self.assertFalse(rest)
+ self.assertTrue(ori.prettyPrint())
+ self.assertEqual(ri['ori']['oriValue'], der_encoder(ori))
+
+class KeyAgreePSKTestCase(unittest.TestCase):
+ key_agree_psk_pem_text = """\
+MIIBRwYLKoZIhvcNAQkQARegggE2MIIBMgIBADGB5aSB4gYLKoZIhvcNAQkQDQIwgdICAQAE
+FHB0Zi1rbWM6MjE2ODQwMTEwMTIxoFWhUzATBgYrgQQBCwEGCWCGSAFlAwQBLQM8AAQ5G0Em
+Jk/2ks8sXY1kzbuG3Uu3ttWwQRXALFDJICjvYfr+yTpOQVkchm88FAh9MEkw4NKctokKNgps
+MA0GCyqGSIb3DQEJEAMdMAsGCWCGSAFlAwQBLTBEMEKgFgQU6CGLmLi32Gtenr3IrrjE7NwF
+xSkEKCKf4LReQAA+fYJE7Bt+f/ssjcoWw29XNyIlU6cSY6kr3giGamAtY/QwNwYJKoZIhvcN
+AQcBMBsGCWCGSAFlAwQBLjAOBAzbrd7K+IjK/rq++s6ADfxtb4I+PtLSCdDG/88EDFUCYMQu
+WylxlCbB/w==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.key_agree_psk_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(
+ rfc5083.id_ct_authEnvelopedData, asn1Object['contentType'])
+
+ aed, rest = der_decoder(
+ asn1Object['content'],
+ asn1Spec=rfc5083.AuthEnvelopedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(aed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(aed))
+ self.assertEqual(0, aed['version'])
+
+ ri = aed['recipientInfos'][0]
+ self.assertEqual(rfc8696.id_ori_keyAgreePSK, ri['ori']['oriType'])
+
+ kapsk, rest = der_decoder(
+ ri['ori']['oriValue'],
+ asn1Spec=rfc8696.KeyAgreePSKRecipientInfo())
+
+ self.assertFalse(rest)
+ self.assertTrue(kapsk.prettyPrint())
+ self.assertEqual(ri['ori']['oriValue'], der_encoder(kapsk))
+ self.assertEqual(0, kapsk['version'])
+
+ rek = kapsk['recipientEncryptedKeys'][0]
+ ski = rek['rid']['rKeyId']['subjectKeyIdentifier']
+ expected_ski = univ.OctetString(
+ hexValue='e8218b98b8b7d86b5e9ebdc8aeb8c4ecdc05c529')
+
+ self.assertEqual(expected_ski, ski)
+
+ def testOtherRecipientInfoMap(self):
+ substrate = pem.readBase64fromText(self.key_agree_psk_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(
+ rfc5083.id_ct_authEnvelopedData, asn1Object['contentType'])
+
+ aed, rest = der_decoder(
+ asn1Object['content'],
+ asn1Spec=rfc5083.AuthEnvelopedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(aed.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(aed))
+ self.assertEqual(0, aed['version'])
+
+ ri = aed['recipientInfos'][0]
+ self.assertIn(ri['ori']['oriType'], rfc5652.otherRecipientInfoMap)
+
+ ori, rest = der_decoder(
+ ri['ori']['oriValue'],
+ asn1Spec=rfc5652.otherRecipientInfoMap[ri['ori']['oriType']])
+
+ self.assertFalse(rest)
+ self.assertTrue(ori.prettyPrint())
+ self.assertEqual(ri['ori']['oriValue'], der_encoder(ori))
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ unittest.TextTestRunner(verbosity=2).run(suite)
diff --git a/tests/test_rfc8702.py b/tests/test_rfc8702.py
new file mode 100644
index 0000000..d6303cf
--- /dev/null
+++ b/tests/test_rfc8702.py
@@ -0,0 +1,140 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2020, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1.type import univ
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc2985
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc6211
+from pyasn1_modules import rfc8702
+
+
+class AlgorithmIdentifierTestCase(unittest.TestCase):
+ pem_text = """\
+MEowCwYJYIZIAWUDBAILMAsGCWCGSAFlAwQCDDAKBggrBgEFBQcGHjAKBggrBgEF
+BQcGHzAKBggrBgEFBQcGIDAKBggrBgEFBQcGIQ==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc2985.SMIMECapabilities()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ oid_list = (
+ rfc8702.id_shake128,
+ rfc8702.id_shake256,
+ rfc8702.id_RSASSA_PSS_SHAKE128,
+ rfc8702.id_RSASSA_PSS_SHAKE256,
+ rfc8702.id_ecdsa_with_shake128,
+ rfc8702.id_ecdsa_with_shake256,
+ )
+
+ for algid in asn1Object:
+ self.assertIn(algid['algorithm'], oid_list)
+
+
+class AuthenticatedDataTestCase(unittest.TestCase):
+ auth_message_pem_text = """\
+MIIDqgYLKoZIhvcNAQkQAQKgggOZMIIDlQIBADGCAk8wggJLAgEAMDMwJjEUMBIG
+A1UECgwLZXhhbXBsZS5jb20xDjAMBgNVBAMMBUFsaWNlAgkAg/ULtwvVxA4wDQYJ
+KoZIhvcNAQEBBQAEggIAdZphtN3x8a8kZoAFY15HYRD6JyPBueRUhLbTPoOH3pZ9
+xeDK+zVXGlahl1y1UOe+McEx2oD7cxAkhFuruNZMrCYEBCTZMwVhyEOZlBXdZEs8
+rZUHL3FFE5PJnygsSIO9DMxd1UuTFGTgCm5V5ZLFGmjeEGJRbsfTyo52S7iseJqI
+N3dl743DbApu0+yuUoXKxqKdUFlEVxmhvc+Qbg/zfiwu8PTsYiUQDMBi4cdIlju8
+iLjj389xQHNyndXHWD51is89GG8vpBe+IsN8mnbGtCcpqtJ/c65ErJhHTR7rSJSM
+EqQD0LPOCKIY1q9FaSSJfMXJZk9t/rPxgUEVjfw7hAkKpgOAqoZRN+FpnFyBl0Fn
+nXo8kLp55tfVyNibtUpmdCPkOwt9b3jAtKtnvDQ2YqY1/llfEUnFOVDKwuC6MYwi
+fm92qNlAQA/T0+ocjs6gA9zOLx+wD1zqM13hMD/L+T2OHL/WgvGb62JLrNHXuPWA
+8RShO4kIlPtARKXap2S3+MX/kpSUUrNa65Y5uK1jwFFclczG+CPCIBBn6iJiQT/v
+OX1I97YUP4Qq6OGkjK064Bq6o8+e5+NmIOBcygYRv6wA7vGkmPLSWbnw99qD728b
+Bh84fC3EjItdusqGIwjzL0eSUWXJ5eu0Z3mYhJGN1pe0R/TEB5ibiJsMLpWAr3gw
+FQYJYIZIAWUDBAITMAgEBnB5YXNuMaELBglghkgBZQMEAgswNQYJKoZIhvcNAQcB
+oCgEJldhdHNvbiwgY29tZSBoZXJlIC0gSSB3YW50IHRvIHNlZSB5b3UuooG/MBgG
+CSqGSIb3DQEJAzELBgkqhkiG9w0BBwEwHAYJKoZIhvcNAQkFMQ8XDTE5MDkxOTEz
+NDEwMFowHwYJKoZIhvcNAQkEMRIEENiFx45okcgTCVIBhhgF+ogwLwYLKoZIhvcN
+AQkQAgQxIDAeDBFXYXRzb24sIGNvbWUgaGVyZQYJKoZIhvcNAQcBMDMGCSqGSIb3
+DQEJNDEmMCQwCwYJYIZIAWUDBAILohUGCWCGSAFlAwQCEzAIBAZweWFzbjEEIBxm
+7hx+iivDlWYp8iUmYYbc2xkpBAcTACkWH+KBRZuF
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.auth_message_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(rfc5652.id_ct_authData, asn1Object['contentType'])
+ ad, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.AuthenticatedData())
+
+ self.assertFalse(rest)
+ self.assertTrue(ad.prettyPrint())
+ self.assertEqual(asn1Object['content'], der_encoder(ad))
+
+ self.assertEqual(
+ rfc8702.id_shake128, ad['digestAlgorithm']['algorithm'])
+
+ ad_mac = ad['macAlgorithm']
+ self.assertEqual(
+ rfc8702.id_KMACWithSHAKE128, ad_mac['algorithm'])
+
+ kmac128_p, rest = der_decoder(
+ ad_mac['parameters'],
+ asn1Spec=rfc5280.algorithmIdentifierMap[ad_mac['algorithm']])
+
+ self.assertFalse(rest)
+ self.assertTrue(kmac128_p.prettyPrint())
+ self.assertEqual(ad_mac['parameters'], der_encoder(kmac128_p))
+
+ self.assertEqual(
+ univ.OctetString("pyasn1"), kmac128_p['customizationString'])
+
+ found_kmac128_params = False
+ for attr in ad['authAttrs']:
+ if attr['attrType'] == rfc6211.id_aa_cmsAlgorithmProtect:
+ av, rest = der_decoder(
+ attr['attrValues'][0],
+ asn1Spec=rfc6211.CMSAlgorithmProtection())
+
+ self.assertFalse(rest)
+ self.assertTrue(av.prettyPrint())
+ self.assertEqual(attr['attrValues'][0], der_encoder(av))
+
+ self.assertEqual(
+ rfc8702.id_shake128, av['digestAlgorithm']['algorithm'])
+
+ self.assertEqual(
+ rfc8702.id_KMACWithSHAKE128, av['macAlgorithm']['algorithm'])
+
+ found_kmac128_params = True
+
+ self.assertTrue(found_kmac128_params)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ import sys
+
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tests/test_rfc8708.py b/tests/test_rfc8708.py
new file mode 100644
index 0000000..049aead
--- /dev/null
+++ b/tests/test_rfc8708.py
@@ -0,0 +1,127 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley
+# Copyright (c) 2020, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+
+import sys
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5280
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc8708
+
+
+class HashSigPublicKeyTestCase(unittest.TestCase):
+ public_key_pem_text = """\
+MFAwDQYLKoZIhvcNAQkQAxEDPwAEPAAAAAIAAAAGAAAAA9CPq9SiCR/wqMtO2DTn
+RTQypYiFzZugQxI1Rmv/llHGySEkQE1F+lPPFhwo8a1ajg==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5280.SubjectPublicKeyInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.public_key_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(
+ asn1Object['algorithm']['algorithm'],
+ rfc8708.id_alg_hss_lms_hashsig)
+
+
+class HashSigSignedDataTestCase(unittest.TestCase):
+ signed_data_pem_text = """\
+MIIKfQYJKoZIhvcNAQcCoIIKbjCCCmoCAQMxADAtBgkqhkiG9w0BBwGgIAQe
+VGhpcyBpcyBzb21lIHNhbXBsZSBjb250ZW50Lg0KMYIKMjCCCi4CAQOABkhp
+TW9tITALBglghkgBZQMEAgGgMTAvBgkqhkiG9w0BCQQxIgQgF6DPgklChkQZ
+NfFTIwED50Du7vSlr2SKRDkhJIYWL8gwDQYLKoZIhvcNAQkQAxEEggnQAAAA
+AAAAAAEAAAADkSkd52zm4k0eKptgJmUZvIzoifgU3rD8AO3TEp3jq5v2DGW6
+SNGcy3dtMFWLhS9DutlHr2Iphd6AGwaL7RGA004g3b+BnpErvDqnGIPy5CZl
+u0Q1UlL2U9DEp6LaPrhZSv7LVR5odGEu9h8TvI/HCXs8IeaDW3S+mtaGOr+V
+sRLCwWpCOYQXBfErxfRJqCgJEtJjQ/KPdROB3u4yTRcFh8qyfHBJCN5Cphx7
+g/NkceH36hXJP/L7f2oFFMP9bloY7Tqyt9etZUKdlDiyrxZGCmdcmCJoj9SL
+hrkz+nIisCMKy3MjjZ+pT1XUOuv6QOCJcTezCDucuspflxyqJADXIbXnMn6B
+7H/vYfxuXCBWyRXLulOe00xNY2XaIAdJRGdm1oLuLWsNuv+v9stWiZGQT3j6
+AQlC0CV1PFno/TpAeTFUcKo+fxHOmDOfV7wGExWhOoh1+1c0eQjJujefNJMB
+9lgSFMCYcLcsOXN+xMRqlhmbZsrSmQvL5bsav96ZEHx/g7OkEenXupLA0RsG
+UrggIMHshcISeZAH6sYKPSVNYFx8ub9UVNgUvAxSygUei9UnDvTCUGAhs/1U
+ZZZnzwRwWh7BgyAb35mzl79jCRXgsZ84GFcZi9WtiWsQWoRN8/YM0d13o4NS
+6gtsCqOKdo21mAyQ7D9UnTZBWhlhRX1M9M14hblDGtkI02pvioJiVtKqNPiq
+BzGjV8Bg246A/v1hsRDOID+toMvgnneS8tBc279QGYessKBUWFvKjkzJFrui
+yv1WgFyyc+YxujldI+hqz26uYxgaWv4fCjYcu9X+/rcxwapgvSUgcdaJydnM
+Ht/oqgI1xlT3WPyJNlFa40QcO/BTuC7bzrX6j9H0tlSlbxJfakZwGuNL19o1
+tYSAnBhTkcz4OTVCTJAL1pgqK4zljUO/R+iPgvWavMKIh1HxXJB4EER4FF/L
+hFZMCqPdDN0EN5NOr+9n14ko34m+u/izqAKyAakF3eEi0ZISU52yEpajSvmA
+s8HIEbml3khWvmfH2W+FJ5thiPKCwfI4r68nfEL4Cbd+tDNQQVNieSBggWMB
+uPzWhjho+5IvRtLdXHDCxQ5cLOQsC+bE7q+8d1UG4vAS2RzpEmhc0vKj/R0Y
+ItqA9AVE0DcKkEqQTpvbpkfoeEOdyTKUPCDQIZSOlO7+H3PvMbdmUKrJ9DMJ
+1LmdDJiwHXb9YHXSCEUESszqVNxIcql8LbzwqZaAAct8IvnZOBgf1dOR8SjA
+3RBUwus1ph4uLzVTkWFqj4kpNfGx/nfcAcJMWPwbTKKPQKUwzjfCNOyy4pPV
+0HEDRR5YFF5wWfvFbpNqEIUfxhDKg8F/r5dbjzgnSSnzawQilxJyFp+XlOYW
+pU5gMDuGoISu2yCyLO/yShAHqKcJOofy+NBt+AIk0uZAQlGXDkJTmDXp+VBg
+ZnVOdMGOFFZMWEVR6pxEKiBPH72B+Vd16NAEJwPBslisrgN7f8neuZvYApG0
+jX+Kt7DrG4V4kIvXSB82luObdGQMoHsS9B4775mXkhn/tKpQNfavHXgaDfwu
+OSvUcFRvX6JhpA+7RJjJVwA85zWpYGPUJVHC/1Roc1GIH+4l885dHfLPAVCL
+GkuYhAPiqnOKPgsOfxlFakDLK+8EePw9ixr/0O2fz4sNgNnz0cMjyY7FmTBL
+E7kiyph3jBu2PHPFm7V8xPq0OTzu+wt6Wol/KK8lHEYF4dXmxpk/Rp8mAhTM
+OrK+UxZX/rEhgNMqiV3b15xjXXSzzv2zQ1MlfM6zdX3OeWF0djjj4TOGtd50
+LQjudbyhyZ8yJSWBvPcnrd9kzGf4Vd42x1/8EVsxlh8pLesJGbTTcfNKhSxL
+4oRppxB1iiLLlsmbsWrqSXee9+4GXMmk099+85HPZZWm2MFLDYD5MCOxs9Q3
+EjnamLZ6G2o3k2Iec2K8ExQICfHUFiz3Xqm/opVMO1AF57khY0QX8RsmTW+7
+jL+pOxTzyGj7qo2RolhjpsALRd65GXsPidNnb5jBYZY/xM4KrdBzoI67CX9A
+8gzDf/v+Ob0DF0Y1HWAZ+hGG4JNTrIdwuhWALnhoZNFlaoVOO0k/OsZ3upwD
+bYtbLqv0NPzcN1N/yOQhCRmB1N3pTI6fVQQN7AcIzzUxMVpNgk25yomzgE8N
+6FlBHVIEnKy3fVME5aokhb0TNU7RpGPWDYdSgcEuKltkCVZRObvB/QKu6HLM
+ErOdFtE0xnTqeIADeT84cIupofpnJPsguY8T/KJkzSPJa/MrZM5Pb3aw/cnk
+WkhczBk79aver+0v/4NyF/+n9e8khNPl8jQ0kayxKtIiYfXP2tXBuxLsmx7U
+cdm9qae446tt5uIkbUx4g9a58yCVDpEmZ0DG2/rWs8/lbeCqZliw3Ik7tuSe
+YiMfRtqA86MTf6ugKP6b9hF+zuSYxf0GfbZsvvYGQSgeCU+meiUKF7ckoav1
+LpfVoloCXq18TZ5hrRqnVpx2O6eb6F6Q9A7OJ205FmwCuNz3acJRXkq0IFQf
+fxs6faAXHE7cLaZY16Sal61qovvjsEPURnSVsG2j3GU2ed/gwfTiHmQKwFAF
+4ns49Wpt6TkX0QZ6sBtOHEhhDEjSxtl/CC8MWm9idDElxYCg56yRfi6aTuVG
+Bl8bYn7zvIVwDj+bDfvdzu3UvZUi1IDOylUDH6siBJDa7eEetRgLpTX+QIhQ
+5yqAyA/TQiJKO1PBsYXoVT6RZBQQiJr7+OWtDqAr+K+Bv34Daax5OUEIMavi
+eWzsJz/xLRH0cph04eobCfGRMoaJtYkCy6xORMkxQWtHzV4gAm1bgbQHoOKc
+quyB8cNShGMTLwBYmp+AIadBCfjb+B/igsH1i/PypSxWDji/1osYxM58O6Yb
+NmK1irtuh2PIVb2SUrqEB/2MvSr89bU5gwAAAAbtHOjG5DeRjUP7p72ThWlM
+QRgnA/a39wTe7dk4S6b4vDYslIZGs8mEiAPm2boffTln9wnN3TXcd9YDVvDD
+aAiQC0kctOy7q+wSjnyBpG5ipntXZAoKeL4cv33Z1BmhDNhobRZiGoCBa/21
+vcViEdcspwuB8RF9EpUpp1cM95z1KnAopIU47N07ONPV1i0mJGWVxPtzpSWl
+7SwwUk67HYzILgwZvEl3xomP+V/T0xCwuucWls75PGpVJFa/lunQdeODu3VD
+xnWEK6+/x824hIOzJ2wp1PCjQcLUBuQNRlO35NBFhRrPagoOqccQuAXM7UY1
+7owQc2Lw/I2AwU0KxJxRZwPSbRR1LzTBwNLEJHWBwYws9N5I6c6Um+fIiOnK
+6+SkFeKR/RB9IdwfCEsRWCCCSfKPT3x+kxuns70NgkpFcA==
+"""
+
+ def setUp(self):
+ self.asn1Spec = rfc5652.ContentInfo()
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.signed_data_pem_text)
+ asn1Object, rest = der_decoder(substrate, asn1Spec=self.asn1Spec)
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ self.assertEqual(asn1Object['contentType'], rfc5652.id_signedData)
+ sd, rest = der_decoder(
+ asn1Object['content'], asn1Spec=rfc5652.SignedData())
+
+ oid = sd['signerInfos'][0]['signatureAlgorithm']['algorithm']
+ self.assertEqual(rfc8708.id_alg_hss_lms_hashsig, oid)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ unittest.TextTestRunner(verbosity=2).run(suite)
diff --git a/tests/test_rfc8769.py b/tests/test_rfc8769.py
new file mode 100644
index 0000000..614f326
--- /dev/null
+++ b/tests/test_rfc8769.py
@@ -0,0 +1,134 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2020, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import sys
+import unittest
+
+from pyasn1.codec.der.decoder import decode as der_decoder
+from pyasn1.codec.der.encoder import encode as der_encoder
+
+from pyasn1_modules import pem
+from pyasn1_modules import rfc5652
+from pyasn1_modules import rfc8769
+
+
+class CBORContentTestCase(unittest.TestCase):
+ pem_text = """\
+MIIEHwYJKoZIhvcNAQcCoIIEEDCCBAwCAQMxDTALBglghkgBZQMEAgIwIQYLKoZIhvcNAQkQ
+ASygEgQQgw9kUnVzc/tADzMzMzMzM6CCAnwwggJ4MIIB/qADAgECAgkApbNUKBuwbjswCgYI
+KoZIzj0EAwMwPzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlZBMRAwDgYDVQQHDAdIZXJuZG9u
+MREwDwYDVQQKDAhCb2d1cyBDQTAeFw0xOTA1MjkxNDQ1NDFaFw0yMDA1MjgxNDQ1NDFaMHAx
+CzAJBgNVBAYTAlVTMQswCQYDVQQIEwJWQTEQMA4GA1UEBxMHSGVybmRvbjEQMA4GA1UEChMH
+RXhhbXBsZTEOMAwGA1UEAxMFQWxpY2UxIDAeBgkqhkiG9w0BCQEWEWFsaWNlQGV4YW1wbGUu
+Y29tMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE+M2fBy/sRA6V1pKFqecRTE8+LuAHtZxes1wm
+JZrBBg+bz7uYZfYQxI3dVB0YCSD6Mt3yXFlnmfBRwoqyArbjIBYrDbHBv2k8Csg2DhQ7qs/w
+to8hMKoFgkcscqIbiV7Zo4GUMIGRMAsGA1UdDwQEAwIHgDBCBglghkgBhvhCAQ0ENRYzVGhp
+cyBjZXJ0aWZpY2F0ZSBjYW5ub3QgYmUgdHJ1c3RlZCBmb3IgYW55IHB1cnBvc2UuMB0GA1Ud
+DgQWBBTEuloOPnrjPIGw9AKqaLsW4JYONTAfBgNVHSMEGDAWgBTyNds0BNqlVfK9aQOZsGLs
+4hUIwTAKBggqhkjOPQQDAwNoADBlAjBjuR/RNbgL3kRhmn+PJTeKaL9sh/oQgHOYTgLmSnv3
++NDCkhfKuMNoo/tHrkmihYgCMQC94MaerDIrQpi0IDh+v0QSAv9rMife8tClafXWtDwwL8MS
+7oAh0ymT446Uizxx3PUxggFTMIIBTwIBATBMMD8xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJW
+QTEQMA4GA1UEBwwHSGVybmRvbjERMA8GA1UECgwIQm9ndXMgQ0ECCQCls1QoG7BuOzALBglg
+hkgBZQMEAgKgezAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQASwwHAYJKoZIhvcNAQkFMQ8X
+DTIwMDExNDIyMjIxNVowPwYJKoZIhvcNAQkEMTIEMADSWdHn4vsesm9XnjJq1WxkoV6EtD+f
+qDAs1JEpZMZ+n8AtUxvC5SFobYpGCl+fsDAKBggqhkjOPQQDAwRmMGQCMGclPwvZLwVJqgON
+mOfnxSF8Cqn3AC+ZFBg7VplspiuhKPNIyu3IofqZjCxw0TzSpAIwEK0JxNlY28KDb5te0iN6
+I2hw+am26W+PRyltVVGUAISHM2kA4tG39HcxEQi+6HJx
+"""
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+
+ layers = { }
+ layers.update(rfc5652.cmsContentTypesMap)
+
+ getNextLayer = {
+ rfc5652.id_ct_contentInfo: lambda x: x['contentType'],
+ rfc5652.id_signedData: lambda x: x['encapContentInfo']['eContentType'],
+ }
+
+ getNextSubstrate = {
+ rfc5652.id_ct_contentInfo: lambda x: x['content'],
+ rfc5652.id_signedData: lambda x: x['encapContentInfo']['eContent'],
+ }
+
+ next_layer = rfc5652.id_ct_contentInfo
+ while next_layer in layers:
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=layers[next_layer])
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ substrate = getNextSubstrate[next_layer](asn1Object)
+ next_layer = getNextLayer[next_layer](asn1Object)
+
+ self.assertEqual(rfc8769.id_ct_cbor, next_layer)
+
+
+class CBORSequenceContentTestCase(unittest.TestCase):
+ pem_text = """\
+MIIEKQYJKoZIhvcNAQcCoIIEGjCCBBYCAQMxDTALBglghkgBZQMEAgIwKgYLKoZIhvcNAQkQ
+AS2gGwQZgw9kUnVzc/tADzMzMzMzM6MDCSD1YWFhYqCCAnwwggJ4MIIB/qADAgECAgkApbNU
+KBuwbjswCgYIKoZIzj0EAwMwPzELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlZBMRAwDgYDVQQH
+DAdIZXJuZG9uMREwDwYDVQQKDAhCb2d1cyBDQTAeFw0xOTA1MjkxNDQ1NDFaFw0yMDA1Mjgx
+NDQ1NDFaMHAxCzAJBgNVBAYTAlVTMQswCQYDVQQIEwJWQTEQMA4GA1UEBxMHSGVybmRvbjEQ
+MA4GA1UEChMHRXhhbXBsZTEOMAwGA1UEAxMFQWxpY2UxIDAeBgkqhkiG9w0BCQEWEWFsaWNl
+QGV4YW1wbGUuY29tMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE+M2fBy/sRA6V1pKFqecRTE8+
+LuAHtZxes1wmJZrBBg+bz7uYZfYQxI3dVB0YCSD6Mt3yXFlnmfBRwoqyArbjIBYrDbHBv2k8
+Csg2DhQ7qs/wto8hMKoFgkcscqIbiV7Zo4GUMIGRMAsGA1UdDwQEAwIHgDBCBglghkgBhvhC
+AQ0ENRYzVGhpcyBjZXJ0aWZpY2F0ZSBjYW5ub3QgYmUgdHJ1c3RlZCBmb3IgYW55IHB1cnBv
+c2UuMB0GA1UdDgQWBBTEuloOPnrjPIGw9AKqaLsW4JYONTAfBgNVHSMEGDAWgBTyNds0BNql
+VfK9aQOZsGLs4hUIwTAKBggqhkjOPQQDAwNoADBlAjBjuR/RNbgL3kRhmn+PJTeKaL9sh/oQ
+gHOYTgLmSnv3+NDCkhfKuMNoo/tHrkmihYgCMQC94MaerDIrQpi0IDh+v0QSAv9rMife8tCl
+afXWtDwwL8MS7oAh0ymT446Uizxx3PUxggFUMIIBUAIBATBMMD8xCzAJBgNVBAYTAlVTMQsw
+CQYDVQQIDAJWQTEQMA4GA1UEBwwHSGVybmRvbjERMA8GA1UECgwIQm9ndXMgQ0ECCQCls1Qo
+G7BuOzALBglghkgBZQMEAgKgezAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAS0wHAYJKoZI
+hvcNAQkFMQ8XDTIwMDExNDIyMjIxNVowPwYJKoZIhvcNAQkEMTIEMOsEu3dGU5j6fKZbsZPL
+LDA8QWxpP36CPDZWr3BVJ3R5mMCKCSmoWtVRnB7XASQcjTAKBggqhkjOPQQDAwRnMGUCMBLW
+PyYw4c11nrH97KHnEmx3BSDX/SfepFNM6PoPR5HCI+OR/v/wlIIByuhyrIl8xAIxAK8dEwOe
+I06um+ATKQzUcbgq0PCKA7T31pAq46fsWc5tA+mMARTrxZjSXsDneeAWpw==
+"""
+
+ def testDerCodec(self):
+ substrate = pem.readBase64fromText(self.pem_text)
+
+ layers = { }
+ layers.update(rfc5652.cmsContentTypesMap)
+
+ getNextLayer = {
+ rfc5652.id_ct_contentInfo: lambda x: x['contentType'],
+ rfc5652.id_signedData: lambda x: x['encapContentInfo']['eContentType'],
+ }
+
+ getNextSubstrate = {
+ rfc5652.id_ct_contentInfo: lambda x: x['content'],
+ rfc5652.id_signedData: lambda x: x['encapContentInfo']['eContent'],
+ }
+
+ next_layer = rfc5652.id_ct_contentInfo
+ while next_layer in layers:
+ asn1Object, rest = der_decoder(
+ substrate, asn1Spec=layers[next_layer])
+
+ self.assertFalse(rest)
+ self.assertTrue(asn1Object.prettyPrint())
+ self.assertEqual(substrate, der_encoder(asn1Object))
+
+ substrate = getNextSubstrate[next_layer](asn1Object)
+ next_layer = getNextLayer[next_layer](asn1Object)
+
+ self.assertEqual(rfc8769.id_ct_cborSequence, next_layer)
+
+
+suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
+
+if __name__ == '__main__':
+ import sys
+
+ result = unittest.TextTestRunner(verbosity=2).run(suite)
+ sys.exit(not result.wasSuccessful())
diff --git a/tools/cmpdump.py b/tools/cmpdump.py
index 0c30a8c..ebf8dba 100755
--- a/tools/cmpdump.py
+++ b/tools/cmpdump.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Read ASN.1/PEM CMP message on stdin, parse into
diff --git a/tools/crldump.py b/tools/crldump.py
index 54b8a37..9eaf6ba 100755
--- a/tools/crldump.py
+++ b/tools/crldump.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Read X.509 CRL on stdin, print them pretty and encode back into
diff --git a/tools/crmfdump.py b/tools/crmfdump.py
index 971c53a..f23fd0d 100755
--- a/tools/crmfdump.py
+++ b/tools/crmfdump.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Read ASN.1/PEM X.509 CRMF request on stdin, parse into
diff --git a/tools/ocspclient.py b/tools/ocspclient.py
index c48a509..84f06fb 100755
--- a/tools/ocspclient.py
+++ b/tools/ocspclient.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
import hashlib
diff --git a/tools/ocspreqdump.py b/tools/ocspreqdump.py
index 0b1e571..3e43418 100755
--- a/tools/ocspreqdump.py
+++ b/tools/ocspreqdump.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Read ASN.1/PEM X.509 CRMF request on stdin, parse into
diff --git a/tools/ocsprspdump.py b/tools/ocsprspdump.py
index 33069a8..1f79acd 100755
--- a/tools/ocsprspdump.py
+++ b/tools/ocsprspdump.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Read ASN.1/PEM OCSP response on stdin, parse into
diff --git a/tools/pkcs10dump.py b/tools/pkcs10dump.py
index 13a7df3..385312a 100755
--- a/tools/pkcs10dump.py
+++ b/tools/pkcs10dump.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Read ASN.1/PEM X.509 certificate requests (PKCS#10 format) on stdin,
diff --git a/tools/pkcs1dump.py b/tools/pkcs1dump.py
index 0329b6b..72fb1dd 100755
--- a/tools/pkcs1dump.py
+++ b/tools/pkcs1dump.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Read unencrypted PKCS#1/PKIX-compliant, PEM&DER encoded private keys on
diff --git a/tools/pkcs7dump.py b/tools/pkcs7dump.py
index 5884faf..7ac2eb9 100755
--- a/tools/pkcs7dump.py
+++ b/tools/pkcs7dump.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Read ASN.1/PEM PKCS#7 on stdin, parse it into plain text,
diff --git a/tools/pkcs8dump.py b/tools/pkcs8dump.py
index d2108e6..e95a549 100755
--- a/tools/pkcs8dump.py
+++ b/tools/pkcs8dump.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Read bunch of ASN.1/PEM plain/encrypted private keys in PKCS#8
diff --git a/tools/snmpget.py b/tools/snmpget.py
index f089baf..c6d97a5 100755
--- a/tools/snmpget.py
+++ b/tools/snmpget.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Generate SNMPGET request, parse response
diff --git a/tools/x509dump-rfc5280.py b/tools/x509dump-rfc5280.py
index 81b19c7..26a79e9 100755
--- a/tools/x509dump-rfc5280.py
+++ b/tools/x509dump-rfc5280.py
@@ -4,7 +4,7 @@
# This file is part of pyasn1-modules software.
#
# Created by Stanisław Pitucha with asn1ate tool.
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Read ASN.1/PEM X.509 certificates on stdin, parse each into plain text,
diff --git a/tools/x509dump.py b/tools/x509dump.py
index 84e2a94..1b8cca4 100755
--- a/tools/x509dump.py
+++ b/tools/x509dump.py
@@ -2,7 +2,7 @@
#
# This file is part of pyasn1-modules software.
#
-# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# Copyright (c) 2005-2020, Ilya Etingof <etingof@gmail.com>
# License: http://snmplabs.com/pyasn1/license.html
#
# Read ASN.1/PEM X.509 certificates on stdin, parse each into plain text,
Debdiff
[The following lists of changes regard files as different if they have different names, permissions or owners.]
Files in second set of .debs but not in first
-rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules-0.3.0.egg-info -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc2876.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc3058.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc3125.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc3370.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc3537.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc3657.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc3739.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc3820.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc4010.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc4357.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc4387.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc4476.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc4490.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc4491.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc4683.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc5126.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc5275.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc5636.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc5639.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc5697.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc5752.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc5753.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc8692.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc8696.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc8702.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc8708.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc8769.py
Files in first set of .debs but not in second
-rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules-0.2.8.egg-info -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc6402-1.py -rw-r--r-- root/root /usr/lib/python3/dist-packages/pyasn1_modules/rfc7894-1.py
Control files: lines which differ (wdiff format)
Depends: python3-pyasn1 (>= 0.4.6), python3-pyasn1 (<< 0.5.0), 0.6.0), python3:any