Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 1 | # This file is dual licensed under the terms of the Apache License, Version |
| 2 | # 2.0, and the BSD License. See the LICENSE file in the root of this repository |
| 3 | # for complete details. |
| 4 | |
| 5 | from __future__ import absolute_import, division, print_function |
| 6 | |
Paul Kehrer | 0307c37 | 2014-11-27 09:49:31 -1000 | [diff] [blame] | 7 | import binascii |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 8 | import datetime |
| 9 | import os |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 10 | |
| 11 | import pytest |
| 12 | |
| 13 | from cryptography import x509 |
Paul Kehrer | 8802a5b | 2015-02-13 12:06:57 -0600 | [diff] [blame] | 14 | from cryptography.exceptions import UnsupportedAlgorithm |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 15 | from cryptography.hazmat.backends.interfaces import ( |
| 16 | DSABackend, EllipticCurveBackend, RSABackend, X509Backend |
| 17 | ) |
Alex Gaynor | 32c57df | 2015-02-23 21:51:27 -0800 | [diff] [blame] | 18 | from cryptography.hazmat.primitives import hashes |
| 19 | from cryptography.hazmat.primitives.asymmetric import dsa, ec, rsa |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 20 | |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 21 | from .hazmat.primitives.test_ec import _skip_curve_unsupported |
Paul Kehrer | a9d78c1 | 2014-11-26 10:59:03 -1000 | [diff] [blame] | 22 | from .utils import load_vectors_from_file |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 23 | |
| 24 | |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 25 | def _load_cert(filename, loader, backend): |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 26 | cert = load_vectors_from_file( |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 27 | filename=filename, |
| 28 | loader=lambda pemfile: loader(pemfile.read(), backend), |
| 29 | mode="rb" |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 30 | ) |
| 31 | return cert |
| 32 | |
| 33 | |
| 34 | @pytest.mark.requires_backend_interface(interface=RSABackend) |
| 35 | @pytest.mark.requires_backend_interface(interface=X509Backend) |
Paul Kehrer | e76cd27 | 2014-12-14 19:00:51 -0600 | [diff] [blame] | 36 | class TestRSACertificate(object): |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 37 | def test_load_pem_cert(self, backend): |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 38 | cert = _load_cert( |
| 39 | os.path.join("x509", "custom", "post2000utctime.pem"), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 40 | x509.load_pem_x509_certificate, |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 41 | backend |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 42 | ) |
Paul Kehrer | e76cd27 | 2014-12-14 19:00:51 -0600 | [diff] [blame] | 43 | assert isinstance(cert, x509.Certificate) |
| 44 | assert cert.serial == 11559813051657483483 |
| 45 | fingerprint = binascii.hexlify(cert.fingerprint(hashes.SHA1())) |
| 46 | assert fingerprint == b"2b619ed04bfc9c3b08eb677d272192286a0947a8" |
Paul Kehrer | 8802a5b | 2015-02-13 12:06:57 -0600 | [diff] [blame] | 47 | assert isinstance(cert.signature_hash_algorithm, hashes.SHA1) |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 48 | |
| 49 | def test_load_der_cert(self, backend): |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 50 | cert = _load_cert( |
| 51 | os.path.join("x509", "PKITS_data", "certs", "GoodCACert.crt"), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 52 | x509.load_der_x509_certificate, |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 53 | backend |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 54 | ) |
Paul Kehrer | e76cd27 | 2014-12-14 19:00:51 -0600 | [diff] [blame] | 55 | assert isinstance(cert, x509.Certificate) |
| 56 | assert cert.serial == 2 |
| 57 | fingerprint = binascii.hexlify(cert.fingerprint(hashes.SHA1())) |
| 58 | assert fingerprint == b"6f49779533d565e8b7c1062503eab41492c38e4d" |
Paul Kehrer | 8802a5b | 2015-02-13 12:06:57 -0600 | [diff] [blame] | 59 | assert isinstance(cert.signature_hash_algorithm, hashes.SHA256) |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 60 | |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 61 | def test_issuer(self, backend): |
| 62 | cert = _load_cert( |
| 63 | os.path.join( |
| 64 | "x509", "PKITS_data", "certs", |
| 65 | "Validpre2000UTCnotBeforeDateTest3EE.crt" |
| 66 | ), |
| 67 | x509.load_der_x509_certificate, |
| 68 | backend |
| 69 | ) |
| 70 | issuer = cert.issuer |
| 71 | assert isinstance(issuer, x509.Name) |
Paul Kehrer | 8b21a4a | 2015-02-14 07:56:36 -0600 | [diff] [blame] | 72 | assert list(issuer) == [ |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 73 | x509.NameAttribute(x509.OID_COUNTRY_NAME, 'US'), |
| 74 | x509.NameAttribute( |
| 75 | x509.OID_ORGANIZATION_NAME, 'Test Certificates 2011' |
| 76 | ), |
| 77 | x509.NameAttribute(x509.OID_COMMON_NAME, 'Good CA') |
| 78 | ] |
Paul Kehrer | e901d64 | 2015-02-11 18:50:58 -0600 | [diff] [blame] | 79 | assert issuer.get_attributes_for_oid(x509.OID_COMMON_NAME) == [ |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 80 | x509.NameAttribute(x509.OID_COMMON_NAME, 'Good CA') |
| 81 | ] |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 82 | |
| 83 | def test_all_issuer_name_types(self, backend): |
| 84 | cert = _load_cert( |
| 85 | os.path.join( |
| 86 | "x509", "custom", |
| 87 | "all_supported_names.pem" |
| 88 | ), |
| 89 | x509.load_pem_x509_certificate, |
| 90 | backend |
| 91 | ) |
| 92 | issuer = cert.issuer |
| 93 | |
| 94 | assert isinstance(issuer, x509.Name) |
Paul Kehrer | 8b21a4a | 2015-02-14 07:56:36 -0600 | [diff] [blame] | 95 | assert list(issuer) == [ |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 96 | x509.NameAttribute(x509.OID_COUNTRY_NAME, 'US'), |
| 97 | x509.NameAttribute(x509.OID_COUNTRY_NAME, 'CA'), |
| 98 | x509.NameAttribute(x509.OID_STATE_OR_PROVINCE_NAME, 'Texas'), |
| 99 | x509.NameAttribute(x509.OID_STATE_OR_PROVINCE_NAME, 'Illinois'), |
| 100 | x509.NameAttribute(x509.OID_LOCALITY_NAME, 'Chicago'), |
| 101 | x509.NameAttribute(x509.OID_LOCALITY_NAME, 'Austin'), |
| 102 | x509.NameAttribute(x509.OID_ORGANIZATION_NAME, 'Zero, LLC'), |
| 103 | x509.NameAttribute(x509.OID_ORGANIZATION_NAME, 'One, LLC'), |
| 104 | x509.NameAttribute(x509.OID_COMMON_NAME, 'common name 0'), |
| 105 | x509.NameAttribute(x509.OID_COMMON_NAME, 'common name 1'), |
| 106 | x509.NameAttribute(x509.OID_ORGANIZATIONAL_UNIT_NAME, 'OU 0'), |
| 107 | x509.NameAttribute(x509.OID_ORGANIZATIONAL_UNIT_NAME, 'OU 1'), |
| 108 | x509.NameAttribute(x509.OID_DN_QUALIFIER, 'dnQualifier0'), |
| 109 | x509.NameAttribute(x509.OID_DN_QUALIFIER, 'dnQualifier1'), |
| 110 | x509.NameAttribute(x509.OID_SERIAL_NUMBER, '123'), |
| 111 | x509.NameAttribute(x509.OID_SERIAL_NUMBER, '456'), |
| 112 | x509.NameAttribute(x509.OID_TITLE, 'Title 0'), |
| 113 | x509.NameAttribute(x509.OID_TITLE, 'Title 1'), |
| 114 | x509.NameAttribute(x509.OID_SURNAME, 'Surname 0'), |
| 115 | x509.NameAttribute(x509.OID_SURNAME, 'Surname 1'), |
| 116 | x509.NameAttribute(x509.OID_GIVEN_NAME, 'Given Name 0'), |
| 117 | x509.NameAttribute(x509.OID_GIVEN_NAME, 'Given Name 1'), |
| 118 | x509.NameAttribute(x509.OID_PSEUDONYM, 'Incognito 0'), |
| 119 | x509.NameAttribute(x509.OID_PSEUDONYM, 'Incognito 1'), |
| 120 | x509.NameAttribute(x509.OID_GENERATION_QUALIFIER, 'Last Gen'), |
| 121 | x509.NameAttribute(x509.OID_GENERATION_QUALIFIER, 'Next Gen'), |
| 122 | x509.NameAttribute(x509.OID_DOMAIN_COMPONENT, 'dc0'), |
| 123 | x509.NameAttribute(x509.OID_DOMAIN_COMPONENT, 'dc1'), |
| 124 | x509.NameAttribute(x509.OID_EMAIL_ADDRESS, 'test0@test.local'), |
| 125 | x509.NameAttribute(x509.OID_EMAIL_ADDRESS, 'test1@test.local'), |
| 126 | ] |
| 127 | |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 128 | def test_subject(self, backend): |
| 129 | cert = _load_cert( |
| 130 | os.path.join( |
| 131 | "x509", "PKITS_data", "certs", |
| 132 | "Validpre2000UTCnotBeforeDateTest3EE.crt" |
| 133 | ), |
| 134 | x509.load_der_x509_certificate, |
| 135 | backend |
| 136 | ) |
| 137 | subject = cert.subject |
| 138 | assert isinstance(subject, x509.Name) |
Paul Kehrer | 8b21a4a | 2015-02-14 07:56:36 -0600 | [diff] [blame] | 139 | assert list(subject) == [ |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 140 | x509.NameAttribute(x509.OID_COUNTRY_NAME, 'US'), |
| 141 | x509.NameAttribute( |
| 142 | x509.OID_ORGANIZATION_NAME, 'Test Certificates 2011' |
| 143 | ), |
| 144 | x509.NameAttribute( |
| 145 | x509.OID_COMMON_NAME, |
| 146 | 'Valid pre2000 UTC notBefore Date EE Certificate Test3' |
| 147 | ) |
| 148 | ] |
Paul Kehrer | e901d64 | 2015-02-11 18:50:58 -0600 | [diff] [blame] | 149 | assert subject.get_attributes_for_oid(x509.OID_COMMON_NAME) == [ |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 150 | x509.NameAttribute( |
| 151 | x509.OID_COMMON_NAME, |
| 152 | 'Valid pre2000 UTC notBefore Date EE Certificate Test3' |
| 153 | ) |
| 154 | ] |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 155 | |
| 156 | def test_unicode_name(self, backend): |
| 157 | cert = _load_cert( |
| 158 | os.path.join( |
| 159 | "x509", "custom", |
| 160 | "utf8_common_name.pem" |
| 161 | ), |
| 162 | x509.load_pem_x509_certificate, |
| 163 | backend |
| 164 | ) |
Paul Kehrer | e901d64 | 2015-02-11 18:50:58 -0600 | [diff] [blame] | 165 | assert cert.subject.get_attributes_for_oid(x509.OID_COMMON_NAME) == [ |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 166 | x509.NameAttribute( |
| 167 | x509.OID_COMMON_NAME, |
Eeshan Garg | f123415 | 2015-04-29 18:41:00 +0530 | [diff] [blame^] | 168 | u'We heart UTF8!\u2122' |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 169 | ) |
| 170 | ] |
Paul Kehrer | e901d64 | 2015-02-11 18:50:58 -0600 | [diff] [blame] | 171 | assert cert.issuer.get_attributes_for_oid(x509.OID_COMMON_NAME) == [ |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 172 | x509.NameAttribute( |
| 173 | x509.OID_COMMON_NAME, |
Eeshan Garg | f123415 | 2015-04-29 18:41:00 +0530 | [diff] [blame^] | 174 | u'We heart UTF8!\u2122' |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 175 | ) |
| 176 | ] |
| 177 | |
| 178 | def test_all_subject_name_types(self, backend): |
| 179 | cert = _load_cert( |
| 180 | os.path.join( |
| 181 | "x509", "custom", |
| 182 | "all_supported_names.pem" |
| 183 | ), |
| 184 | x509.load_pem_x509_certificate, |
| 185 | backend |
| 186 | ) |
| 187 | subject = cert.subject |
| 188 | assert isinstance(subject, x509.Name) |
Paul Kehrer | 8b21a4a | 2015-02-14 07:56:36 -0600 | [diff] [blame] | 189 | assert list(subject) == [ |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 190 | x509.NameAttribute(x509.OID_COUNTRY_NAME, 'AU'), |
| 191 | x509.NameAttribute(x509.OID_COUNTRY_NAME, 'DE'), |
| 192 | x509.NameAttribute(x509.OID_STATE_OR_PROVINCE_NAME, 'California'), |
| 193 | x509.NameAttribute(x509.OID_STATE_OR_PROVINCE_NAME, 'New York'), |
| 194 | x509.NameAttribute(x509.OID_LOCALITY_NAME, 'San Francisco'), |
| 195 | x509.NameAttribute(x509.OID_LOCALITY_NAME, 'Ithaca'), |
| 196 | x509.NameAttribute(x509.OID_ORGANIZATION_NAME, 'Org Zero, LLC'), |
| 197 | x509.NameAttribute(x509.OID_ORGANIZATION_NAME, 'Org One, LLC'), |
| 198 | x509.NameAttribute(x509.OID_COMMON_NAME, 'CN 0'), |
| 199 | x509.NameAttribute(x509.OID_COMMON_NAME, 'CN 1'), |
| 200 | x509.NameAttribute( |
| 201 | x509.OID_ORGANIZATIONAL_UNIT_NAME, 'Engineering 0' |
| 202 | ), |
| 203 | x509.NameAttribute( |
| 204 | x509.OID_ORGANIZATIONAL_UNIT_NAME, 'Engineering 1' |
| 205 | ), |
| 206 | x509.NameAttribute(x509.OID_DN_QUALIFIER, 'qualified0'), |
| 207 | x509.NameAttribute(x509.OID_DN_QUALIFIER, 'qualified1'), |
| 208 | x509.NameAttribute(x509.OID_SERIAL_NUMBER, '789'), |
| 209 | x509.NameAttribute(x509.OID_SERIAL_NUMBER, '012'), |
| 210 | x509.NameAttribute(x509.OID_TITLE, 'Title IX'), |
| 211 | x509.NameAttribute(x509.OID_TITLE, 'Title X'), |
| 212 | x509.NameAttribute(x509.OID_SURNAME, 'Last 0'), |
| 213 | x509.NameAttribute(x509.OID_SURNAME, 'Last 1'), |
| 214 | x509.NameAttribute(x509.OID_GIVEN_NAME, 'First 0'), |
| 215 | x509.NameAttribute(x509.OID_GIVEN_NAME, 'First 1'), |
| 216 | x509.NameAttribute(x509.OID_PSEUDONYM, 'Guy Incognito 0'), |
| 217 | x509.NameAttribute(x509.OID_PSEUDONYM, 'Guy Incognito 1'), |
| 218 | x509.NameAttribute(x509.OID_GENERATION_QUALIFIER, '32X'), |
| 219 | x509.NameAttribute(x509.OID_GENERATION_QUALIFIER, 'Dreamcast'), |
| 220 | x509.NameAttribute(x509.OID_DOMAIN_COMPONENT, 'dc2'), |
| 221 | x509.NameAttribute(x509.OID_DOMAIN_COMPONENT, 'dc3'), |
| 222 | x509.NameAttribute(x509.OID_EMAIL_ADDRESS, 'test2@test.local'), |
| 223 | x509.NameAttribute(x509.OID_EMAIL_ADDRESS, 'test3@test.local'), |
| 224 | ] |
| 225 | |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 226 | def test_load_good_ca_cert(self, backend): |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 227 | cert = _load_cert( |
| 228 | os.path.join("x509", "PKITS_data", "certs", "GoodCACert.crt"), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 229 | x509.load_der_x509_certificate, |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 230 | backend |
| 231 | ) |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 232 | |
Paul Kehrer | d9fc725 | 2014-12-11 12:25:00 -0600 | [diff] [blame] | 233 | assert cert.not_valid_before == datetime.datetime(2010, 1, 1, 8, 30) |
| 234 | assert cert.not_valid_after == datetime.datetime(2030, 12, 31, 8, 30) |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 235 | assert cert.serial == 2 |
| 236 | public_key = cert.public_key() |
Alex Gaynor | 32c57df | 2015-02-23 21:51:27 -0800 | [diff] [blame] | 237 | assert isinstance(public_key, rsa.RSAPublicKey) |
Paul Kehrer | e76cd27 | 2014-12-14 19:00:51 -0600 | [diff] [blame] | 238 | assert cert.version is x509.Version.v3 |
Paul Kehrer | 0307c37 | 2014-11-27 09:49:31 -1000 | [diff] [blame] | 239 | fingerprint = binascii.hexlify(cert.fingerprint(hashes.SHA1())) |
Paul Kehrer | 4e1db79 | 2014-11-27 10:50:55 -1000 | [diff] [blame] | 240 | assert fingerprint == b"6f49779533d565e8b7c1062503eab41492c38e4d" |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 241 | |
Paul Kehrer | 1eb5b86 | 2014-11-26 11:44:03 -1000 | [diff] [blame] | 242 | def test_utc_pre_2000_not_before_cert(self, backend): |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 243 | cert = _load_cert( |
| 244 | os.path.join( |
| 245 | "x509", "PKITS_data", "certs", |
| 246 | "Validpre2000UTCnotBeforeDateTest3EE.crt" |
| 247 | ), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 248 | x509.load_der_x509_certificate, |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 249 | backend |
| 250 | ) |
| 251 | |
Paul Kehrer | d9fc725 | 2014-12-11 12:25:00 -0600 | [diff] [blame] | 252 | assert cert.not_valid_before == datetime.datetime(1950, 1, 1, 12, 1) |
Paul Kehrer | 1eb5b86 | 2014-11-26 11:44:03 -1000 | [diff] [blame] | 253 | |
| 254 | def test_pre_2000_utc_not_after_cert(self, backend): |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 255 | cert = _load_cert( |
| 256 | os.path.join( |
| 257 | "x509", "PKITS_data", "certs", |
| 258 | "Invalidpre2000UTCEEnotAfterDateTest7EE.crt" |
| 259 | ), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 260 | x509.load_der_x509_certificate, |
Paul Kehrer | 1eb5b86 | 2014-11-26 11:44:03 -1000 | [diff] [blame] | 261 | backend |
| 262 | ) |
| 263 | |
Paul Kehrer | d9fc725 | 2014-12-11 12:25:00 -0600 | [diff] [blame] | 264 | assert cert.not_valid_after == datetime.datetime(1999, 1, 1, 12, 1) |
Paul Kehrer | 1eb5b86 | 2014-11-26 11:44:03 -1000 | [diff] [blame] | 265 | |
| 266 | def test_post_2000_utc_cert(self, backend): |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 267 | cert = _load_cert( |
Paul Kehrer | 1eb5b86 | 2014-11-26 11:44:03 -1000 | [diff] [blame] | 268 | os.path.join("x509", "custom", "post2000utctime.pem"), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 269 | x509.load_pem_x509_certificate, |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 270 | backend |
Paul Kehrer | 1eb5b86 | 2014-11-26 11:44:03 -1000 | [diff] [blame] | 271 | ) |
Paul Kehrer | d9fc725 | 2014-12-11 12:25:00 -0600 | [diff] [blame] | 272 | assert cert.not_valid_before == datetime.datetime( |
| 273 | 2014, 11, 26, 21, 41, 20 |
| 274 | ) |
| 275 | assert cert.not_valid_after == datetime.datetime( |
| 276 | 2014, 12, 26, 21, 41, 20 |
| 277 | ) |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 278 | |
| 279 | def test_generalized_time_not_before_cert(self, backend): |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 280 | cert = _load_cert( |
| 281 | os.path.join( |
| 282 | "x509", "PKITS_data", "certs", |
| 283 | "ValidGeneralizedTimenotBeforeDateTest4EE.crt" |
| 284 | ), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 285 | x509.load_der_x509_certificate, |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 286 | backend |
| 287 | ) |
Paul Kehrer | d9fc725 | 2014-12-11 12:25:00 -0600 | [diff] [blame] | 288 | assert cert.not_valid_before == datetime.datetime(2002, 1, 1, 12, 1) |
| 289 | assert cert.not_valid_after == datetime.datetime(2030, 12, 31, 8, 30) |
Paul Kehrer | e76cd27 | 2014-12-14 19:00:51 -0600 | [diff] [blame] | 290 | assert cert.version is x509.Version.v3 |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 291 | |
| 292 | def test_generalized_time_not_after_cert(self, backend): |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 293 | cert = _load_cert( |
| 294 | os.path.join( |
| 295 | "x509", "PKITS_data", "certs", |
| 296 | "ValidGeneralizedTimenotAfterDateTest8EE.crt" |
| 297 | ), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 298 | x509.load_der_x509_certificate, |
Paul Kehrer | 016e08a | 2014-11-26 09:41:18 -1000 | [diff] [blame] | 299 | backend |
| 300 | ) |
Paul Kehrer | d9fc725 | 2014-12-11 12:25:00 -0600 | [diff] [blame] | 301 | assert cert.not_valid_before == datetime.datetime(2010, 1, 1, 8, 30) |
| 302 | assert cert.not_valid_after == datetime.datetime(2050, 1, 1, 12, 1) |
Paul Kehrer | e76cd27 | 2014-12-14 19:00:51 -0600 | [diff] [blame] | 303 | assert cert.version is x509.Version.v3 |
Paul Kehrer | a9d78c1 | 2014-11-26 10:59:03 -1000 | [diff] [blame] | 304 | |
| 305 | def test_invalid_version_cert(self, backend): |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 306 | cert = _load_cert( |
Paul Kehrer | a9d78c1 | 2014-11-26 10:59:03 -1000 | [diff] [blame] | 307 | os.path.join("x509", "custom", "invalid_version.pem"), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 308 | x509.load_pem_x509_certificate, |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 309 | backend |
Paul Kehrer | a9d78c1 | 2014-11-26 10:59:03 -1000 | [diff] [blame] | 310 | ) |
Paul Kehrer | d5cccf7 | 2014-12-15 17:20:33 -0600 | [diff] [blame] | 311 | with pytest.raises(x509.InvalidVersion) as exc: |
Paul Kehrer | a9d78c1 | 2014-11-26 10:59:03 -1000 | [diff] [blame] | 312 | cert.version |
Paul Kehrer | 30c5ccd | 2014-11-26 11:10:28 -1000 | [diff] [blame] | 313 | |
Paul Kehrer | d5cccf7 | 2014-12-15 17:20:33 -0600 | [diff] [blame] | 314 | assert exc.value.parsed_version == 7 |
| 315 | |
Paul Kehrer | 30c5ccd | 2014-11-26 11:10:28 -1000 | [diff] [blame] | 316 | def test_version_1_cert(self, backend): |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 317 | cert = _load_cert( |
Paul Kehrer | 30c5ccd | 2014-11-26 11:10:28 -1000 | [diff] [blame] | 318 | os.path.join("x509", "v1_cert.pem"), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 319 | x509.load_pem_x509_certificate, |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 320 | backend |
Paul Kehrer | 30c5ccd | 2014-11-26 11:10:28 -1000 | [diff] [blame] | 321 | ) |
Paul Kehrer | e76cd27 | 2014-12-14 19:00:51 -0600 | [diff] [blame] | 322 | assert cert.version is x509.Version.v1 |
Paul Kehrer | 7638c31 | 2014-11-26 11:13:31 -1000 | [diff] [blame] | 323 | |
| 324 | def test_invalid_pem(self, backend): |
| 325 | with pytest.raises(ValueError): |
| 326 | x509.load_pem_x509_certificate(b"notacert", backend) |
| 327 | |
| 328 | def test_invalid_der(self, backend): |
| 329 | with pytest.raises(ValueError): |
| 330 | x509.load_der_x509_certificate(b"notacert", backend) |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 331 | |
Paul Kehrer | 8802a5b | 2015-02-13 12:06:57 -0600 | [diff] [blame] | 332 | def test_unsupported_signature_hash_algorithm_cert(self, backend): |
| 333 | cert = _load_cert( |
| 334 | os.path.join("x509", "verisign_md2_root.pem"), |
| 335 | x509.load_pem_x509_certificate, |
| 336 | backend |
| 337 | ) |
| 338 | with pytest.raises(UnsupportedAlgorithm): |
| 339 | cert.signature_hash_algorithm |
| 340 | |
Paul Kehrer | 1effb6e | 2015-03-30 15:05:59 -0500 | [diff] [blame] | 341 | @pytest.mark.parametrize( |
| 342 | ("path", "loader_func"), |
| 343 | [ |
| 344 | [ |
| 345 | os.path.join("x509", "requests", "rsa_sha1.pem"), |
| 346 | x509.load_pem_x509_csr |
| 347 | ], |
| 348 | [ |
| 349 | os.path.join("x509", "requests", "rsa_sha1.der"), |
| 350 | x509.load_der_x509_csr |
| 351 | ], |
| 352 | ] |
| 353 | ) |
| 354 | def test_load_rsa_certificate_request(self, path, loader_func, backend): |
| 355 | request = _load_cert(path, loader_func, backend) |
Paul Kehrer | dc480ad | 2015-02-23 12:14:54 -0600 | [diff] [blame] | 356 | assert isinstance(request.signature_hash_algorithm, hashes.SHA1) |
| 357 | public_key = request.public_key() |
| 358 | assert isinstance(public_key, rsa.RSAPublicKey) |
| 359 | subject = request.subject |
| 360 | assert isinstance(subject, x509.Name) |
| 361 | assert list(subject) == [ |
| 362 | x509.NameAttribute(x509.OID_COUNTRY_NAME, 'US'), |
| 363 | x509.NameAttribute(x509.OID_STATE_OR_PROVINCE_NAME, 'Texas'), |
| 364 | x509.NameAttribute(x509.OID_LOCALITY_NAME, 'Austin'), |
| 365 | x509.NameAttribute(x509.OID_ORGANIZATION_NAME, 'PyCA'), |
| 366 | x509.NameAttribute(x509.OID_COMMON_NAME, 'cryptography.io'), |
| 367 | ] |
| 368 | |
Paul Kehrer | 1effb6e | 2015-03-30 15:05:59 -0500 | [diff] [blame] | 369 | @pytest.mark.parametrize( |
| 370 | "loader_func", |
| 371 | [x509.load_pem_x509_csr, x509.load_der_x509_csr] |
| 372 | ) |
| 373 | def test_invalid_certificate_request(self, loader_func, backend): |
Paul Kehrer | b759e29 | 2015-03-17 07:34:41 -0500 | [diff] [blame] | 374 | with pytest.raises(ValueError): |
Paul Kehrer | 1effb6e | 2015-03-30 15:05:59 -0500 | [diff] [blame] | 375 | loader_func(b"notacsr", backend) |
Paul Kehrer | b759e29 | 2015-03-17 07:34:41 -0500 | [diff] [blame] | 376 | |
Paul Kehrer | dc480ad | 2015-02-23 12:14:54 -0600 | [diff] [blame] | 377 | def test_unsupported_signature_hash_algorithm_request(self, backend): |
| 378 | request = _load_cert( |
| 379 | os.path.join("x509", "requests", "rsa_md4.pem"), |
Paul Kehrer | 31e3988 | 2015-03-11 11:37:04 -0500 | [diff] [blame] | 380 | x509.load_pem_x509_csr, |
Paul Kehrer | dc480ad | 2015-02-23 12:14:54 -0600 | [diff] [blame] | 381 | backend |
| 382 | ) |
| 383 | with pytest.raises(UnsupportedAlgorithm): |
| 384 | request.signature_hash_algorithm |
| 385 | |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 386 | |
| 387 | @pytest.mark.requires_backend_interface(interface=DSABackend) |
| 388 | @pytest.mark.requires_backend_interface(interface=X509Backend) |
Paul Kehrer | e76cd27 | 2014-12-14 19:00:51 -0600 | [diff] [blame] | 389 | class TestDSACertificate(object): |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 390 | def test_load_dsa_cert(self, backend): |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 391 | cert = _load_cert( |
Paul Kehrer | 4903adc | 2014-12-13 16:57:50 -0600 | [diff] [blame] | 392 | os.path.join("x509", "custom", "dsa_selfsigned_ca.pem"), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 393 | x509.load_pem_x509_certificate, |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 394 | backend |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 395 | ) |
Paul Kehrer | 8802a5b | 2015-02-13 12:06:57 -0600 | [diff] [blame] | 396 | assert isinstance(cert.signature_hash_algorithm, hashes.SHA1) |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 397 | public_key = cert.public_key() |
Alex Gaynor | 32c57df | 2015-02-23 21:51:27 -0800 | [diff] [blame] | 398 | assert isinstance(public_key, dsa.DSAPublicKey) |
Alex Gaynor | fcadda6 | 2015-03-10 10:01:18 -0400 | [diff] [blame] | 399 | if isinstance(public_key, dsa.DSAPublicKeyWithSerialization): |
Paul Kehrer | e76cd27 | 2014-12-14 19:00:51 -0600 | [diff] [blame] | 400 | num = public_key.public_numbers() |
| 401 | assert num.y == int( |
| 402 | "4c08bfe5f2d76649c80acf7d431f6ae2124b217abc8c9f6aca776ddfa94" |
| 403 | "53b6656f13e543684cd5f6431a314377d2abfa068b7080cb8ddc065afc2" |
| 404 | "dea559f0b584c97a2b235b9b69b46bc6de1aed422a6f341832618bcaae2" |
| 405 | "198aba388099dafb05ff0b5efecb3b0ae169a62e1c72022af50ae68af3b" |
| 406 | "033c18e6eec1f7df4692c456ccafb79cc7e08da0a5786e9816ceda651d6" |
| 407 | "1b4bb7b81c2783da97cea62df67af5e85991fdc13aff10fc60e06586386" |
| 408 | "b96bb78d65750f542f86951e05a6d81baadbcd35a2e5cad4119923ae6a2" |
| 409 | "002091a3d17017f93c52970113cdc119970b9074ca506eac91c3dd37632" |
| 410 | "5df4af6b3911ef267d26623a5a1c5df4a6d13f1c", 16 |
| 411 | ) |
| 412 | assert num.parameter_numbers.g == int( |
| 413 | "4b7ced71dc353965ecc10d441a9a06fc24943a32d66429dd5ef44d43e67" |
| 414 | "d789d99770aec32c0415dc92970880872da45fef8dd1e115a3e4801387b" |
| 415 | "a6d755861f062fd3b6e9ea8e2641152339b828315b1528ee6c7b79458d2" |
| 416 | "1f3db973f6fc303f9397174c2799dd2351282aa2d8842c357a73495bbaa" |
| 417 | "c4932786414c55e60d73169f5761036fba29e9eebfb049f8a3b1b7cee6f" |
| 418 | "3fbfa136205f130bee2cf5b9c38dc1095d4006f2e73335c07352c64130a" |
| 419 | "1ab2b89f13b48f628d3cc3868beece9bb7beade9f830eacc6fa241425c0" |
| 420 | "b3fcc0df416a0c89f7bf35668d765ec95cdcfbe9caff49cfc156c668c76" |
| 421 | "fa6247676a6d3ac945844a083509c6a1b436baca", 16 |
| 422 | ) |
| 423 | assert num.parameter_numbers.p == int( |
| 424 | "bfade6048e373cd4e48b677e878c8e5b08c02102ae04eb2cb5c46a523a3" |
| 425 | "af1c73d16b24f34a4964781ae7e50500e21777754a670bd19a7420d6330" |
| 426 | "84e5556e33ca2c0e7d547ea5f46a07a01bf8669ae3bdec042d9b2ae5e6e" |
| 427 | "cf49f00ba9dac99ab6eff140d2cedf722ee62c2f9736857971444c25d0a" |
| 428 | "33d2017dc36d682a1054fe2a9428dda355a851ce6e6d61e03e419fd4ca4" |
| 429 | "e703313743d86caa885930f62ed5bf342d8165627681e9cc3244ba72aa2" |
| 430 | "2148400a6bbe80154e855d042c9dc2a3405f1e517be9dea50562f56da93" |
| 431 | "f6085f844a7e705c1f043e65751c583b80d29103e590ccb26efdaa0893d" |
| 432 | "833e36468f3907cfca788a3cb790f0341c8a31bf", 16 |
| 433 | ) |
| 434 | assert num.parameter_numbers.q == int( |
| 435 | "822ff5d234e073b901cf5941f58e1f538e71d40d", 16 |
| 436 | ) |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 437 | |
Paul Kehrer | 1effb6e | 2015-03-30 15:05:59 -0500 | [diff] [blame] | 438 | @pytest.mark.parametrize( |
| 439 | ("path", "loader_func"), |
| 440 | [ |
| 441 | [ |
| 442 | os.path.join("x509", "requests", "dsa_sha1.pem"), |
| 443 | x509.load_pem_x509_csr |
| 444 | ], |
| 445 | [ |
| 446 | os.path.join("x509", "requests", "dsa_sha1.der"), |
| 447 | x509.load_der_x509_csr |
| 448 | ], |
| 449 | ] |
| 450 | ) |
| 451 | def test_load_dsa_request(self, path, loader_func, backend): |
| 452 | request = _load_cert(path, loader_func, backend) |
Paul Kehrer | dc480ad | 2015-02-23 12:14:54 -0600 | [diff] [blame] | 453 | assert isinstance(request.signature_hash_algorithm, hashes.SHA1) |
| 454 | public_key = request.public_key() |
| 455 | assert isinstance(public_key, dsa.DSAPublicKey) |
| 456 | subject = request.subject |
| 457 | assert isinstance(subject, x509.Name) |
| 458 | assert list(subject) == [ |
| 459 | x509.NameAttribute(x509.OID_COMMON_NAME, 'cryptography.io'), |
| 460 | x509.NameAttribute(x509.OID_ORGANIZATION_NAME, 'PyCA'), |
| 461 | x509.NameAttribute(x509.OID_COUNTRY_NAME, 'US'), |
| 462 | x509.NameAttribute(x509.OID_STATE_OR_PROVINCE_NAME, 'Texas'), |
| 463 | x509.NameAttribute(x509.OID_LOCALITY_NAME, 'Austin'), |
| 464 | ] |
| 465 | |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 466 | |
| 467 | @pytest.mark.requires_backend_interface(interface=EllipticCurveBackend) |
| 468 | @pytest.mark.requires_backend_interface(interface=X509Backend) |
Paul Kehrer | e76cd27 | 2014-12-14 19:00:51 -0600 | [diff] [blame] | 469 | class TestECDSACertificate(object): |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 470 | def test_load_ecdsa_cert(self, backend): |
| 471 | _skip_curve_unsupported(backend, ec.SECP384R1()) |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 472 | cert = _load_cert( |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 473 | os.path.join("x509", "ecdsa_root.pem"), |
Paul Kehrer | 4112032 | 2014-12-02 18:31:14 -1000 | [diff] [blame] | 474 | x509.load_pem_x509_certificate, |
Paul Kehrer | a693cfd | 2014-11-27 07:47:58 -1000 | [diff] [blame] | 475 | backend |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 476 | ) |
Paul Kehrer | 8802a5b | 2015-02-13 12:06:57 -0600 | [diff] [blame] | 477 | assert isinstance(cert.signature_hash_algorithm, hashes.SHA384) |
Paul Kehrer | f1ef351 | 2014-11-26 17:36:05 -1000 | [diff] [blame] | 478 | public_key = cert.public_key() |
Alex Gaynor | 32c57df | 2015-02-23 21:51:27 -0800 | [diff] [blame] | 479 | assert isinstance(public_key, ec.EllipticCurvePublicKey) |
Alex Gaynor | fcadda6 | 2015-03-10 10:01:18 -0400 | [diff] [blame] | 480 | if isinstance(public_key, ec.EllipticCurvePublicKeyWithSerialization): |
Paul Kehrer | e76cd27 | 2014-12-14 19:00:51 -0600 | [diff] [blame] | 481 | num = public_key.public_numbers() |
| 482 | assert num.x == int( |
| 483 | "dda7d9bb8ab80bfb0b7f21d2f0bebe73f3335d1abc34eadec69bbcd095f" |
| 484 | "6f0ccd00bba615b51467e9e2d9fee8e630c17", 16 |
| 485 | ) |
| 486 | assert num.y == int( |
| 487 | "ec0770f5cf842e40839ce83f416d3badd3a4145936789d0343ee10136c7" |
| 488 | "2deae88a7a16bb543ce67dc23ff031ca3e23e", 16 |
| 489 | ) |
| 490 | assert isinstance(num.curve, ec.SECP384R1) |
Paul Kehrer | 6c660a8 | 2014-12-12 11:50:44 -0600 | [diff] [blame] | 491 | |
| 492 | def test_load_ecdsa_no_named_curve(self, backend): |
| 493 | _skip_curve_unsupported(backend, ec.SECP256R1()) |
| 494 | cert = _load_cert( |
| 495 | os.path.join("x509", "custom", "ec_no_named_curve.pem"), |
| 496 | x509.load_pem_x509_certificate, |
| 497 | backend |
| 498 | ) |
| 499 | with pytest.raises(NotImplementedError): |
| 500 | cert.public_key() |
Paul Kehrer | 912d3fb | 2015-01-29 11:19:22 -0600 | [diff] [blame] | 501 | |
Paul Kehrer | 1effb6e | 2015-03-30 15:05:59 -0500 | [diff] [blame] | 502 | @pytest.mark.parametrize( |
| 503 | ("path", "loader_func"), |
| 504 | [ |
| 505 | [ |
| 506 | os.path.join("x509", "requests", "ec_sha256.pem"), |
| 507 | x509.load_pem_x509_csr |
| 508 | ], |
| 509 | [ |
| 510 | os.path.join("x509", "requests", "ec_sha256.der"), |
| 511 | x509.load_der_x509_csr |
| 512 | ], |
| 513 | ] |
| 514 | ) |
| 515 | def test_load_ecdsa_certificate_request(self, path, loader_func, backend): |
Paul Kehrer | dc480ad | 2015-02-23 12:14:54 -0600 | [diff] [blame] | 516 | _skip_curve_unsupported(backend, ec.SECP384R1()) |
Paul Kehrer | 1effb6e | 2015-03-30 15:05:59 -0500 | [diff] [blame] | 517 | request = _load_cert(path, loader_func, backend) |
Paul Kehrer | dc480ad | 2015-02-23 12:14:54 -0600 | [diff] [blame] | 518 | assert isinstance(request.signature_hash_algorithm, hashes.SHA256) |
| 519 | public_key = request.public_key() |
| 520 | assert isinstance(public_key, ec.EllipticCurvePublicKey) |
| 521 | subject = request.subject |
| 522 | assert isinstance(subject, x509.Name) |
| 523 | assert list(subject) == [ |
| 524 | x509.NameAttribute(x509.OID_COMMON_NAME, 'cryptography.io'), |
| 525 | x509.NameAttribute(x509.OID_ORGANIZATION_NAME, 'PyCA'), |
| 526 | x509.NameAttribute(x509.OID_COUNTRY_NAME, 'US'), |
| 527 | x509.NameAttribute(x509.OID_STATE_OR_PROVINCE_NAME, 'Texas'), |
| 528 | x509.NameAttribute(x509.OID_LOCALITY_NAME, 'Austin'), |
| 529 | ] |
| 530 | |
Paul Kehrer | 912d3fb | 2015-01-29 11:19:22 -0600 | [diff] [blame] | 531 | |
Paul Kehrer | 806bfb2 | 2015-02-02 17:05:24 -0600 | [diff] [blame] | 532 | class TestNameAttribute(object): |
Alex Gaynor | a56ff41 | 2015-02-10 17:26:32 -0500 | [diff] [blame] | 533 | def test_init_bad_oid(self): |
| 534 | with pytest.raises(TypeError): |
| 535 | x509.NameAttribute(None, 'value') |
| 536 | |
Paul Kehrer | 912d3fb | 2015-01-29 11:19:22 -0600 | [diff] [blame] | 537 | def test_eq(self): |
Paul Kehrer | 806bfb2 | 2015-02-02 17:05:24 -0600 | [diff] [blame] | 538 | assert x509.NameAttribute( |
| 539 | x509.ObjectIdentifier('oid'), 'value' |
| 540 | ) == x509.NameAttribute( |
| 541 | x509.ObjectIdentifier('oid'), 'value' |
Paul Kehrer | 912d3fb | 2015-01-29 11:19:22 -0600 | [diff] [blame] | 542 | ) |
| 543 | |
| 544 | def test_ne(self): |
Paul Kehrer | 806bfb2 | 2015-02-02 17:05:24 -0600 | [diff] [blame] | 545 | assert x509.NameAttribute( |
| 546 | x509.ObjectIdentifier('2.5.4.3'), 'value' |
| 547 | ) != x509.NameAttribute( |
| 548 | x509.ObjectIdentifier('2.5.4.5'), 'value' |
Paul Kehrer | 912d3fb | 2015-01-29 11:19:22 -0600 | [diff] [blame] | 549 | ) |
Paul Kehrer | 806bfb2 | 2015-02-02 17:05:24 -0600 | [diff] [blame] | 550 | assert x509.NameAttribute( |
| 551 | x509.ObjectIdentifier('oid'), 'value' |
| 552 | ) != x509.NameAttribute( |
| 553 | x509.ObjectIdentifier('oid'), 'value2' |
Paul Kehrer | 912d3fb | 2015-01-29 11:19:22 -0600 | [diff] [blame] | 554 | ) |
Paul Kehrer | 806bfb2 | 2015-02-02 17:05:24 -0600 | [diff] [blame] | 555 | assert x509.NameAttribute( |
| 556 | x509.ObjectIdentifier('oid'), 'value' |
Paul Kehrer | 912d3fb | 2015-01-29 11:19:22 -0600 | [diff] [blame] | 557 | ) != object() |
| 558 | |
Paul Kehrer | a498be8 | 2015-02-12 15:00:56 -0600 | [diff] [blame] | 559 | def test_repr(self): |
| 560 | na = x509.NameAttribute(x509.ObjectIdentifier('2.5.4.3'), 'value') |
| 561 | assert repr(na) == ( |
| 562 | "<NameAttribute(oid=<ObjectIdentifier(oid=2.5.4.3, name=commonName" |
| 563 | ")>, value='value')>" |
| 564 | ) |
| 565 | |
Paul Kehrer | 912d3fb | 2015-01-29 11:19:22 -0600 | [diff] [blame] | 566 | |
| 567 | class TestObjectIdentifier(object): |
| 568 | def test_eq(self): |
Paul Kehrer | 806bfb2 | 2015-02-02 17:05:24 -0600 | [diff] [blame] | 569 | oid1 = x509.ObjectIdentifier('oid') |
| 570 | oid2 = x509.ObjectIdentifier('oid') |
Paul Kehrer | 912d3fb | 2015-01-29 11:19:22 -0600 | [diff] [blame] | 571 | assert oid1 == oid2 |
| 572 | |
| 573 | def test_ne(self): |
Paul Kehrer | 806bfb2 | 2015-02-02 17:05:24 -0600 | [diff] [blame] | 574 | oid1 = x509.ObjectIdentifier('oid') |
| 575 | assert oid1 != x509.ObjectIdentifier('oid1') |
Paul Kehrer | 912d3fb | 2015-01-29 11:19:22 -0600 | [diff] [blame] | 576 | assert oid1 != object() |
| 577 | |
| 578 | def test_repr(self): |
Paul Kehrer | 806bfb2 | 2015-02-02 17:05:24 -0600 | [diff] [blame] | 579 | oid = x509.ObjectIdentifier("2.5.4.3") |
| 580 | assert repr(oid) == "<ObjectIdentifier(oid=2.5.4.3, name=commonName)>" |
| 581 | oid = x509.ObjectIdentifier("oid1") |
| 582 | assert repr(oid) == "<ObjectIdentifier(oid=oid1, name=Unknown OID)>" |
Paul Kehrer | 719d536 | 2015-01-01 20:03:52 -0600 | [diff] [blame] | 583 | |
| 584 | |
| 585 | class TestName(object): |
| 586 | def test_eq(self): |
| 587 | name1 = x509.Name([ |
| 588 | x509.NameAttribute(x509.ObjectIdentifier('oid'), 'value1'), |
| 589 | x509.NameAttribute(x509.ObjectIdentifier('oid2'), 'value2'), |
| 590 | ]) |
| 591 | name2 = x509.Name([ |
| 592 | x509.NameAttribute(x509.ObjectIdentifier('oid'), 'value1'), |
| 593 | x509.NameAttribute(x509.ObjectIdentifier('oid2'), 'value2'), |
| 594 | ]) |
| 595 | assert name1 == name2 |
| 596 | |
| 597 | def test_ne(self): |
| 598 | name1 = x509.Name([ |
| 599 | x509.NameAttribute(x509.ObjectIdentifier('oid'), 'value1'), |
| 600 | x509.NameAttribute(x509.ObjectIdentifier('oid2'), 'value2'), |
| 601 | ]) |
| 602 | name2 = x509.Name([ |
| 603 | x509.NameAttribute(x509.ObjectIdentifier('oid2'), 'value2'), |
| 604 | x509.NameAttribute(x509.ObjectIdentifier('oid'), 'value1'), |
| 605 | ]) |
| 606 | assert name1 != name2 |
| 607 | assert name1 != object() |
Paul Kehrer | 1fb35c9 | 2015-04-11 15:42:54 -0400 | [diff] [blame] | 608 | |
| 609 | def test_repr(self): |
| 610 | name = x509.Name([ |
| 611 | x509.NameAttribute(x509.OID_COMMON_NAME, 'cryptography.io'), |
| 612 | x509.NameAttribute(x509.OID_ORGANIZATION_NAME, 'PyCA'), |
| 613 | ]) |
| 614 | |
| 615 | assert repr(name) == ( |
Paul Kehrer | e613e5d | 2015-04-11 15:52:04 -0400 | [diff] [blame] | 616 | "<Name([<NameAttribute(oid=<ObjectIdentifier(oid=2.5.4.3, name=com" |
| 617 | "monName)>, value='cryptography.io')>, <NameAttribute(oid=<ObjectI" |
| 618 | "dentifier(oid=2.5.4.10, name=organizationName)>, value='PyCA')>])" |
| 619 | ">" |
Paul Kehrer | 1fb35c9 | 2015-04-11 15:42:54 -0400 | [diff] [blame] | 620 | ) |