diff options
| author | shadchin <shadchin@yandex-team.com> | 2023-10-02 15:08:44 +0300 |
|---|---|---|
| committer | shadchin <shadchin@yandex-team.com> | 2023-10-02 15:35:28 +0300 |
| commit | 78229dda48cda2402d17aa589f9e2165b3513caf (patch) | |
| tree | ab840878d8609ee3f8b0d44f0dc04ef47e94ee23 | |
| parent | 991934594f5abcdb6405f3021b7a3ba9c1b38349 (diff) | |
| download | ydb-78229dda48cda2402d17aa589f9e2165b3513caf.tar.gz | |
Split cryptography on py2/py3
185 files changed, 76184 insertions, 119 deletions
diff --git a/contrib/python/cryptography/.dist-info/METADATA b/contrib/python/cryptography/py2/.dist-info/METADATA index 7abd5f9465..7abd5f9465 100644 --- a/contrib/python/cryptography/.dist-info/METADATA +++ b/contrib/python/cryptography/py2/.dist-info/METADATA diff --git a/contrib/python/cryptography/.dist-info/top_level.txt b/contrib/python/cryptography/py2/.dist-info/top_level.txt index 52ccfc6e37..52ccfc6e37 100644 --- a/contrib/python/cryptography/.dist-info/top_level.txt +++ b/contrib/python/cryptography/py2/.dist-info/top_level.txt diff --git a/contrib/python/cryptography/LICENSE b/contrib/python/cryptography/py2/LICENSE index 07074259b6..07074259b6 100644 --- a/contrib/python/cryptography/LICENSE +++ b/contrib/python/cryptography/py2/LICENSE diff --git a/contrib/python/cryptography/LICENSE.APACHE b/contrib/python/cryptography/py2/LICENSE.APACHE index 62589edd12..62589edd12 100644 --- a/contrib/python/cryptography/LICENSE.APACHE +++ b/contrib/python/cryptography/py2/LICENSE.APACHE diff --git a/contrib/python/cryptography/LICENSE.BSD b/contrib/python/cryptography/py2/LICENSE.BSD index ec1a29d34d..ec1a29d34d 100644 --- a/contrib/python/cryptography/LICENSE.BSD +++ b/contrib/python/cryptography/py2/LICENSE.BSD diff --git a/contrib/python/cryptography/LICENSE.PSF b/contrib/python/cryptography/py2/LICENSE.PSF index 4d3a4f57de..4d3a4f57de 100644 --- a/contrib/python/cryptography/LICENSE.PSF +++ b/contrib/python/cryptography/py2/LICENSE.PSF diff --git a/contrib/python/cryptography/build/temp.linux-x86_64-2.7/_openssl.c b/contrib/python/cryptography/py2/build/temp.linux-x86_64-2.7/_openssl.c index 5a6e835914..5a6e835914 100644 --- a/contrib/python/cryptography/build/temp.linux-x86_64-2.7/_openssl.c +++ b/contrib/python/cryptography/py2/build/temp.linux-x86_64-2.7/_openssl.c diff --git a/contrib/python/cryptography/build/temp.linux-x86_64-2.7/_padding.c b/contrib/python/cryptography/py2/build/temp.linux-x86_64-2.7/_padding.c index aa3f1b819d..aa3f1b819d 100644 --- a/contrib/python/cryptography/build/temp.linux-x86_64-2.7/_padding.c +++ b/contrib/python/cryptography/py2/build/temp.linux-x86_64-2.7/_padding.c diff --git a/contrib/python/cryptography/cryptography/__about__.py b/contrib/python/cryptography/py2/cryptography/__about__.py index f816509257..f816509257 100644 --- a/contrib/python/cryptography/cryptography/__about__.py +++ b/contrib/python/cryptography/py2/cryptography/__about__.py diff --git a/contrib/python/cryptography/cryptography/__init__.py b/contrib/python/cryptography/py2/cryptography/__init__.py index 0fcaef8370..0fcaef8370 100644 --- a/contrib/python/cryptography/cryptography/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/__init__.py diff --git a/contrib/python/cryptography/cryptography/exceptions.py b/contrib/python/cryptography/py2/cryptography/exceptions.py index 1d52d7dcfc..1d52d7dcfc 100644 --- a/contrib/python/cryptography/cryptography/exceptions.py +++ b/contrib/python/cryptography/py2/cryptography/exceptions.py diff --git a/contrib/python/cryptography/cryptography/fernet.py b/contrib/python/cryptography/py2/cryptography/fernet.py index 00c2528671..00c2528671 100644 --- a/contrib/python/cryptography/cryptography/fernet.py +++ b/contrib/python/cryptography/py2/cryptography/fernet.py diff --git a/contrib/python/cryptography/cryptography/hazmat/__init__.py b/contrib/python/cryptography/py2/cryptography/hazmat/__init__.py index 9f06a9949a..9f06a9949a 100644 --- a/contrib/python/cryptography/cryptography/hazmat/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/__init__.py diff --git a/contrib/python/cryptography/cryptography/hazmat/_der.py b/contrib/python/cryptography/py2/cryptography/hazmat/_der.py index 462b911b45..462b911b45 100644 --- a/contrib/python/cryptography/cryptography/hazmat/_der.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/_der.py diff --git a/contrib/python/cryptography/cryptography/hazmat/_oid.py b/contrib/python/cryptography/py2/cryptography/hazmat/_oid.py index de2771a737..de2771a737 100644 --- a/contrib/python/cryptography/cryptography/hazmat/_oid.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/_oid.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/__init__.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/__init__.py index 1563936dde..1563936dde 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/__init__.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/interfaces.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/interfaces.py index 418980a34e..418980a34e 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/interfaces.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/interfaces.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/__init__.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/__init__.py index 8eadeb6e18..8eadeb6e18 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/__init__.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/aead.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/aead.py index 4494916852..4494916852 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/aead.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/aead.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/backend.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/backend.py index 45d4a1a1ee..45d4a1a1ee 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/backend.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/backend.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/ciphers.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/ciphers.py index ad5dad3f7e..ad5dad3f7e 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/ciphers.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/ciphers.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/cmac.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/cmac.py index 195fc230f2..195fc230f2 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/cmac.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/cmac.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/decode_asn1.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/decode_asn1.py index cc9b8c0e34..cc9b8c0e34 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/decode_asn1.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/decode_asn1.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/dh.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/dh.py index 2862676c65..2862676c65 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/dh.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/dh.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/dsa.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/dsa.py index 0c5faba18a..0c5faba18a 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/dsa.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/dsa.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/ec.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/ec.py index 05d32baba6..05d32baba6 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/ec.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/ec.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/ed25519.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/ed25519.py index 13bec3af10..13bec3af10 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/ed25519.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/ed25519.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/ed448.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/ed448.py index 6512770e5b..6512770e5b 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/ed448.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/ed448.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/encode_asn1.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/encode_asn1.py index 0a33200bbc..0a33200bbc 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/encode_asn1.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/encode_asn1.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/hashes.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/hashes.py index 764dce0ede..764dce0ede 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/hashes.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/hashes.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/hmac.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/hmac.py index 1cc9d99fec..1cc9d99fec 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/hmac.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/hmac.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/ocsp.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/ocsp.py index 50c02e7a80..50c02e7a80 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/ocsp.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/ocsp.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/poly1305.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/poly1305.py index 5699918b17..5699918b17 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/poly1305.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/poly1305.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/rsa.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/rsa.py index 82cd49c960..82cd49c960 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/rsa.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/rsa.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/utils.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/utils.py index 3d697d1fb5..3d697d1fb5 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/utils.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/utils.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/x25519.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/x25519.py index 4971c54814..4971c54814 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/x25519.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/x25519.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/x448.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/x448.py index 7ebcdf84bc..7ebcdf84bc 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/x448.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/x448.py diff --git a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/x509.py b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/x509.py index 4d0dac7649..4d0dac7649 100644 --- a/contrib/python/cryptography/cryptography/hazmat/backends/openssl/x509.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/backends/openssl/x509.py diff --git a/contrib/python/cryptography/cryptography/hazmat/bindings/__init__.py b/contrib/python/cryptography/py2/cryptography/hazmat/bindings/__init__.py index 4b540884df..4b540884df 100644 --- a/contrib/python/cryptography/cryptography/hazmat/bindings/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/bindings/__init__.py diff --git a/contrib/python/cryptography/cryptography/hazmat/bindings/openssl/__init__.py b/contrib/python/cryptography/py2/cryptography/hazmat/bindings/openssl/__init__.py index 4b540884df..4b540884df 100644 --- a/contrib/python/cryptography/cryptography/hazmat/bindings/openssl/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/bindings/openssl/__init__.py diff --git a/contrib/python/cryptography/cryptography/hazmat/bindings/openssl/_conditional.py b/contrib/python/cryptography/py2/cryptography/hazmat/bindings/openssl/_conditional.py index ca50fed134..ca50fed134 100644 --- a/contrib/python/cryptography/cryptography/hazmat/bindings/openssl/_conditional.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/bindings/openssl/_conditional.py diff --git a/contrib/python/cryptography/cryptography/hazmat/bindings/openssl/binding.py b/contrib/python/cryptography/py2/cryptography/hazmat/bindings/openssl/binding.py index 7a84a340e4..7a84a340e4 100644 --- a/contrib/python/cryptography/cryptography/hazmat/bindings/openssl/binding.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/bindings/openssl/binding.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/__init__.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/__init__.py index 4b540884df..4b540884df 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/__init__.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/__init__.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/__init__.py index 494a7a1350..494a7a1350 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/__init__.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/dh.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/dh.py index 74a311d501..74a311d501 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/dh.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/dh.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/dsa.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/dsa.py index 8ccc66665f..8ccc66665f 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/dsa.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/dsa.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/ec.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/ec.py index c7e694fc56..c7e694fc56 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/ec.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/ec.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/ed25519.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/ed25519.py index 2d07a029bc..2d07a029bc 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/ed25519.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/ed25519.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/ed448.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/ed448.py index 520ffcbcbc..520ffcbcbc 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/ed448.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/ed448.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/padding.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/padding.py index fc8f6e26a9..fc8f6e26a9 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/padding.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/padding.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/rsa.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/rsa.py index ea16bbf66e..ea16bbf66e 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/rsa.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/rsa.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/utils.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/utils.py index 5f9b677868..5f9b677868 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/utils.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/utils.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/x25519.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/x25519.py index fc63691536..fc63691536 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/x25519.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/x25519.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/x448.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/x448.py index 3ac067bfd5..3ac067bfd5 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/asymmetric/x448.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/asymmetric/x448.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/ciphers/__init__.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/ciphers/__init__.py index 4380f72b2e..4380f72b2e 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/ciphers/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/ciphers/__init__.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/ciphers/aead.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/ciphers/aead.py index c8c93955ce..c8c93955ce 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/ciphers/aead.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/ciphers/aead.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/ciphers/algorithms.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/ciphers/algorithms.py index 8072cedd17..8072cedd17 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/ciphers/algorithms.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/ciphers/algorithms.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/ciphers/base.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/ciphers/base.py index dae425a299..dae425a299 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/ciphers/base.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/ciphers/base.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/ciphers/modes.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/ciphers/modes.py index 0ba0f2b5a1..0ba0f2b5a1 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/ciphers/modes.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/ciphers/modes.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/cmac.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/cmac.py index bf962c9069..bf962c9069 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/cmac.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/cmac.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/constant_time.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/constant_time.py index 7f41b9efa5..7f41b9efa5 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/constant_time.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/constant_time.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/hashes.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/hashes.py index 18e2bab363..18e2bab363 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/hashes.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/hashes.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/hmac.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/hmac.py index 8c421dc68d..8c421dc68d 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/hmac.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/hmac.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/__init__.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/__init__.py index 2d0724e5da..2d0724e5da 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/__init__.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/concatkdf.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/concatkdf.py index 7cc0324fc4..7cc0324fc4 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/concatkdf.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/concatkdf.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/hkdf.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/hkdf.py index 9bb6bc2132..9bb6bc2132 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/hkdf.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/hkdf.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/kbkdf.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/kbkdf.py index 864337001c..864337001c 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/kbkdf.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/kbkdf.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/pbkdf2.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/pbkdf2.py index 5b67d48bba..5b67d48bba 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/pbkdf2.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/pbkdf2.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/scrypt.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/scrypt.py index f028646aa0..f028646aa0 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/scrypt.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/scrypt.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/x963kdf.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/x963kdf.py index 1898d526a4..1898d526a4 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/kdf/x963kdf.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/kdf/x963kdf.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/keywrap.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/keywrap.py index 2439cafe6d..2439cafe6d 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/keywrap.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/keywrap.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/padding.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/padding.py index 98abffbc08..98abffbc08 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/padding.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/padding.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/poly1305.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/poly1305.py index 6439686202..6439686202 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/poly1305.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/poly1305.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/serialization/__init__.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/serialization/__init__.py index c2f9b014a6..c2f9b014a6 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/serialization/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/serialization/__init__.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/serialization/base.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/serialization/base.py index fc27235c5c..fc27235c5c 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/serialization/base.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/serialization/base.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/serialization/pkcs12.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/serialization/pkcs12.py index 201f32941c..201f32941c 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/serialization/pkcs12.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/serialization/pkcs12.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/serialization/pkcs7.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/serialization/pkcs7.py index 1e11e28ef5..1e11e28ef5 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/serialization/pkcs7.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/serialization/pkcs7.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/serialization/ssh.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/serialization/ssh.py index 5ecae59f8a..5ecae59f8a 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/serialization/ssh.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/serialization/ssh.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/twofactor/__init__.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/twofactor/__init__.py index e71f9e67a3..e71f9e67a3 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/twofactor/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/twofactor/__init__.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/twofactor/hotp.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/twofactor/hotp.py index c00eec0e54..c00eec0e54 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/twofactor/hotp.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/twofactor/hotp.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/twofactor/totp.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/twofactor/totp.py index d59539b3f9..d59539b3f9 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/twofactor/totp.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/twofactor/totp.py diff --git a/contrib/python/cryptography/cryptography/hazmat/primitives/twofactor/utils.py b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/twofactor/utils.py index 0afa1ccc04..0afa1ccc04 100644 --- a/contrib/python/cryptography/cryptography/hazmat/primitives/twofactor/utils.py +++ b/contrib/python/cryptography/py2/cryptography/hazmat/primitives/twofactor/utils.py diff --git a/contrib/python/cryptography/cryptography/utils.py b/contrib/python/cryptography/py2/cryptography/utils.py index bdb3dbf477..bdb3dbf477 100644 --- a/contrib/python/cryptography/cryptography/utils.py +++ b/contrib/python/cryptography/py2/cryptography/utils.py diff --git a/contrib/python/cryptography/cryptography/x509/__init__.py b/contrib/python/cryptography/py2/cryptography/x509/__init__.py index 69630e4cba..69630e4cba 100644 --- a/contrib/python/cryptography/cryptography/x509/__init__.py +++ b/contrib/python/cryptography/py2/cryptography/x509/__init__.py diff --git a/contrib/python/cryptography/cryptography/x509/base.py b/contrib/python/cryptography/py2/cryptography/x509/base.py index f3bc872b94..f3bc872b94 100644 --- a/contrib/python/cryptography/cryptography/x509/base.py +++ b/contrib/python/cryptography/py2/cryptography/x509/base.py diff --git a/contrib/python/cryptography/cryptography/x509/certificate_transparency.py b/contrib/python/cryptography/py2/cryptography/x509/certificate_transparency.py index d00fe81269..d00fe81269 100644 --- a/contrib/python/cryptography/cryptography/x509/certificate_transparency.py +++ b/contrib/python/cryptography/py2/cryptography/x509/certificate_transparency.py diff --git a/contrib/python/cryptography/cryptography/x509/extensions.py b/contrib/python/cryptography/py2/cryptography/x509/extensions.py index 130ba69b87..130ba69b87 100644 --- a/contrib/python/cryptography/cryptography/x509/extensions.py +++ b/contrib/python/cryptography/py2/cryptography/x509/extensions.py diff --git a/contrib/python/cryptography/cryptography/x509/general_name.py b/contrib/python/cryptography/py2/cryptography/x509/general_name.py index 9be9d8c991..9be9d8c991 100644 --- a/contrib/python/cryptography/cryptography/x509/general_name.py +++ b/contrib/python/cryptography/py2/cryptography/x509/general_name.py diff --git a/contrib/python/cryptography/cryptography/x509/name.py b/contrib/python/cryptography/py2/cryptography/x509/name.py index 0be876a0ed..0be876a0ed 100644 --- a/contrib/python/cryptography/cryptography/x509/name.py +++ b/contrib/python/cryptography/py2/cryptography/x509/name.py diff --git a/contrib/python/cryptography/cryptography/x509/ocsp.py b/contrib/python/cryptography/py2/cryptography/x509/ocsp.py index f8e27224ec..f8e27224ec 100644 --- a/contrib/python/cryptography/cryptography/x509/ocsp.py +++ b/contrib/python/cryptography/py2/cryptography/x509/ocsp.py diff --git a/contrib/python/cryptography/cryptography/x509/oid.py b/contrib/python/cryptography/py2/cryptography/x509/oid.py index 2bf606e50d..2bf606e50d 100644 --- a/contrib/python/cryptography/cryptography/x509/oid.py +++ b/contrib/python/cryptography/py2/cryptography/x509/oid.py diff --git a/contrib/python/cryptography/py2/ya.make b/contrib/python/cryptography/py2/ya.make new file mode 100644 index 0000000000..e401931861 --- /dev/null +++ b/contrib/python/cryptography/py2/ya.make @@ -0,0 +1,129 @@ +PY2_LIBRARY() + +LICENSE(BSD-3-Clause) + +VERSION(3.3.2) + +IF (PYTHON2) + PEERDIR( + contrib/deprecated/python/enum34 + contrib/deprecated/python/ipaddress + ) +ENDIF() + +PEERDIR( + contrib/libs/openssl + contrib/python/cffi + # contrib/python/idna + # contrib/python/asn1crypto + contrib/python/setuptools + contrib/python/six +) + +NO_COMPILER_WARNINGS() +NO_LINT() + +RESOURCE_FILES( + PREFIX contrib/python/cryptography/py2/ + .dist-info/METADATA + .dist-info/top_level.txt +) + +SRCS( + build/temp.linux-x86_64-2.7/_openssl.c + build/temp.linux-x86_64-2.7/_padding.c +) + +PY_REGISTER( + cryptography.hazmat.bindings._openssl + cryptography.hazmat.bindings._padding +) + +PY_SRCS( + TOP_LEVEL + cryptography/__about__.py + cryptography/__init__.py + cryptography/exceptions.py + cryptography/fernet.py + cryptography/hazmat/__init__.py + cryptography/hazmat/_der.py + cryptography/hazmat/_oid.py + cryptography/hazmat/backends/__init__.py + cryptography/hazmat/backends/interfaces.py + cryptography/hazmat/backends/openssl/__init__.py + cryptography/hazmat/backends/openssl/aead.py + cryptography/hazmat/backends/openssl/backend.py + cryptography/hazmat/backends/openssl/ciphers.py + cryptography/hazmat/backends/openssl/cmac.py + cryptography/hazmat/backends/openssl/decode_asn1.py + cryptography/hazmat/backends/openssl/dh.py + cryptography/hazmat/backends/openssl/dsa.py + cryptography/hazmat/backends/openssl/ec.py + cryptography/hazmat/backends/openssl/ed25519.py + cryptography/hazmat/backends/openssl/ed448.py + cryptography/hazmat/backends/openssl/encode_asn1.py + cryptography/hazmat/backends/openssl/hashes.py + cryptography/hazmat/backends/openssl/hmac.py + cryptography/hazmat/backends/openssl/ocsp.py + cryptography/hazmat/backends/openssl/poly1305.py + cryptography/hazmat/backends/openssl/rsa.py + cryptography/hazmat/backends/openssl/utils.py + cryptography/hazmat/backends/openssl/x25519.py + cryptography/hazmat/backends/openssl/x448.py + cryptography/hazmat/backends/openssl/x509.py + cryptography/hazmat/bindings/__init__.py + cryptography/hazmat/bindings/openssl/__init__.py + cryptography/hazmat/bindings/openssl/_conditional.py + cryptography/hazmat/bindings/openssl/binding.py + cryptography/hazmat/primitives/__init__.py + cryptography/hazmat/primitives/asymmetric/__init__.py + cryptography/hazmat/primitives/asymmetric/dh.py + cryptography/hazmat/primitives/asymmetric/dsa.py + cryptography/hazmat/primitives/asymmetric/ec.py + cryptography/hazmat/primitives/asymmetric/ed25519.py + cryptography/hazmat/primitives/asymmetric/ed448.py + cryptography/hazmat/primitives/asymmetric/padding.py + cryptography/hazmat/primitives/asymmetric/rsa.py + cryptography/hazmat/primitives/asymmetric/utils.py + cryptography/hazmat/primitives/asymmetric/x25519.py + cryptography/hazmat/primitives/asymmetric/x448.py + cryptography/hazmat/primitives/ciphers/__init__.py + cryptography/hazmat/primitives/ciphers/aead.py + cryptography/hazmat/primitives/ciphers/algorithms.py + cryptography/hazmat/primitives/ciphers/base.py + cryptography/hazmat/primitives/ciphers/modes.py + cryptography/hazmat/primitives/cmac.py + cryptography/hazmat/primitives/constant_time.py + cryptography/hazmat/primitives/hashes.py + cryptography/hazmat/primitives/hmac.py + cryptography/hazmat/primitives/kdf/__init__.py + cryptography/hazmat/primitives/kdf/concatkdf.py + cryptography/hazmat/primitives/kdf/hkdf.py + cryptography/hazmat/primitives/kdf/kbkdf.py + cryptography/hazmat/primitives/kdf/pbkdf2.py + cryptography/hazmat/primitives/kdf/scrypt.py + cryptography/hazmat/primitives/kdf/x963kdf.py + cryptography/hazmat/primitives/keywrap.py + cryptography/hazmat/primitives/padding.py + cryptography/hazmat/primitives/poly1305.py + cryptography/hazmat/primitives/serialization/__init__.py + cryptography/hazmat/primitives/serialization/base.py + cryptography/hazmat/primitives/serialization/pkcs12.py + cryptography/hazmat/primitives/serialization/pkcs7.py + cryptography/hazmat/primitives/serialization/ssh.py + cryptography/hazmat/primitives/twofactor/__init__.py + cryptography/hazmat/primitives/twofactor/hotp.py + cryptography/hazmat/primitives/twofactor/totp.py + cryptography/hazmat/primitives/twofactor/utils.py + cryptography/utils.py + cryptography/x509/__init__.py + cryptography/x509/base.py + cryptography/x509/certificate_transparency.py + cryptography/x509/extensions.py + cryptography/x509/general_name.py + cryptography/x509/name.py + cryptography/x509/ocsp.py + cryptography/x509/oid.py +) + +END() diff --git a/contrib/python/cryptography/py3/.dist-info/METADATA b/contrib/python/cryptography/py3/.dist-info/METADATA new file mode 100644 index 0000000000..7abd5f9465 --- /dev/null +++ b/contrib/python/cryptography/py3/.dist-info/METADATA @@ -0,0 +1,131 @@ +Metadata-Version: 2.1 +Name: cryptography +Version: 3.3.2 +Summary: cryptography is a package which provides cryptographic recipes and primitives to Python developers. +Home-page: https://github.com/pyca/cryptography +Author: The cryptography developers +Author-email: cryptography-dev@python.org +License: BSD or Apache License, Version 2.0 +Platform: UNKNOWN +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: Apache Software License +Classifier: License :: OSI Approved :: BSD License +Classifier: Natural Language :: English +Classifier: Operating System :: MacOS :: MacOS X +Classifier: Operating System :: POSIX +Classifier: Operating System :: POSIX :: BSD +Classifier: Operating System :: POSIX :: Linux +Classifier: Operating System :: Microsoft :: Windows +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 2.7 +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: Topic :: Security :: Cryptography +Requires-Python: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.* +Description-Content-Type: text/x-rst +Requires-Dist: six (>=1.4.1) +Requires-Dist: cffi (>=1.12) +Requires-Dist: enum34 ; python_version < '3' +Requires-Dist: ipaddress ; python_version < '3' +Provides-Extra: docs +Requires-Dist: sphinx (!=1.8.0,!=3.1.0,!=3.1.1,>=1.6.5) ; extra == 'docs' +Requires-Dist: sphinx-rtd-theme ; extra == 'docs' +Provides-Extra: docstest +Requires-Dist: doc8 ; extra == 'docstest' +Requires-Dist: pyenchant (>=1.6.11) ; extra == 'docstest' +Requires-Dist: twine (>=1.12.0) ; extra == 'docstest' +Requires-Dist: sphinxcontrib-spelling (>=4.0.1) ; extra == 'docstest' +Provides-Extra: pep8test +Requires-Dist: black ; extra == 'pep8test' +Requires-Dist: flake8 ; extra == 'pep8test' +Requires-Dist: flake8-import-order ; extra == 'pep8test' +Requires-Dist: pep8-naming ; extra == 'pep8test' +Provides-Extra: ssh +Requires-Dist: bcrypt (>=3.1.5) ; extra == 'ssh' +Provides-Extra: test +Requires-Dist: pytest (!=3.9.0,!=3.9.1,!=3.9.2,>=3.6.0) ; extra == 'test' +Requires-Dist: pretend ; extra == 'test' +Requires-Dist: iso8601 ; extra == 'test' +Requires-Dist: pytz ; extra == 'test' +Requires-Dist: hypothesis (!=3.79.2,>=1.11.4) ; extra == 'test' + +pyca/cryptography +================= + +.. image:: https://img.shields.io/pypi/v/cryptography.svg + :target: https://pypi.org/project/cryptography/ + :alt: Latest Version + +.. image:: https://readthedocs.org/projects/cryptography/badge/?version=latest + :target: https://cryptography.io + :alt: Latest Docs + +.. image:: https://github.com/pyca/cryptography/workflows/CI/badge.svg?branch=master + :target: https://github.com/pyca/cryptography/actions?query=workflow%3ACI+branch%3Amaster + +.. image:: https://codecov.io/github/pyca/cryptography/coverage.svg?branch=master + :target: https://codecov.io/github/pyca/cryptography?branch=master + + +``cryptography`` is a package which provides cryptographic recipes and +primitives to Python developers. Our goal is for it to be your "cryptographic +standard library". It supports Python 2.7, Python 3.6+, and PyPy 5.4+. + +``cryptography`` includes both high level recipes and low level interfaces to +common cryptographic algorithms such as symmetric ciphers, message digests, and +key derivation functions. For example, to encrypt something with +``cryptography``'s high level symmetric encryption recipe: + +.. code-block:: pycon + + >>> from cryptography.fernet import Fernet + >>> # Put this somewhere safe! + >>> key = Fernet.generate_key() + >>> f = Fernet(key) + >>> token = f.encrypt(b"A really secret message. Not for prying eyes.") + >>> token + '...' + >>> f.decrypt(token) + 'A really secret message. Not for prying eyes.' + +You can find more information in the `documentation`_. + +You can install ``cryptography`` with: + +.. code-block:: console + + $ pip install cryptography + +For full details see `the installation documentation`_. + +Discussion +~~~~~~~~~~ + +If you run into bugs, you can file them in our `issue tracker`_. + +We maintain a `cryptography-dev`_ mailing list for development discussion. + +You can also join ``#cryptography-dev`` on Freenode to ask questions or get +involved. + +Security +~~~~~~~~ + +Need to report a security issue? Please consult our `security reporting`_ +documentation. + + +.. _`documentation`: https://cryptography.io/ +.. _`the installation documentation`: https://cryptography.io/en/latest/installation.html +.. _`issue tracker`: https://github.com/pyca/cryptography/issues +.. _`cryptography-dev`: https://mail.python.org/mailman/listinfo/cryptography-dev +.. _`security reporting`: https://cryptography.io/en/latest/security.html + + diff --git a/contrib/python/cryptography/py3/.dist-info/top_level.txt b/contrib/python/cryptography/py3/.dist-info/top_level.txt new file mode 100644 index 0000000000..52ccfc6e37 --- /dev/null +++ b/contrib/python/cryptography/py3/.dist-info/top_level.txt @@ -0,0 +1,3 @@ +_openssl +_padding +cryptography diff --git a/contrib/python/cryptography/py3/LICENSE b/contrib/python/cryptography/py3/LICENSE new file mode 100644 index 0000000000..07074259b6 --- /dev/null +++ b/contrib/python/cryptography/py3/LICENSE @@ -0,0 +1,6 @@ +This software is made available under the terms of *either* of the licenses +found in LICENSE.APACHE or LICENSE.BSD. Contributions to cryptography are made +under the terms of *both* these licenses. + +The code used in the OS random engine is derived from CPython, and is licensed +under the terms of the PSF License Agreement. diff --git a/contrib/python/cryptography/py3/LICENSE.APACHE b/contrib/python/cryptography/py3/LICENSE.APACHE new file mode 100644 index 0000000000..62589edd12 --- /dev/null +++ b/contrib/python/cryptography/py3/LICENSE.APACHE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + https://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + https://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/contrib/python/cryptography/py3/LICENSE.BSD b/contrib/python/cryptography/py3/LICENSE.BSD new file mode 100644 index 0000000000..ec1a29d34d --- /dev/null +++ b/contrib/python/cryptography/py3/LICENSE.BSD @@ -0,0 +1,27 @@ +Copyright (c) Individual contributors. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + 3. Neither the name of PyCA Cryptography nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/contrib/python/cryptography/py3/LICENSE.PSF b/contrib/python/cryptography/py3/LICENSE.PSF new file mode 100644 index 0000000000..4d3a4f57de --- /dev/null +++ b/contrib/python/cryptography/py3/LICENSE.PSF @@ -0,0 +1,41 @@ +1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and + the Individual or Organization ("Licensee") accessing and otherwise using Python + 2.7.12 software in source or binary form and its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, PSF hereby + grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, + analyze, test, perform and/or display publicly, prepare derivative works, + distribute, and otherwise use Python 2.7.12 alone or in any derivative + version, provided, however, that PSF's License Agreement and PSF's notice of + copyright, i.e., "Copyright © 2001-2016 Python Software Foundation; All Rights + Reserved" are retained in Python 2.7.12 alone or in any derivative version + prepared by Licensee. + +3. In the event Licensee prepares a derivative work that is based on or + incorporates Python 2.7.12 or any part thereof, and wants to make the + derivative work available to others as provided herein, then Licensee hereby + agrees to include in any such work a brief summary of the changes made to Python + 2.7.12. + +4. PSF is making Python 2.7.12 available to Licensee on an "AS IS" basis. + PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF + EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR + WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE + USE OF PYTHON 2.7.12 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. + +5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.7.12 + FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF + MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.7.12, OR ANY DERIVATIVE + THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material breach of + its terms and conditions. + +7. Nothing in this License Agreement shall be deemed to create any relationship + of agency, partnership, or joint venture between PSF and Licensee. This License + Agreement does not grant permission to use PSF trademarks or trade name in a + trademark sense to endorse or promote products or services of Licensee, or any + third party. + +8. By copying, installing or otherwise using Python 2.7.12, Licensee agrees + to be bound by the terms and conditions of this License Agreement. diff --git a/contrib/python/cryptography/py3/build/temp.linux-x86_64-2.7/_openssl.c b/contrib/python/cryptography/py3/build/temp.linux-x86_64-2.7/_openssl.c new file mode 100644 index 0000000000..5a6e835914 --- /dev/null +++ b/contrib/python/cryptography/py3/build/temp.linux-x86_64-2.7/_openssl.c @@ -0,0 +1,55695 @@ +#define _CFFI_ + +/* We try to define Py_LIMITED_API before including Python.h. + + Mess: we can only define it if Py_DEBUG, Py_TRACE_REFS and + Py_REF_DEBUG are not defined. This is a best-effort approximation: + we can learn about Py_DEBUG from pyconfig.h, but it is unclear if + the same works for the other two macros. Py_DEBUG implies them, + but not the other way around. +*/ +#ifndef _CFFI_USE_EMBEDDING +# include <pyconfig.h> +# if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) +# define Py_LIMITED_API +# endif +#endif + +#include <Python.h> +#ifdef __cplusplus +extern "C" { +#endif +#include <stddef.h> + +/* This part is from file 'cffi/parse_c_type.h'. It is copied at the + beginning of C sources generated by CFFI's ffi.set_source(). */ + +typedef void *_cffi_opcode_t; + +#define _CFFI_OP(opcode, arg) (_cffi_opcode_t)(opcode | (((uintptr_t)(arg)) << 8)) +#define _CFFI_GETOP(cffi_opcode) ((unsigned char)(uintptr_t)cffi_opcode) +#define _CFFI_GETARG(cffi_opcode) (((intptr_t)cffi_opcode) >> 8) + +#define _CFFI_OP_PRIMITIVE 1 +#define _CFFI_OP_POINTER 3 +#define _CFFI_OP_ARRAY 5 +#define _CFFI_OP_OPEN_ARRAY 7 +#define _CFFI_OP_STRUCT_UNION 9 +#define _CFFI_OP_ENUM 11 +#define _CFFI_OP_FUNCTION 13 +#define _CFFI_OP_FUNCTION_END 15 +#define _CFFI_OP_NOOP 17 +#define _CFFI_OP_BITFIELD 19 +#define _CFFI_OP_TYPENAME 21 +#define _CFFI_OP_CPYTHON_BLTN_V 23 // varargs +#define _CFFI_OP_CPYTHON_BLTN_N 25 // noargs +#define _CFFI_OP_CPYTHON_BLTN_O 27 // O (i.e. a single arg) +#define _CFFI_OP_CONSTANT 29 +#define _CFFI_OP_CONSTANT_INT 31 +#define _CFFI_OP_GLOBAL_VAR 33 +#define _CFFI_OP_DLOPEN_FUNC 35 +#define _CFFI_OP_DLOPEN_CONST 37 +#define _CFFI_OP_GLOBAL_VAR_F 39 +#define _CFFI_OP_EXTERN_PYTHON 41 + +#define _CFFI_PRIM_VOID 0 +#define _CFFI_PRIM_BOOL 1 +#define _CFFI_PRIM_CHAR 2 +#define _CFFI_PRIM_SCHAR 3 +#define _CFFI_PRIM_UCHAR 4 +#define _CFFI_PRIM_SHORT 5 +#define _CFFI_PRIM_USHORT 6 +#define _CFFI_PRIM_INT 7 +#define _CFFI_PRIM_UINT 8 +#define _CFFI_PRIM_LONG 9 +#define _CFFI_PRIM_ULONG 10 +#define _CFFI_PRIM_LONGLONG 11 +#define _CFFI_PRIM_ULONGLONG 12 +#define _CFFI_PRIM_FLOAT 13 +#define _CFFI_PRIM_DOUBLE 14 +#define _CFFI_PRIM_LONGDOUBLE 15 + +#define _CFFI_PRIM_WCHAR 16 +#define _CFFI_PRIM_INT8 17 +#define _CFFI_PRIM_UINT8 18 +#define _CFFI_PRIM_INT16 19 +#define _CFFI_PRIM_UINT16 20 +#define _CFFI_PRIM_INT32 21 +#define _CFFI_PRIM_UINT32 22 +#define _CFFI_PRIM_INT64 23 +#define _CFFI_PRIM_UINT64 24 +#define _CFFI_PRIM_INTPTR 25 +#define _CFFI_PRIM_UINTPTR 26 +#define _CFFI_PRIM_PTRDIFF 27 +#define _CFFI_PRIM_SIZE 28 +#define _CFFI_PRIM_SSIZE 29 +#define _CFFI_PRIM_INT_LEAST8 30 +#define _CFFI_PRIM_UINT_LEAST8 31 +#define _CFFI_PRIM_INT_LEAST16 32 +#define _CFFI_PRIM_UINT_LEAST16 33 +#define _CFFI_PRIM_INT_LEAST32 34 +#define _CFFI_PRIM_UINT_LEAST32 35 +#define _CFFI_PRIM_INT_LEAST64 36 +#define _CFFI_PRIM_UINT_LEAST64 37 +#define _CFFI_PRIM_INT_FAST8 38 +#define _CFFI_PRIM_UINT_FAST8 39 +#define _CFFI_PRIM_INT_FAST16 40 +#define _CFFI_PRIM_UINT_FAST16 41 +#define _CFFI_PRIM_INT_FAST32 42 +#define _CFFI_PRIM_UINT_FAST32 43 +#define _CFFI_PRIM_INT_FAST64 44 +#define _CFFI_PRIM_UINT_FAST64 45 +#define _CFFI_PRIM_INTMAX 46 +#define _CFFI_PRIM_UINTMAX 47 + +#define _CFFI__NUM_PRIM 48 +#define _CFFI__UNKNOWN_PRIM (-1) +#define _CFFI__UNKNOWN_FLOAT_PRIM (-2) +#define _CFFI__UNKNOWN_LONG_DOUBLE (-3) + +#define _CFFI__IO_FILE_STRUCT (-1) + + +struct _cffi_global_s { + const char *name; + void *address; + _cffi_opcode_t type_op; + void *size_or_direct_fn; // OP_GLOBAL_VAR: size, or 0 if unknown + // OP_CPYTHON_BLTN_*: addr of direct function +}; + +struct _cffi_getconst_s { + unsigned long long value; + const struct _cffi_type_context_s *ctx; + int gindex; +}; + +struct _cffi_struct_union_s { + const char *name; + int type_index; // -> _cffi_types, on a OP_STRUCT_UNION + int flags; // _CFFI_F_* flags below + size_t size; + int alignment; + int first_field_index; // -> _cffi_fields array + int num_fields; +}; +#define _CFFI_F_UNION 0x01 // is a union, not a struct +#define _CFFI_F_CHECK_FIELDS 0x02 // complain if fields are not in the + // "standard layout" or if some are missing +#define _CFFI_F_PACKED 0x04 // for CHECK_FIELDS, assume a packed struct +#define _CFFI_F_EXTERNAL 0x08 // in some other ffi.include() +#define _CFFI_F_OPAQUE 0x10 // opaque + +struct _cffi_field_s { + const char *name; + size_t field_offset; + size_t field_size; + _cffi_opcode_t field_type_op; +}; + +struct _cffi_enum_s { + const char *name; + int type_index; // -> _cffi_types, on a OP_ENUM + int type_prim; // _CFFI_PRIM_xxx + const char *enumerators; // comma-delimited string +}; + +struct _cffi_typename_s { + const char *name; + int type_index; /* if opaque, points to a possibly artificial + OP_STRUCT which is itself opaque */ +}; + +struct _cffi_type_context_s { + _cffi_opcode_t *types; + const struct _cffi_global_s *globals; + const struct _cffi_field_s *fields; + const struct _cffi_struct_union_s *struct_unions; + const struct _cffi_enum_s *enums; + const struct _cffi_typename_s *typenames; + int num_globals; + int num_struct_unions; + int num_enums; + int num_typenames; + const char *const *includes; + int num_types; + int flags; /* future extension */ +}; + +struct _cffi_parse_info_s { + const struct _cffi_type_context_s *ctx; + _cffi_opcode_t *output; + unsigned int output_size; + size_t error_location; + const char *error_message; +}; + +struct _cffi_externpy_s { + const char *name; + size_t size_of_result; + void *reserved1, *reserved2; +}; + +#ifdef _CFFI_INTERNAL +static int parse_c_type(struct _cffi_parse_info_s *info, const char *input); +static int search_in_globals(const struct _cffi_type_context_s *ctx, + const char *search, size_t search_len); +static int search_in_struct_unions(const struct _cffi_type_context_s *ctx, + const char *search, size_t search_len); +#endif + +/* this block of #ifs should be kept exactly identical between + c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py + and cffi/_cffi_include.h */ +#if defined(_MSC_VER) +# include <malloc.h> /* for alloca() */ +# if _MSC_VER < 1600 /* MSVC < 2010 */ + typedef __int8 int8_t; + typedef __int16 int16_t; + typedef __int32 int32_t; + typedef __int64 int64_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int64 uint64_t; + typedef __int8 int_least8_t; + typedef __int16 int_least16_t; + typedef __int32 int_least32_t; + typedef __int64 int_least64_t; + typedef unsigned __int8 uint_least8_t; + typedef unsigned __int16 uint_least16_t; + typedef unsigned __int32 uint_least32_t; + typedef unsigned __int64 uint_least64_t; + typedef __int8 int_fast8_t; + typedef __int16 int_fast16_t; + typedef __int32 int_fast32_t; + typedef __int64 int_fast64_t; + typedef unsigned __int8 uint_fast8_t; + typedef unsigned __int16 uint_fast16_t; + typedef unsigned __int32 uint_fast32_t; + typedef unsigned __int64 uint_fast64_t; + typedef __int64 intmax_t; + typedef unsigned __int64 uintmax_t; +# else +# include <stdint.h> +# endif +# if _MSC_VER < 1800 /* MSVC < 2013 */ +# ifndef __cplusplus + typedef unsigned char _Bool; +# endif +# endif +#else +# include <stdint.h> +# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) +# include <alloca.h> +# endif +#endif + +#ifdef __GNUC__ +# define _CFFI_UNUSED_FN __attribute__((unused)) +#else +# define _CFFI_UNUSED_FN /* nothing */ +#endif + +#ifdef __cplusplus +# ifndef _Bool + typedef bool _Bool; /* semi-hackish: C++ has no _Bool; bool is builtin */ +# endif +#endif + +/********** CPython-specific section **********/ +#ifndef PYPY_VERSION + + +#if PY_MAJOR_VERSION >= 3 +# define PyInt_FromLong PyLong_FromLong +#endif + +#define _cffi_from_c_double PyFloat_FromDouble +#define _cffi_from_c_float PyFloat_FromDouble +#define _cffi_from_c_long PyInt_FromLong +#define _cffi_from_c_ulong PyLong_FromUnsignedLong +#define _cffi_from_c_longlong PyLong_FromLongLong +#define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong + +#define _cffi_to_c_double PyFloat_AsDouble +#define _cffi_to_c_float PyFloat_AsDouble + +#define _cffi_from_c_int(x, type) \ + (((type)-1) > 0 ? /* unsigned */ \ + (sizeof(type) < sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + sizeof(type) == sizeof(long) ? \ + PyLong_FromUnsignedLong((unsigned long)x) : \ + PyLong_FromUnsignedLongLong((unsigned long long)x)) : \ + (sizeof(type) <= sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + PyLong_FromLongLong((long long)x))) + +#define _cffi_to_c_int(o, type) \ + ((type)( \ + sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o) \ + : (type)_cffi_to_c_i8(o)) : \ + sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o) \ + : (type)_cffi_to_c_i16(o)) : \ + sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o) \ + : (type)_cffi_to_c_i32(o)) : \ + sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o) \ + : (type)_cffi_to_c_i64(o)) : \ + (Py_FatalError("unsupported size for type " #type), (type)0))) + +#define _cffi_to_c_i8 \ + ((int(*)(PyObject *))_cffi_exports[1]) +#define _cffi_to_c_u8 \ + ((int(*)(PyObject *))_cffi_exports[2]) +#define _cffi_to_c_i16 \ + ((int(*)(PyObject *))_cffi_exports[3]) +#define _cffi_to_c_u16 \ + ((int(*)(PyObject *))_cffi_exports[4]) +#define _cffi_to_c_i32 \ + ((int(*)(PyObject *))_cffi_exports[5]) +#define _cffi_to_c_u32 \ + ((unsigned int(*)(PyObject *))_cffi_exports[6]) +#define _cffi_to_c_i64 \ + ((long long(*)(PyObject *))_cffi_exports[7]) +#define _cffi_to_c_u64 \ + ((unsigned long long(*)(PyObject *))_cffi_exports[8]) +#define _cffi_to_c_char \ + ((int(*)(PyObject *))_cffi_exports[9]) +#define _cffi_from_c_pointer \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[10]) +#define _cffi_to_c_pointer \ + ((char *(*)(PyObject *, struct _cffi_ctypedescr *))_cffi_exports[11]) +#define _cffi_get_struct_layout \ + not used any more +#define _cffi_restore_errno \ + ((void(*)(void))_cffi_exports[13]) +#define _cffi_save_errno \ + ((void(*)(void))_cffi_exports[14]) +#define _cffi_from_c_char \ + ((PyObject *(*)(char))_cffi_exports[15]) +#define _cffi_from_c_deref \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[16]) +#define _cffi_to_c \ + ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[17]) +#define _cffi_from_c_struct \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[18]) +#define _cffi_to_c_wchar_t \ + ((wchar_t(*)(PyObject *))_cffi_exports[19]) +#define _cffi_from_c_wchar_t \ + ((PyObject *(*)(wchar_t))_cffi_exports[20]) +#define _cffi_to_c_long_double \ + ((long double(*)(PyObject *))_cffi_exports[21]) +#define _cffi_to_c__Bool \ + ((_Bool(*)(PyObject *))_cffi_exports[22]) +#define _cffi_prepare_pointer_call_argument \ + ((Py_ssize_t(*)(struct _cffi_ctypedescr *, \ + PyObject *, char **))_cffi_exports[23]) +#define _cffi_convert_array_from_object \ + ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[24]) +#define _CFFI_CPIDX 25 +#define _cffi_call_python \ + ((void(*)(struct _cffi_externpy_s *, char *))_cffi_exports[_CFFI_CPIDX]) +#define _CFFI_NUM_EXPORTS 26 + +struct _cffi_ctypedescr; + +static void *_cffi_exports[_CFFI_NUM_EXPORTS]; + +#define _cffi_type(index) ( \ + assert((((uintptr_t)_cffi_types[index]) & 1) == 0), \ + (struct _cffi_ctypedescr *)_cffi_types[index]) + +static PyObject *_cffi_init(const char *module_name, Py_ssize_t version, + const struct _cffi_type_context_s *ctx) +{ + PyObject *module, *o_arg, *new_module; + void *raw[] = { + (void *)module_name, + (void *)version, + (void *)_cffi_exports, + (void *)ctx, + }; + + module = PyImport_ImportModule("_cffi_backend"); + if (module == NULL) + goto failure; + + o_arg = PyLong_FromVoidPtr((void *)raw); + if (o_arg == NULL) + goto failure; + + new_module = PyObject_CallMethod( + module, (char *)"_init_cffi_1_0_external_module", (char *)"O", o_arg); + + Py_DECREF(o_arg); + Py_DECREF(module); + return new_module; + + failure: + Py_XDECREF(module); + return NULL; +} + +/********** end CPython-specific section **********/ +#else +_CFFI_UNUSED_FN +static void (*_cffi_call_python_org)(struct _cffi_externpy_s *, char *); +# define _cffi_call_python _cffi_call_python_org +#endif + + +#define _cffi_array_len(array) (sizeof(array) / sizeof((array)[0])) + +#define _cffi_prim_int(size, sign) \ + ((size) == 1 ? ((sign) ? _CFFI_PRIM_INT8 : _CFFI_PRIM_UINT8) : \ + (size) == 2 ? ((sign) ? _CFFI_PRIM_INT16 : _CFFI_PRIM_UINT16) : \ + (size) == 4 ? ((sign) ? _CFFI_PRIM_INT32 : _CFFI_PRIM_UINT32) : \ + (size) == 8 ? ((sign) ? _CFFI_PRIM_INT64 : _CFFI_PRIM_UINT64) : \ + _CFFI__UNKNOWN_PRIM) + +#define _cffi_prim_float(size) \ + ((size) == sizeof(float) ? _CFFI_PRIM_FLOAT : \ + (size) == sizeof(double) ? _CFFI_PRIM_DOUBLE : \ + (size) == sizeof(long double) ? _CFFI__UNKNOWN_LONG_DOUBLE : \ + _CFFI__UNKNOWN_FLOAT_PRIM) + +#define _cffi_check_int(got, got_nonpos, expected) \ + ((got_nonpos) == (expected <= 0) && \ + (got) == (unsigned long long)expected) + +#ifdef MS_WIN32 +# define _cffi_stdcall __stdcall +#else +# define _cffi_stdcall /* nothing */ +#endif + +#ifdef __cplusplus +} +#endif + +/************************************************************/ + + +/* define our OpenSSL API compatibility level to 1.0.1. Any symbols older than + that will raise an error during compilation. We can raise this number again + after we drop 1.0.2 support in the distant future. */ +#define OPENSSL_API_COMPAT 0x10001000L + +#include <openssl/opensslv.h> + + +#if defined(LIBRESSL_VERSION_NUMBER) +#define CRYPTOGRAPHY_IS_LIBRESSL 1 +#else +#define CRYPTOGRAPHY_IS_LIBRESSL 0 +#endif + +/* + LibreSSL removed e_os2.h from the public headers so we'll only include it + if we're using vanilla OpenSSL. +*/ +#if !CRYPTOGRAPHY_IS_LIBRESSL +#include <openssl/e_os2.h> +#endif +#if defined(_WIN32) +#define WIN32_LEAN_AND_MEAN +#include <windows.h> +#include <Wincrypt.h> +#include <Winsock2.h> +#endif + +#define CRYPTOGRAPHY_OPENSSL_110F_OR_GREATER (OPENSSL_VERSION_NUMBER >= 0x1010006f && !CRYPTOGRAPHY_IS_LIBRESSL) + +#define CRYPTOGRAPHY_OPENSSL_LESS_THAN_110J (OPENSSL_VERSION_NUMBER < 0x101000af || CRYPTOGRAPHY_IS_LIBRESSL) +#define CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 (OPENSSL_VERSION_NUMBER < 0x10101000 || CRYPTOGRAPHY_IS_LIBRESSL) +#define CRYPTOGRAPHY_OPENSSL_LESS_THAN_111B (OPENSSL_VERSION_NUMBER < 0x10101020 || CRYPTOGRAPHY_IS_LIBRESSL) +#define CRYPTOGRAPHY_OPENSSL_LESS_THAN_111D (OPENSSL_VERSION_NUMBER < 0x10101040 || CRYPTOGRAPHY_IS_LIBRESSL) +#if (CRYPTOGRAPHY_OPENSSL_LESS_THAN_111D && !CRYPTOGRAPHY_IS_LIBRESSL && !defined(OPENSSL_NO_ENGINE)) || defined(USE_OSRANDOM_RNG_FOR_TESTING) +#define CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE 1 +#else +#define CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE 0 +#endif + + +#include <openssl/aes.h> + + +#include <openssl/asn1.h> + + +#include <openssl/bn.h> + + +#include <openssl/bio.h> + + +#if !defined(OPENSSL_NO_CMAC) +#include <openssl/cmac.h> +#endif + + +#include <openssl/conf.h> + + +#include <openssl/crypto.h> + + +#if CRYPTOGRAPHY_OPENSSL_110F_OR_GREATER && !defined(OPENSSL_NO_CT) +#include <openssl/ct.h> + +typedef STACK_OF(SCT) Cryptography_STACK_OF_SCT; +#endif + + +#include <openssl/dh.h> + + +#include <openssl/dsa.h> + + +#include <openssl/ec.h> +#include <openssl/obj_mac.h> + + +#include <openssl/ecdh.h> + + +#include <openssl/ecdsa.h> + + +#include <openssl/engine.h> + + +#include <openssl/err.h> + + +#include <openssl/evp.h> + + +#include <openssl/crypto.h> + + +#include <openssl/hmac.h> + + +#include <openssl/obj_mac.h> + + +#include <openssl/objects.h> + + +#include <openssl/ocsp.h> + + +#include <openssl/opensslv.h> + +#ifndef OPENSSL_NO_ENGINE +/* OpenSSL has ENGINE support so include all of this. */ +#ifdef _WIN32 + #include <Wincrypt.h> +#else + #include <fcntl.h> + #include <unistd.h> + /* for defined(BSD) */ + #ifndef __MVS__ + #include <sys/param.h> + #endif + + #ifdef BSD + /* for SYS_getentropy */ + #include <sys/syscall.h> + #endif + + #ifdef __APPLE__ + #include <sys/random.h> + /* To support weak linking we need to declare this as a weak import even if + * it's not present in sys/random (e.g. macOS < 10.12). */ + extern int getentropy(void *buffer, size_t size) __attribute((weak_import)); + #endif + + #ifdef __linux__ + /* for SYS_getrandom */ + #include <sys/syscall.h> + #ifndef GRND_NONBLOCK + #define GRND_NONBLOCK 0x0001 + #endif /* GRND_NONBLOCK */ + + #ifndef SYS_getrandom + /* We only bother to define the constants for platforms where we ship + * wheels, since that's the predominant way you get a situation where + * you don't have SYS_getrandom at compile time but do have the syscall + * at runtime */ + #if defined(__x86_64__) + #define SYS_getrandom 318 + #elif defined(__i386__) + #define SYS_getrandom 355 + #elif defined(__aarch64__) + #define SYS_getrandom 278 + #endif + #endif + #endif /* __linux__ */ +#endif /* _WIN32 */ + +#define CRYPTOGRAPHY_OSRANDOM_ENGINE_CRYPTGENRANDOM 1 +#define CRYPTOGRAPHY_OSRANDOM_ENGINE_GETENTROPY 2 +#define CRYPTOGRAPHY_OSRANDOM_ENGINE_GETRANDOM 3 +#define CRYPTOGRAPHY_OSRANDOM_ENGINE_DEV_URANDOM 4 + +#ifndef CRYPTOGRAPHY_OSRANDOM_ENGINE + #if defined(_WIN32) + /* Windows */ + #define CRYPTOGRAPHY_OSRANDOM_ENGINE CRYPTOGRAPHY_OSRANDOM_ENGINE_CRYPTGENRANDOM + #elif defined(BSD) && defined(SYS_getentropy) + /* OpenBSD 5.6+ & macOS with SYS_getentropy defined, although < 10.12 will fallback + * to urandom */ + #define CRYPTOGRAPHY_OSRANDOM_ENGINE CRYPTOGRAPHY_OSRANDOM_ENGINE_GETENTROPY + #elif defined(__linux__) && defined(SYS_getrandom) + /* Linux 3.17+ */ + #define CRYPTOGRAPHY_OSRANDOM_ENGINE CRYPTOGRAPHY_OSRANDOM_ENGINE_GETRANDOM + #else + /* Keep this as last entry, fall back to /dev/urandom */ + #define CRYPTOGRAPHY_OSRANDOM_ENGINE CRYPTOGRAPHY_OSRANDOM_ENGINE_DEV_URANDOM + #endif +#endif /* CRYPTOGRAPHY_OSRANDOM_ENGINE */ + +/* Fallbacks need /dev/urandom helper functions. */ +#if CRYPTOGRAPHY_OSRANDOM_ENGINE == CRYPTOGRAPHY_OSRANDOM_ENGINE_GETRANDOM || \ + CRYPTOGRAPHY_OSRANDOM_ENGINE == CRYPTOGRAPHY_OSRANDOM_ENGINE_DEV_URANDOM || \ + (CRYPTOGRAPHY_OSRANDOM_ENGINE == CRYPTOGRAPHY_OSRANDOM_ENGINE_GETENTROPY && \ + defined(__APPLE__)) + #define CRYPTOGRAPHY_OSRANDOM_NEEDS_DEV_URANDOM 1 +#endif + +enum { + CRYPTOGRAPHY_OSRANDOM_GETRANDOM_INIT_FAILED = -2, + CRYPTOGRAPHY_OSRANDOM_GETRANDOM_NOT_INIT, + CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK, + CRYPTOGRAPHY_OSRANDOM_GETRANDOM_WORKS +}; + +enum { + CRYPTOGRAPHY_OSRANDOM_GETENTROPY_NOT_INIT, + CRYPTOGRAPHY_OSRANDOM_GETENTROPY_FALLBACK, + CRYPTOGRAPHY_OSRANDOM_GETENTROPY_WORKS +}; + +/* engine ctrl */ +#define CRYPTOGRAPHY_OSRANDOM_GET_IMPLEMENTATION ENGINE_CMD_BASE + +/* error reporting */ +static void ERR_load_Cryptography_OSRandom_strings(void); +static void ERR_Cryptography_OSRandom_error(int function, int reason, + char *file, int line); + +#define CRYPTOGRAPHY_OSRANDOM_F_INIT 100 +#define CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES 101 +#define CRYPTOGRAPHY_OSRANDOM_F_FINISH 102 +#define CRYPTOGRAPHY_OSRANDOM_F_DEV_URANDOM_FD 300 +#define CRYPTOGRAPHY_OSRANDOM_F_DEV_URANDOM_READ 301 + +#define CRYPTOGRAPHY_OSRANDOM_R_CRYPTACQUIRECONTEXT 100 +#define CRYPTOGRAPHY_OSRANDOM_R_CRYPTGENRANDOM 101 +#define CRYPTOGRAPHY_OSRANDOM_R_CRYPTRELEASECONTEXT 102 + +#define CRYPTOGRAPHY_OSRANDOM_R_GETENTROPY_FAILED 200 + +#define CRYPTOGRAPHY_OSRANDOM_R_DEV_URANDOM_OPEN_FAILED 300 +#define CRYPTOGRAPHY_OSRANDOM_R_DEV_URANDOM_READ_FAILED 301 + +#define CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_INIT_FAILED 400 +#define CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_INIT_FAILED_UNEXPECTED 402 +#define CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_FAILED 403 +#define CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_NOT_INIT 404 +#endif + + +#include <openssl/pem.h> + + +#include <openssl/pkcs12.h> + + +#include <openssl/rand.h> + + +#include <openssl/rsa.h> + + +#include <openssl/ssl.h> + +typedef STACK_OF(SSL_CIPHER) Cryptography_STACK_OF_SSL_CIPHER; + + +#include <openssl/ssl.h> + +/* + * This is part of a work-around for the difficulty cffi has in dealing with + * `STACK_OF(foo)` as the name of a type. We invent a new, simpler name that + * will be an alias for this type and use the alias throughout. This works + * together with another opaque typedef for the same name in the TYPES section. + * Note that the result is an opaque type. + */ +typedef STACK_OF(X509) Cryptography_STACK_OF_X509; +typedef STACK_OF(X509_CRL) Cryptography_STACK_OF_X509_CRL; +typedef STACK_OF(X509_REVOKED) Cryptography_STACK_OF_X509_REVOKED; + + +#include <openssl/x509.h> + +/* + * See the comment above Cryptography_STACK_OF_X509 in x509.py + */ +typedef STACK_OF(X509_NAME) Cryptography_STACK_OF_X509_NAME; +typedef STACK_OF(X509_NAME_ENTRY) Cryptography_STACK_OF_X509_NAME_ENTRY; + + +#include <openssl/x509v3.h> + +/* + * This is part of a work-around for the difficulty cffi has in dealing with + * `LHASH_OF(foo)` as the name of a type. We invent a new, simpler name that + * will be an alias for this type and use the alias throughout. This works + * together with another opaque typedef for the same name in the TYPES section. + * Note that the result is an opaque type. + */ +typedef LHASH_OF(CONF_VALUE) Cryptography_LHASH_OF_CONF_VALUE; + +typedef STACK_OF(ACCESS_DESCRIPTION) Cryptography_STACK_OF_ACCESS_DESCRIPTION; +typedef STACK_OF(DIST_POINT) Cryptography_STACK_OF_DIST_POINT; +typedef STACK_OF(POLICYQUALINFO) Cryptography_STACK_OF_POLICYQUALINFO; +typedef STACK_OF(POLICYINFO) Cryptography_STACK_OF_POLICYINFO; +typedef STACK_OF(ASN1_INTEGER) Cryptography_STACK_OF_ASN1_INTEGER; +typedef STACK_OF(GENERAL_SUBTREE) Cryptography_STACK_OF_GENERAL_SUBTREE; + + +#include <openssl/x509_vfy.h> + +/* + * This is part of a work-around for the difficulty cffi has in dealing with + * `STACK_OF(foo)` as the name of a type. We invent a new, simpler name that + * will be an alias for this type and use the alias throughout. This works + * together with another opaque typedef for the same name in the TYPES section. + * Note that the result is an opaque type. + */ +typedef STACK_OF(ASN1_OBJECT) Cryptography_STACK_OF_ASN1_OBJECT; +typedef STACK_OF(X509_OBJECT) Cryptography_STACK_OF_X509_OBJECT; + + +#include <openssl/pkcs7.h> + + +#include <string.h> + + + + + + + + + + + + + + + + +/* In 1.1.0 SSLeay has finally been retired. We bidirectionally define the + values so you can use either one. This is so we can use the new function + names no matter what OpenSSL we're running on, but users on older pyOpenSSL + releases won't see issues if they're running OpenSSL 1.1.0 */ +#if !defined(SSLEAY_VERSION) +# define SSLeay OpenSSL_version_num +# define SSLeay_version OpenSSL_version +# define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER +# define SSLEAY_VERSION OPENSSL_VERSION +# define SSLEAY_CFLAGS OPENSSL_CFLAGS +# define SSLEAY_BUILT_ON OPENSSL_BUILT_ON +# define SSLEAY_PLATFORM OPENSSL_PLATFORM +# define SSLEAY_DIR OPENSSL_DIR +#endif +#if !defined(OPENSSL_VERSION) +# define OpenSSL_version_num SSLeay +# define OpenSSL_version SSLeay_version +# define OPENSSL_VERSION SSLEAY_VERSION +# define OPENSSL_CFLAGS SSLEAY_CFLAGS +# define OPENSSL_BUILT_ON SSLEAY_BUILT_ON +# define OPENSSL_PLATFORM SSLEAY_PLATFORM +# define OPENSSL_DIR SSLEAY_DIR +#endif + +#if CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_OPENSSL_CLEANUP = 0; + +void (*OPENSSL_cleanup)(void) = NULL; + +/* This function has a significantly different signature pre-1.1.0. since it is + * for testing only, we don't bother to expose it on older OpenSSLs. + */ +static const long Cryptography_HAS_MEM_FUNCTIONS = 0; +int (*Cryptography_CRYPTO_set_mem_functions)( + void *(*)(size_t, const char *, int), + void *(*)(void *, size_t, const char *, int), + void (*)(void *, const char *, int)) = NULL; + +#else +static const long Cryptography_HAS_OPENSSL_CLEANUP = 1; +static const long Cryptography_HAS_MEM_FUNCTIONS = 1; + +int Cryptography_CRYPTO_set_mem_functions( + void *(*m)(size_t, const char *, int), + void *(*r)(void *, size_t, const char *, int), + void (*f)(void *, const char *, int) +) { + return CRYPTO_set_mem_functions(m, r, f); +} +#endif + +void *Cryptography_malloc_wrapper(size_t size, const char *path, int line) { + return malloc(size); +} + +void *Cryptography_realloc_wrapper(void *ptr, size_t size, const char *path, + int line) { + return realloc(ptr, size); +} + +void Cryptography_free_wrapper(void *ptr, const char *path, int line) { + free(ptr); +} + + +#if CRYPTOGRAPHY_OPENSSL_110F_OR_GREATER && !defined(OPENSSL_NO_CT) +static const long Cryptography_HAS_SCT = 1; +#else +static const long Cryptography_HAS_SCT = 0; + +typedef enum { + SCT_VERSION_NOT_SET, + SCT_VERSION_V1 +} sct_version_t; +typedef enum { + CT_LOG_ENTRY_TYPE_NOT_SET, + CT_LOG_ENTRY_TYPE_X509, + CT_LOG_ENTRY_TYPE_PRECERT +} ct_log_entry_type_t; +typedef enum { + SCT_SOURCE_UNKNOWN, + SCT_SOURCE_TLS_EXTENSION, + SCT_SOURCE_X509V3_EXTENSION, + SCT_SOURCE_OCSP_STAPLED_RESPONSE +} sct_source_t; + +/* OpenSSL compiled with `no-ct` still defines the `SCT` struct. */ +#if !defined(OPENSSL_NO_CT) +typedef void SCT; +#endif + +typedef void Cryptography_STACK_OF_SCT; + +sct_version_t (*SCT_get_version)(const SCT *) = NULL; +ct_log_entry_type_t (*SCT_get_log_entry_type)(const SCT *) = NULL; +size_t (*SCT_get0_log_id)(const SCT *, unsigned char **) = NULL; +size_t (*SCT_get0_signature)(const SCT *, unsigned char **) = NULL; +uint64_t (*SCT_get_timestamp)(const SCT *) = NULL; + +int (*SCT_set_source)(SCT *, sct_source_t) = NULL; + +Cryptography_STACK_OF_SCT *(*sk_SCT_new_null)(void) = NULL; +void (*sk_SCT_free)(Cryptography_STACK_OF_SCT *) = NULL; +int (*sk_SCT_num)(const Cryptography_STACK_OF_SCT *) = NULL; +SCT *(*sk_SCT_value)(const Cryptography_STACK_OF_SCT *, int) = NULL; +int (*sk_SCT_push)(Cryptography_STACK_OF_SCT *, SCT *) = NULL; + +void (*SCT_LIST_free)(Cryptography_STACK_OF_SCT *) = NULL; +SCT *(*SCT_new)(void) = NULL; +int (*SCT_set1_log_id)(SCT *, unsigned char *, size_t) = NULL; +void (*SCT_set_timestamp)(SCT *, uint64_t) = NULL; +int (*SCT_set_version)(SCT *, sct_version_t) = NULL; +int (*SCT_set_log_entry_type)(SCT *, ct_log_entry_type_t) = NULL; +#endif + + +#if CRYPTOGRAPHY_IS_LIBRESSL +#ifndef DH_CHECK_Q_NOT_PRIME +#define DH_CHECK_Q_NOT_PRIME 0x10 +#endif + +#ifndef DH_CHECK_INVALID_Q_VALUE +#define DH_CHECK_INVALID_Q_VALUE 0x20 +#endif + +#ifndef DH_CHECK_INVALID_J_VALUE +#define DH_CHECK_INVALID_J_VALUE 0x40 +#endif + +/* DH_check implementation taken from OpenSSL 1.1.0pre6 */ + +/*- + * Check that p is a safe prime and + * if g is 2, 3 or 5, check that it is a suitable generator + * where + * for 2, p mod 24 == 11 + * for 3, p mod 12 == 5 + * for 5, p mod 10 == 3 or 7 + * should hold. + */ + +int Cryptography_DH_check(const DH *dh, int *ret) +{ + int ok = 0, r; + BN_CTX *ctx = NULL; + BN_ULONG l; + BIGNUM *t1 = NULL, *t2 = NULL; + + *ret = 0; + ctx = BN_CTX_new(); + if (ctx == NULL) + goto err; + BN_CTX_start(ctx); + t1 = BN_CTX_get(ctx); + if (t1 == NULL) + goto err; + t2 = BN_CTX_get(ctx); + if (t2 == NULL) + goto err; + + if (dh->q) { + if (BN_cmp(dh->g, BN_value_one()) <= 0) + *ret |= DH_NOT_SUITABLE_GENERATOR; + else if (BN_cmp(dh->g, dh->p) >= 0) + *ret |= DH_NOT_SUITABLE_GENERATOR; + else { + /* Check g^q == 1 mod p */ + if (!BN_mod_exp(t1, dh->g, dh->q, dh->p, ctx)) + goto err; + if (!BN_is_one(t1)) + *ret |= DH_NOT_SUITABLE_GENERATOR; + } + r = BN_is_prime_ex(dh->q, BN_prime_checks, ctx, NULL); + if (r < 0) + goto err; + if (!r) + *ret |= DH_CHECK_Q_NOT_PRIME; + /* Check p == 1 mod q i.e. q divides p - 1 */ + if (!BN_div(t1, t2, dh->p, dh->q, ctx)) + goto err; + if (!BN_is_one(t2)) + *ret |= DH_CHECK_INVALID_Q_VALUE; + if (dh->j && BN_cmp(dh->j, t1)) + *ret |= DH_CHECK_INVALID_J_VALUE; + + } else if (BN_is_word(dh->g, DH_GENERATOR_2)) { + l = BN_mod_word(dh->p, 24); + if (l == (BN_ULONG)-1) + goto err; + if (l != 11) + *ret |= DH_NOT_SUITABLE_GENERATOR; + } else if (BN_is_word(dh->g, DH_GENERATOR_5)) { + l = BN_mod_word(dh->p, 10); + if (l == (BN_ULONG)-1) + goto err; + if ((l != 3) && (l != 7)) + *ret |= DH_NOT_SUITABLE_GENERATOR; + } else + *ret |= DH_UNABLE_TO_CHECK_GENERATOR; + + r = BN_is_prime_ex(dh->p, BN_prime_checks, ctx, NULL); + if (r < 0) + goto err; + if (!r) + *ret |= DH_CHECK_P_NOT_PRIME; + else if (!dh->q) { + if (!BN_rshift1(t1, dh->p)) + goto err; + r = BN_is_prime_ex(t1, BN_prime_checks, ctx, NULL); + if (r < 0) + goto err; + if (!r) + *ret |= DH_CHECK_P_NOT_SAFE_PRIME; + } + ok = 1; + err: + if (ctx != NULL) { + BN_CTX_end(ctx); + BN_CTX_free(ctx); + } + return (ok); +} +#else +int Cryptography_DH_check(const DH *dh, int *ret) { + return DH_check(dh, ret); +} +#endif + +/* These functions were added in OpenSSL 1.1.0f commit d0c50e80a8 */ +/* Define our own to simplify support across all versions. */ +#if defined(EVP_PKEY_DHX) && EVP_PKEY_DHX != -1 +DH *Cryptography_d2i_DHxparams_bio(BIO *bp, DH **x) { + return ASN1_d2i_bio_of(DH, DH_new, d2i_DHxparams, bp, x); +} +int Cryptography_i2d_DHxparams_bio(BIO *bp, DH *x) { + return ASN1_i2d_bio_of_const(DH, i2d_DHxparams, bp, x); +} +#else +DH *(*Cryptography_d2i_DHxparams_bio)(BIO *bp, DH **x) = NULL; +int (*Cryptography_i2d_DHxparams_bio)(BIO *bp, DH *x) = NULL; +#endif + + + + +#if defined(OPENSSL_NO_EC2M) +static const long Cryptography_HAS_EC2M = 0; + +int (*EC_POINT_set_affine_coordinates_GF2m)(const EC_GROUP *, EC_POINT *, + const BIGNUM *, const BIGNUM *, BN_CTX *) = NULL; + +int (*EC_POINT_get_affine_coordinates_GF2m)(const EC_GROUP *, + const EC_POINT *, BIGNUM *, BIGNUM *, BN_CTX *) = NULL; + +int (*EC_POINT_set_compressed_coordinates_GF2m)(const EC_GROUP *, EC_POINT *, + const BIGNUM *, int, BN_CTX *) = NULL; +#else +static const long Cryptography_HAS_EC2M = 1; +#endif + + + + + + +#ifdef OPENSSL_NO_ENGINE +static const long Cryptography_HAS_ENGINE = 0; + +ENGINE *(*ENGINE_by_id)(const char *) = NULL; +int (*ENGINE_init)(ENGINE *) = NULL; +int (*ENGINE_finish)(ENGINE *) = NULL; +ENGINE *(*ENGINE_get_default_RAND)(void) = NULL; +int (*ENGINE_set_default_RAND)(ENGINE *) = NULL; +void (*ENGINE_unregister_RAND)(ENGINE *) = NULL; +int (*ENGINE_ctrl_cmd)(ENGINE *, const char *, long, void *, + void (*)(void), int) = NULL; + +int (*ENGINE_free)(ENGINE *) = NULL; +const char *(*ENGINE_get_id)(const ENGINE *) = NULL; +const char *(*ENGINE_get_name)(const ENGINE *) = NULL; + +int (*ENGINE_ctrl_cmd_string)(ENGINE *, const char *, const char *, + int) = NULL; +void (*ENGINE_load_builtin_engines)(void) = NULL; +EVP_PKEY *(*ENGINE_load_private_key)(ENGINE *, const char *, UI_METHOD *, + void *) = NULL; +EVP_PKEY *(*ENGINE_load_public_key)(ENGINE *, const char *, + UI_METHOD *, void *) = NULL; + +#else +static const long Cryptography_HAS_ENGINE = 1; +#endif + + + + +#ifdef EVP_PKEY_DHX +const long Cryptography_HAS_EVP_PKEY_DHX = 1; +#else +const long Cryptography_HAS_EVP_PKEY_DHX = 0; +const long EVP_PKEY_DHX = -1; +#endif + +int Cryptography_EVP_PKEY_id(const EVP_PKEY *key) { + return EVP_PKEY_id(key); +} +EVP_MD_CTX *Cryptography_EVP_MD_CTX_new(void) { + return EVP_MD_CTX_new(); +} +void Cryptography_EVP_MD_CTX_free(EVP_MD_CTX *md) { + EVP_MD_CTX_free(md); +} + +#if CRYPTOGRAPHY_IS_LIBRESSL || defined(OPENSSL_NO_SCRYPT) +static const long Cryptography_HAS_SCRYPT = 0; +int (*EVP_PBE_scrypt)(const char *, size_t, const unsigned char *, size_t, + uint64_t, uint64_t, uint64_t, uint64_t, unsigned char *, + size_t) = NULL; +#else +static const long Cryptography_HAS_SCRYPT = 1; +#endif + +#if !CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_EVP_PKEY_get_set_tls_encodedpoint = 1; +#else +static const long Cryptography_HAS_EVP_PKEY_get_set_tls_encodedpoint = 0; +size_t (*EVP_PKEY_get1_tls_encodedpoint)(EVP_PKEY *, unsigned char **) = NULL; +int (*EVP_PKEY_set1_tls_encodedpoint)(EVP_PKEY *, const unsigned char *, + size_t) = NULL; +#endif + +#if CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 +static const long Cryptography_HAS_ONESHOT_EVP_DIGEST_SIGN_VERIFY = 0; +static const long Cryptography_HAS_RAW_KEY = 0; +static const long Cryptography_HAS_EVP_DIGESTFINAL_XOF = 0; +int (*EVP_DigestFinalXOF)(EVP_MD_CTX *, unsigned char *, size_t) = NULL; +int (*EVP_DigestSign)(EVP_MD_CTX *, unsigned char *, size_t *, + const unsigned char *tbs, size_t) = NULL; +int (*EVP_DigestVerify)(EVP_MD_CTX *, const unsigned char *, size_t, + const unsigned char *, size_t) = NULL; +EVP_PKEY *(*EVP_PKEY_new_raw_private_key)(int, ENGINE *, const unsigned char *, + size_t) = NULL; +EVP_PKEY *(*EVP_PKEY_new_raw_public_key)(int, ENGINE *, const unsigned char *, + size_t) = NULL; +int (*EVP_PKEY_get_raw_private_key)(const EVP_PKEY *, unsigned char *, + size_t *) = NULL; +int (*EVP_PKEY_get_raw_public_key)(const EVP_PKEY *, unsigned char *, + size_t *) = NULL; +#else +static const long Cryptography_HAS_ONESHOT_EVP_DIGEST_SIGN_VERIFY = 1; +static const long Cryptography_HAS_RAW_KEY = 1; +static const long Cryptography_HAS_EVP_DIGESTFINAL_XOF = 1; +#endif + +/* OpenSSL 1.1.0+ does this define for us, but if not present we'll do it */ +#if !defined(EVP_CTRL_AEAD_SET_IVLEN) +# define EVP_CTRL_AEAD_SET_IVLEN EVP_CTRL_GCM_SET_IVLEN +#endif +#if !defined(EVP_CTRL_AEAD_GET_TAG) +# define EVP_CTRL_AEAD_GET_TAG EVP_CTRL_GCM_GET_TAG +#endif +#if !defined(EVP_CTRL_AEAD_SET_TAG) +# define EVP_CTRL_AEAD_SET_TAG EVP_CTRL_GCM_SET_TAG +#endif + +/* This is tied to X25519 support so we reuse the Cryptography_HAS_X25519 + conditional to remove it. OpenSSL 1.1.0 didn't have this define, but + 1.1.1 will when it is released. We can remove this in the distant + future when we drop 1.1.0 support. */ +#ifndef EVP_PKEY_X25519 +#define EVP_PKEY_X25519 NID_X25519 +#endif + +/* This is tied to X448 support so we reuse the Cryptography_HAS_X448 + conditional to remove it. OpenSSL 1.1.1 adds this define. We can remove + this in the distant future when we drop 1.1.0 support. */ +#ifndef EVP_PKEY_X448 +#define EVP_PKEY_X448 NID_X448 +#endif + +/* This is tied to ED25519 support so we reuse the Cryptography_HAS_ED25519 + conditional to remove it. */ +#ifndef EVP_PKEY_ED25519 +#define EVP_PKEY_ED25519 NID_ED25519 +#endif + +/* This is tied to ED448 support so we reuse the Cryptography_HAS_ED448 + conditional to remove it. */ +#ifndef EVP_PKEY_ED448 +#define EVP_PKEY_ED448 NID_ED448 +#endif + +/* This is tied to poly1305 support so we reuse the Cryptography_HAS_POLY1305 + conditional to remove it. */ +#ifndef EVP_PKEY_POLY1305 +#define EVP_PKEY_POLY1305 NID_poly1305 +#endif + + +#if CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_FIPS = 0; +int (*FIPS_mode_set)(int) = NULL; +int (*FIPS_mode)(void) = NULL; +#else +static const long Cryptography_HAS_FIPS = 1; +#endif + + + + +#ifndef NID_ED25519 +static const long Cryptography_HAS_ED25519 = 0; +static const int NID_ED25519 = 0; +#else +static const long Cryptography_HAS_ED25519 = 1; +#endif +#ifndef NID_ED448 +static const long Cryptography_HAS_ED448 = 0; +static const int NID_ED448 = 0; +#else +static const long Cryptography_HAS_ED448 = 1; +#endif +#ifndef NID_poly1305 +static const long Cryptography_HAS_POLY1305 = 0; +static const int NID_poly1305 = 0; +#else +static const long Cryptography_HAS_POLY1305 = 1; +#endif + + + + +#if ( !CRYPTOGRAPHY_IS_LIBRESSL && CRYPTOGRAPHY_OPENSSL_LESS_THAN_110J ) +/* These structs come from ocsp_lcl.h and are needed to de-opaque the struct + for the getters in OpenSSL 1.1.0 through 1.1.0i */ +struct ocsp_responder_id_st { + int type; + union { + X509_NAME *byName; + ASN1_OCTET_STRING *byKey; + } value; +}; +struct ocsp_response_data_st { + ASN1_INTEGER *version; + OCSP_RESPID responderId; + ASN1_GENERALIZEDTIME *producedAt; + STACK_OF(OCSP_SINGLERESP) *responses; + STACK_OF(X509_EXTENSION) *responseExtensions; +}; +struct ocsp_basic_response_st { + OCSP_RESPDATA tbsResponseData; + X509_ALGOR signatureAlgorithm; + ASN1_BIT_STRING *signature; + STACK_OF(X509) *certs; +}; +#endif + +#if CRYPTOGRAPHY_IS_LIBRESSL +/* These functions are all taken from ocsp_cl.c in OpenSSL 1.1.0 */ +const OCSP_CERTID *OCSP_SINGLERESP_get0_id(const OCSP_SINGLERESP *single) +{ + return single->certId; +} +const Cryptography_STACK_OF_X509 *OCSP_resp_get0_certs( + const OCSP_BASICRESP *bs) +{ + return bs->certs; +} +int OCSP_resp_get0_id(const OCSP_BASICRESP *bs, + const ASN1_OCTET_STRING **pid, + const X509_NAME **pname) +{ + const OCSP_RESPID *rid = bs->tbsResponseData->responderId; + + if (rid->type == V_OCSP_RESPID_NAME) { + *pname = rid->value.byName; + *pid = NULL; + } else if (rid->type == V_OCSP_RESPID_KEY) { + *pid = rid->value.byKey; + *pname = NULL; + } else { + return 0; + } + return 1; +} +const ASN1_GENERALIZEDTIME *OCSP_resp_get0_produced_at( + const OCSP_BASICRESP* bs) +{ + return bs->tbsResponseData->producedAt; +} +const ASN1_OCTET_STRING *OCSP_resp_get0_signature(const OCSP_BASICRESP *bs) +{ + return bs->signature; +} +#endif + +#if CRYPTOGRAPHY_OPENSSL_LESS_THAN_110J +const X509_ALGOR *OCSP_resp_get0_tbs_sigalg(const OCSP_BASICRESP *bs) +{ +#if CRYPTOGRAPHY_IS_LIBRESSL + return bs->signatureAlgorithm; +#else + return &bs->signatureAlgorithm; +#endif +} + +const OCSP_RESPDATA *OCSP_resp_get0_respdata(const OCSP_BASICRESP *bs) +{ +#if CRYPTOGRAPHY_IS_LIBRESSL + return bs->tbsResponseData; +#else + return &bs->tbsResponseData; +#endif +} +#endif + + + +/* osurandom engine + * + * Windows CryptGenRandom() + * macOS >= 10.12 getentropy() + * OpenBSD 5.6+ getentropy() + * other BSD getentropy() if SYS_getentropy is defined + * Linux 3.17+ getrandom() with fallback to /dev/urandom + * other /dev/urandom with cached fd + * + * The /dev/urandom, getrandom and getentropy code is derived from Python's + * Python/random.c, written by Antoine Pitrou and Victor Stinner. + * + * Copyright 2001-2016 Python Software Foundation; All Rights Reserved. + */ + +#ifdef __linux__ +#include <poll.h> +#endif + +#if CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE +/* OpenSSL has ENGINE support and is older than 1.1.1d (the first version that + * properly implements fork safety in its RNG) so build the engine. */ +static const char *Cryptography_osrandom_engine_id = "osrandom"; + +/**************************************************************************** + * Windows + */ +#if CRYPTOGRAPHY_OSRANDOM_ENGINE == CRYPTOGRAPHY_OSRANDOM_ENGINE_CRYPTGENRANDOM +static const char *Cryptography_osrandom_engine_name = "osrandom_engine CryptGenRandom()"; +static HCRYPTPROV hCryptProv = 0; + +static int osrandom_init(ENGINE *e) { + if (hCryptProv != 0) { + return 1; + } + if (CryptAcquireContext(&hCryptProv, NULL, NULL, + PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) { + return 1; + } else { + ERR_Cryptography_OSRandom_error( + CRYPTOGRAPHY_OSRANDOM_F_INIT, + CRYPTOGRAPHY_OSRANDOM_R_CRYPTACQUIRECONTEXT, + __FILE__, __LINE__ + ); + return 0; + } +} + +static int osrandom_rand_bytes(unsigned char *buffer, int size) { + if (hCryptProv == 0) { + return 0; + } + + if (!CryptGenRandom(hCryptProv, (DWORD)size, buffer)) { + ERR_Cryptography_OSRandom_error( + CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES, + CRYPTOGRAPHY_OSRANDOM_R_CRYPTGENRANDOM, + __FILE__, __LINE__ + ); + return 0; + } + return 1; +} + +static int osrandom_finish(ENGINE *e) { + if (CryptReleaseContext(hCryptProv, 0)) { + hCryptProv = 0; + return 1; + } else { + ERR_Cryptography_OSRandom_error( + CRYPTOGRAPHY_OSRANDOM_F_FINISH, + CRYPTOGRAPHY_OSRANDOM_R_CRYPTRELEASECONTEXT, + __FILE__, __LINE__ + ); + return 0; + } +} + +static int osrandom_rand_status(void) { + return hCryptProv != 0; +} + +static const char *osurandom_get_implementation(void) { + return "CryptGenRandom"; +} + +#endif /* CRYPTOGRAPHY_OSRANDOM_ENGINE_CRYPTGENRANDOM */ + +/**************************************************************************** + * /dev/urandom helpers for all non-BSD Unix platforms + */ +#ifdef CRYPTOGRAPHY_OSRANDOM_NEEDS_DEV_URANDOM + +static struct { + int fd; + dev_t st_dev; + ino_t st_ino; +} urandom_cache = { -1 }; + +static int open_cloexec(const char *path) { + int open_flags = O_RDONLY; +#ifdef O_CLOEXEC + open_flags |= O_CLOEXEC; +#endif + + int fd = open(path, open_flags); + if (fd == -1) { + return -1; + } + +#ifndef O_CLOEXEC + int flags = fcntl(fd, F_GETFD); + if (flags == -1) { + return -1; + } + if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) { + return -1; + } +#endif + return fd; +} + +#ifdef __linux__ +/* On Linux, we open("/dev/random") and use poll() to wait until it's readable + * before we read from /dev/urandom, this ensures that we don't read from + * /dev/urandom before the kernel CSPRNG is initialized. This isn't necessary on + * other platforms because they don't have the same _bug_ as Linux does with + * /dev/urandom and early boot. */ +static int wait_on_devrandom(void) { + struct pollfd pfd = {}; + int ret = 0; + int random_fd = open_cloexec("/dev/random"); + if (random_fd < 0) { + return -1; + } + pfd.fd = random_fd; + pfd.events = POLLIN; + pfd.revents = 0; + do { + ret = poll(&pfd, 1, -1); + } while (ret < 0 && (errno == EINTR || errno == EAGAIN)); + close(random_fd); + return ret; +} +#endif + +/* return -1 on error */ +static int dev_urandom_fd(void) { + int fd = -1; + struct stat st; + + /* Check that fd still points to the correct device */ + if (urandom_cache.fd >= 0) { + if (fstat(urandom_cache.fd, &st) + || st.st_dev != urandom_cache.st_dev + || st.st_ino != urandom_cache.st_ino) { + /* Somebody replaced our FD. Invalidate our cache but don't + * close the fd. */ + urandom_cache.fd = -1; + } + } + if (urandom_cache.fd < 0) { +#ifdef __linux__ + if (wait_on_devrandom() < 0) { + goto error; + } +#endif + + fd = open_cloexec("/dev/urandom"); + if (fd < 0) { + goto error; + } + if (fstat(fd, &st)) { + goto error; + } + /* Another thread initialized the fd */ + if (urandom_cache.fd >= 0) { + close(fd); + return urandom_cache.fd; + } + urandom_cache.st_dev = st.st_dev; + urandom_cache.st_ino = st.st_ino; + urandom_cache.fd = fd; + } + return urandom_cache.fd; + + error: + if (fd != -1) { + close(fd); + } + ERR_Cryptography_OSRandom_error( + CRYPTOGRAPHY_OSRANDOM_F_DEV_URANDOM_FD, + CRYPTOGRAPHY_OSRANDOM_R_DEV_URANDOM_OPEN_FAILED, + __FILE__, __LINE__ + ); + return -1; +} + +static int dev_urandom_read(unsigned char *buffer, int size) { + int fd; + int n; + + fd = dev_urandom_fd(); + if (fd < 0) { + return 0; + } + + while (size > 0) { + do { + n = (int)read(fd, buffer, (size_t)size); + } while (n < 0 && errno == EINTR); + + if (n <= 0) { + ERR_Cryptography_OSRandom_error( + CRYPTOGRAPHY_OSRANDOM_F_DEV_URANDOM_READ, + CRYPTOGRAPHY_OSRANDOM_R_DEV_URANDOM_READ_FAILED, + __FILE__, __LINE__ + ); + return 0; + } + buffer += n; + size -= n; + } + return 1; +} + +static void dev_urandom_close(void) { + if (urandom_cache.fd >= 0) { + int fd; + struct stat st; + + if (fstat(urandom_cache.fd, &st) + && st.st_dev == urandom_cache.st_dev + && st.st_ino == urandom_cache.st_ino) { + fd = urandom_cache.fd; + urandom_cache.fd = -1; + close(fd); + } + } +} +#endif /* CRYPTOGRAPHY_OSRANDOM_NEEDS_DEV_URANDOM */ + +/**************************************************************************** + * BSD getentropy + */ +#if CRYPTOGRAPHY_OSRANDOM_ENGINE == CRYPTOGRAPHY_OSRANDOM_ENGINE_GETENTROPY +static const char *Cryptography_osrandom_engine_name = "osrandom_engine getentropy()"; + +static int getentropy_works = CRYPTOGRAPHY_OSRANDOM_GETENTROPY_NOT_INIT; + +static int osrandom_init(ENGINE *e) { +#if !defined(__APPLE__) + getentropy_works = CRYPTOGRAPHY_OSRANDOM_GETENTROPY_WORKS; +#else + if (__builtin_available(macOS 10.12, *)) { + getentropy_works = CRYPTOGRAPHY_OSRANDOM_GETENTROPY_WORKS; + } else { + getentropy_works = CRYPTOGRAPHY_OSRANDOM_GETENTROPY_FALLBACK; + int fd = dev_urandom_fd(); + if (fd < 0) { + return 0; + } + } +#endif + return 1; +} + +static int osrandom_rand_bytes(unsigned char *buffer, int size) { + int len; + int res; + + switch(getentropy_works) { +#if defined(__APPLE__) + case CRYPTOGRAPHY_OSRANDOM_GETENTROPY_FALLBACK: + return dev_urandom_read(buffer, size); +#endif + case CRYPTOGRAPHY_OSRANDOM_GETENTROPY_WORKS: + while (size > 0) { + /* OpenBSD and macOS restrict maximum buffer size to 256. */ + len = size > 256 ? 256 : size; +/* on mac, availability is already checked using `__builtin_available` above */ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunguarded-availability" + res = getentropy(buffer, (size_t)len); +#pragma clang diagnostic pop + if (res < 0) { + ERR_Cryptography_OSRandom_error( + CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES, + CRYPTOGRAPHY_OSRANDOM_R_GETENTROPY_FAILED, + __FILE__, __LINE__ + ); + return 0; + } + buffer += len; + size -= len; + } + return 1; + } + __builtin_unreachable(); +} + +static int osrandom_finish(ENGINE *e) { + return 1; +} + +static int osrandom_rand_status(void) { + return 1; +} + +static const char *osurandom_get_implementation(void) { + switch(getentropy_works) { + case CRYPTOGRAPHY_OSRANDOM_GETENTROPY_FALLBACK: + return "/dev/urandom"; + case CRYPTOGRAPHY_OSRANDOM_GETENTROPY_WORKS: + return "getentropy"; + } + __builtin_unreachable(); +} +#endif /* CRYPTOGRAPHY_OSRANDOM_ENGINE_GETENTROPY */ + +/**************************************************************************** + * Linux getrandom engine with fallback to dev_urandom + */ + +#if CRYPTOGRAPHY_OSRANDOM_ENGINE == CRYPTOGRAPHY_OSRANDOM_ENGINE_GETRANDOM +static const char *Cryptography_osrandom_engine_name = "osrandom_engine getrandom()"; + +static int getrandom_works = CRYPTOGRAPHY_OSRANDOM_GETRANDOM_NOT_INIT; + +static int osrandom_init(ENGINE *e) { + /* We try to detect working getrandom until we succeed. */ + if (getrandom_works != CRYPTOGRAPHY_OSRANDOM_GETRANDOM_WORKS) { + long n; + char dest[1]; + /* if the kernel CSPRNG is not initialized this will block */ + n = syscall(SYS_getrandom, dest, sizeof(dest), 0); + if (n == sizeof(dest)) { + getrandom_works = CRYPTOGRAPHY_OSRANDOM_GETRANDOM_WORKS; + } else { + int e = errno; + switch(e) { + case ENOSYS: + /* Fallback: Kernel does not support the syscall. */ + getrandom_works = CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK; + break; + case EPERM: + /* Fallback: seccomp prevents syscall */ + getrandom_works = CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK; + break; + default: + /* EINTR cannot occur for buflen < 256. */ + ERR_Cryptography_OSRandom_error( + CRYPTOGRAPHY_OSRANDOM_F_INIT, + CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_INIT_FAILED_UNEXPECTED, + "errno", e + ); + getrandom_works = CRYPTOGRAPHY_OSRANDOM_GETRANDOM_INIT_FAILED; + break; + } + } + } + + /* fallback to dev urandom */ + if (getrandom_works == CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK) { + int fd = dev_urandom_fd(); + if (fd < 0) { + return 0; + } + } + return 1; +} + +static int osrandom_rand_bytes(unsigned char *buffer, int size) { + long n; + + switch(getrandom_works) { + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_INIT_FAILED: + ERR_Cryptography_OSRandom_error( + CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES, + CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_INIT_FAILED, + __FILE__, __LINE__ + ); + return 0; + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_NOT_INIT: + ERR_Cryptography_OSRandom_error( + CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES, + CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_NOT_INIT, + __FILE__, __LINE__ + ); + return 0; + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK: + return dev_urandom_read(buffer, size); + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_WORKS: + while (size > 0) { + do { + n = syscall(SYS_getrandom, buffer, size, 0); + } while (n < 0 && errno == EINTR); + + if (n <= 0) { + ERR_Cryptography_OSRandom_error( + CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES, + CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_FAILED, + __FILE__, __LINE__ + ); + return 0; + } + buffer += n; + size -= (int)n; + } + return 1; + } + __builtin_unreachable(); +} + +static int osrandom_finish(ENGINE *e) { + dev_urandom_close(); + return 1; +} + +static int osrandom_rand_status(void) { + switch(getrandom_works) { + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_INIT_FAILED: + return 0; + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_NOT_INIT: + return 0; + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK: + return urandom_cache.fd >= 0; + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_WORKS: + return 1; + } + __builtin_unreachable(); +} + +static const char *osurandom_get_implementation(void) { + switch(getrandom_works) { + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_INIT_FAILED: + return "<failed>"; + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_NOT_INIT: + return "<not initialized>"; + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_FALLBACK: + return "/dev/urandom"; + case CRYPTOGRAPHY_OSRANDOM_GETRANDOM_WORKS: + return "getrandom"; + } + __builtin_unreachable(); +} +#endif /* CRYPTOGRAPHY_OSRANDOM_ENGINE_GETRANDOM */ + +/**************************************************************************** + * dev_urandom engine for all remaining platforms + */ + +#if CRYPTOGRAPHY_OSRANDOM_ENGINE == CRYPTOGRAPHY_OSRANDOM_ENGINE_DEV_URANDOM +static const char *Cryptography_osrandom_engine_name = "osrandom_engine /dev/urandom"; + +static int osrandom_init(ENGINE *e) { + int fd = dev_urandom_fd(); + if (fd < 0) { + return 0; + } + return 1; +} + +static int osrandom_rand_bytes(unsigned char *buffer, int size) { + return dev_urandom_read(buffer, size); +} + +static int osrandom_finish(ENGINE *e) { + dev_urandom_close(); + return 1; +} + +static int osrandom_rand_status(void) { + return urandom_cache.fd >= 0; +} + +static const char *osurandom_get_implementation(void) { + return "/dev/urandom"; +} +#endif /* CRYPTOGRAPHY_OSRANDOM_ENGINE_DEV_URANDOM */ + +/**************************************************************************** + * ENGINE boiler plate + */ + +/* This replicates the behavior of the OpenSSL FIPS RNG, which returns a + -1 in the event that there is an error when calling RAND_pseudo_bytes. */ +static int osrandom_pseudo_rand_bytes(unsigned char *buffer, int size) { + int res = osrandom_rand_bytes(buffer, size); + if (res == 0) { + return -1; + } else { + return res; + } +} + +static RAND_METHOD osrandom_rand = { + NULL, + osrandom_rand_bytes, + NULL, + NULL, + osrandom_pseudo_rand_bytes, + osrandom_rand_status, +}; + +static const ENGINE_CMD_DEFN osrandom_cmd_defns[] = { + {CRYPTOGRAPHY_OSRANDOM_GET_IMPLEMENTATION, + "get_implementation", + "Get CPRNG implementation.", + ENGINE_CMD_FLAG_NO_INPUT}, + {0, NULL, NULL, 0} +}; + +static int osrandom_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void)) { + const char *name; + size_t len; + + switch (cmd) { + case CRYPTOGRAPHY_OSRANDOM_GET_IMPLEMENTATION: + /* i: buffer size, p: char* buffer */ + name = osurandom_get_implementation(); + len = strlen(name); + if ((p == NULL) && (i == 0)) { + /* return required buffer len */ + return (int)len; + } + if ((p == NULL) || i < 0 || ((size_t)i <= len)) { + /* no buffer or buffer too small */ + ENGINEerr(ENGINE_F_ENGINE_CTRL, ENGINE_R_INVALID_ARGUMENT); + return 0; + } + strcpy((char *)p, name); + return (int)len; + default: + ENGINEerr(ENGINE_F_ENGINE_CTRL, ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED); + return 0; + } +} + +/* error reporting */ +#define ERR_FUNC(func) ERR_PACK(0, func, 0) +#define ERR_REASON(reason) ERR_PACK(0, 0, reason) + +static ERR_STRING_DATA CRYPTOGRAPHY_OSRANDOM_lib_name[] = { + {0, "osrandom_engine"}, + {0, NULL} +}; + +static ERR_STRING_DATA CRYPTOGRAPHY_OSRANDOM_str_funcs[] = { + {ERR_FUNC(CRYPTOGRAPHY_OSRANDOM_F_INIT), + "osrandom_init"}, + {ERR_FUNC(CRYPTOGRAPHY_OSRANDOM_F_RAND_BYTES), + "osrandom_rand_bytes"}, + {ERR_FUNC(CRYPTOGRAPHY_OSRANDOM_F_FINISH), + "osrandom_finish"}, + {ERR_FUNC(CRYPTOGRAPHY_OSRANDOM_F_DEV_URANDOM_FD), + "dev_urandom_fd"}, + {ERR_FUNC(CRYPTOGRAPHY_OSRANDOM_F_DEV_URANDOM_READ), + "dev_urandom_read"}, + {0, NULL} +}; + +static ERR_STRING_DATA CRYPTOGRAPHY_OSRANDOM_str_reasons[] = { + {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_CRYPTACQUIRECONTEXT), + "CryptAcquireContext() failed."}, + {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_CRYPTGENRANDOM), + "CryptGenRandom() failed."}, + {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_CRYPTRELEASECONTEXT), + "CryptReleaseContext() failed."}, + {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_GETENTROPY_FAILED), + "getentropy() failed"}, + {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_DEV_URANDOM_OPEN_FAILED), + "open('/dev/urandom') failed."}, + {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_DEV_URANDOM_READ_FAILED), + "Reading from /dev/urandom fd failed."}, + {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_INIT_FAILED), + "getrandom() initialization failed."}, + {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_INIT_FAILED_UNEXPECTED), + "getrandom() initialization failed with unexpected errno."}, + {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_FAILED), + "getrandom() syscall failed."}, + {ERR_REASON(CRYPTOGRAPHY_OSRANDOM_R_GETRANDOM_NOT_INIT), + "getrandom() engine was not properly initialized."}, + {0, NULL} +}; + +static int Cryptography_OSRandom_lib_error_code = 0; + +static void ERR_load_Cryptography_OSRandom_strings(void) +{ + if (Cryptography_OSRandom_lib_error_code == 0) { + Cryptography_OSRandom_lib_error_code = ERR_get_next_error_library(); + ERR_load_strings(Cryptography_OSRandom_lib_error_code, + CRYPTOGRAPHY_OSRANDOM_lib_name); + ERR_load_strings(Cryptography_OSRandom_lib_error_code, + CRYPTOGRAPHY_OSRANDOM_str_funcs); + ERR_load_strings(Cryptography_OSRandom_lib_error_code, + CRYPTOGRAPHY_OSRANDOM_str_reasons); + } +} + +static void ERR_Cryptography_OSRandom_error(int function, int reason, + char *file, int line) +{ + ERR_PUT_error(Cryptography_OSRandom_lib_error_code, function, reason, + file, line); +} + +/* Returns 1 if successfully added, 2 if engine has previously been added, + and 0 for error. */ +int Cryptography_add_osrandom_engine(void) { + ENGINE *e; + + ERR_load_Cryptography_OSRandom_strings(); + + e = ENGINE_by_id(Cryptography_osrandom_engine_id); + if (e != NULL) { + ENGINE_free(e); + return 2; + } else { + ERR_clear_error(); + } + + e = ENGINE_new(); + if (e == NULL) { + return 0; + } + if (!ENGINE_set_id(e, Cryptography_osrandom_engine_id) || + !ENGINE_set_name(e, Cryptography_osrandom_engine_name) || + !ENGINE_set_RAND(e, &osrandom_rand) || + !ENGINE_set_init_function(e, osrandom_init) || + !ENGINE_set_finish_function(e, osrandom_finish) || + !ENGINE_set_cmd_defns(e, osrandom_cmd_defns) || + !ENGINE_set_ctrl_function(e, osrandom_ctrl)) { + ENGINE_free(e); + return 0; + } + if (!ENGINE_add(e)) { + ENGINE_free(e); + return 0; + } + if (!ENGINE_free(e)) { + return 0; + } + + return 1; +} + +#else +/* If OpenSSL has no ENGINE support then we don't want + * to compile the osrandom engine, but we do need some + * placeholders */ +static const char *Cryptography_osrandom_engine_id = "no-engine-support"; +static const char *Cryptography_osrandom_engine_name = "osrandom_engine disabled"; + +int Cryptography_add_osrandom_engine(void) { + return 0; +} + +#endif + + +#if !defined(EVP_PKEY_DHX) || EVP_PKEY_DHX == -1 +int (*PEM_write_bio_DHxparams)(BIO *, DH *) = NULL; +#endif + + + + + + +#if !CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_RSA_OAEP_MD = 1; +static const long Cryptography_HAS_RSA_OAEP_LABEL = 1; +#else +static const long Cryptography_HAS_RSA_OAEP_MD = 0; +static const long Cryptography_HAS_RSA_OAEP_LABEL = 0; +int (*EVP_PKEY_CTX_set_rsa_oaep_md)(EVP_PKEY_CTX *, EVP_MD *) = NULL; +int (*EVP_PKEY_CTX_set0_rsa_oaep_label)(EVP_PKEY_CTX *, unsigned char *, + int) = NULL; +#endif + + +// This symbol is being preserved because removing it will break users with +// pyOpenSSL < 19.1 and pip < 20.x. We need to leave this in place until those +// users have upgraded. PersistentlyDeprecated2020 +static const long Cryptography_HAS_TLSEXT_HOSTNAME = 1; + +#if CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_VERIFIED_CHAIN = 0; +Cryptography_STACK_OF_X509 *(*SSL_get0_verified_chain)(const SSL *) = NULL; +#else +static const long Cryptography_HAS_VERIFIED_CHAIN = 1; +#endif + +#if CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 +static const long Cryptography_HAS_KEYLOG = 0; +void (*SSL_CTX_set_keylog_callback)(SSL_CTX *, + void (*) (const SSL *, const char *) + ) = NULL; +void (*(*SSL_CTX_get_keylog_callback)(SSL_CTX *))( + const SSL *, + const char * + ) = NULL; +#else +static const long Cryptography_HAS_KEYLOG = 1; +#endif + +static const long Cryptography_HAS_SECURE_RENEGOTIATION = 1; + +#ifdef OPENSSL_NO_SSL3_METHOD +static const long Cryptography_HAS_SSL3_METHOD = 0; +SSL_METHOD* (*SSLv3_method)(void) = NULL; +SSL_METHOD* (*SSLv3_client_method)(void) = NULL; +SSL_METHOD* (*SSLv3_server_method)(void) = NULL; +#else +static const long Cryptography_HAS_SSL3_METHOD = 1; +#endif + +static const long Cryptography_HAS_RELEASE_BUFFERS = 1; +static const long Cryptography_HAS_OP_NO_COMPRESSION = 1; +static const long Cryptography_HAS_TLSv1_1 = 1; +static const long Cryptography_HAS_TLSv1_2 = 1; +static const long Cryptography_HAS_SSL_OP_MSIE_SSLV2_RSA_PADDING = 1; +static const long Cryptography_HAS_SSL_OP_NO_TICKET = 1; +static const long Cryptography_HAS_SSL_SET_SSL_CTX = 1; +static const long Cryptography_HAS_NEXTPROTONEG = 0; +static const long Cryptography_HAS_ALPN = 1; + +#if CRYPTOGRAPHY_IS_LIBRESSL +void (*SSL_CTX_set_cert_cb)(SSL_CTX *, int (*)(SSL *, void *), void *) = NULL; +void (*SSL_set_cert_cb)(SSL *, int (*)(SSL *, void *), void *) = NULL; +static const long Cryptography_HAS_SET_CERT_CB = 0; +#else +static const long Cryptography_HAS_SET_CERT_CB = 1; +#endif + +static const long Cryptography_HAS_SSL_CTX_CLEAR_OPTIONS = 1; + +/* in OpenSSL 1.1.0 the SSL_ST values were renamed to TLS_ST and several were + removed */ +#if CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_SSL_ST = 1; +#else +static const long Cryptography_HAS_SSL_ST = 0; +static const long SSL_ST_BEFORE = 0; +static const long SSL_ST_OK = 0; +static const long SSL_ST_INIT = 0; +static const long SSL_ST_RENEGOTIATE = 0; +#endif +#if !CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_TLS_ST = 1; +#else +static const long Cryptography_HAS_TLS_ST = 0; +static const long TLS_ST_BEFORE = 0; +static const long TLS_ST_OK = 0; +#endif + +#if CRYPTOGRAPHY_IS_LIBRESSL +static const long SSL_OP_NO_DTLSv1 = 0; +static const long SSL_OP_NO_DTLSv1_2 = 0; +long (*DTLS_set_link_mtu)(SSL *, long) = NULL; +long (*DTLS_get_link_min_mtu)(SSL *) = NULL; +#endif + +static const long Cryptography_HAS_DTLS = 1; +/* Wrap DTLSv1_get_timeout to avoid cffi to handle a 'struct timeval'. */ +long Cryptography_DTLSv1_get_timeout(SSL *ssl, time_t *ptv_sec, + long *ptv_usec) { + struct timeval tv = { 0 }; + long r = DTLSv1_get_timeout(ssl, &tv); + + if (r == 1) { + if (ptv_sec) { + *ptv_sec = tv.tv_sec; + } + + if (ptv_usec) { + *ptv_usec = tv.tv_usec; + } + } + + return r; +} + +#if CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_SIGALGS = 0; +const int (*SSL_get_sigalgs)(SSL *, int, int *, int *, int *, unsigned char *, + unsigned char *) = NULL; +const long (*SSL_CTX_set1_sigalgs_list)(SSL_CTX *, const char *) = NULL; +#else +static const long Cryptography_HAS_SIGALGS = 1; +#endif + +#if CRYPTOGRAPHY_IS_LIBRESSL || defined(OPENSSL_NO_PSK) +static const long Cryptography_HAS_PSK = 0; +int (*SSL_CTX_use_psk_identity_hint)(SSL_CTX *, const char *) = NULL; +void (*SSL_CTX_set_psk_server_callback)(SSL_CTX *, + unsigned int (*)( + SSL *, + const char *, + unsigned char *, + unsigned int + )) = NULL; +void (*SSL_CTX_set_psk_client_callback)(SSL_CTX *, + unsigned int (*)( + SSL *, + const char *, + char *, + unsigned int, + unsigned char *, + unsigned int + )) = NULL; +#else +static const long Cryptography_HAS_PSK = 1; +#endif + +#if !CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_CUSTOM_EXT = 1; +#else +static const long Cryptography_HAS_CUSTOM_EXT = 0; +typedef int (*custom_ext_add_cb)(SSL *, unsigned int, + const unsigned char **, + size_t *, int *, + void *); +typedef void (*custom_ext_free_cb)(SSL *, unsigned int, + const unsigned char *, + void *); +typedef int (*custom_ext_parse_cb)(SSL *, unsigned int, + const unsigned char *, + size_t, int *, + void *); +int (*SSL_CTX_add_client_custom_ext)(SSL_CTX *, unsigned int, + custom_ext_add_cb, + custom_ext_free_cb, void *, + custom_ext_parse_cb, + void *) = NULL; +int (*SSL_CTX_add_server_custom_ext)(SSL_CTX *, unsigned int, + custom_ext_add_cb, + custom_ext_free_cb, void *, + custom_ext_parse_cb, + void *) = NULL; +int (*SSL_extension_supported)(unsigned int) = NULL; +#endif + +#ifndef OPENSSL_NO_SRTP +static const long Cryptography_HAS_SRTP = 1; +#else +static const long Cryptography_HAS_SRTP = 0; +int (*SSL_CTX_set_tlsext_use_srtp)(SSL_CTX *, const char *) = NULL; +int (*SSL_set_tlsext_use_srtp)(SSL *, const char *) = NULL; +SRTP_PROTECTION_PROFILE * (*SSL_get_selected_srtp_profile)(SSL *) = NULL; +#endif + +#if CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 +static const long Cryptography_HAS_TLSv1_3 = 0; +static const long SSL_OP_NO_TLSv1_3 = 0; +static const long SSL_VERIFY_POST_HANDSHAKE = 0; +int (*SSL_CTX_set_ciphersuites)(SSL_CTX *, const char *) = NULL; +int (*SSL_verify_client_post_handshake)(SSL *) = NULL; +void (*SSL_CTX_set_post_handshake_auth)(SSL_CTX *, int) = NULL; +void (*SSL_set_post_handshake_auth)(SSL *, int) = NULL; +uint32_t (*SSL_SESSION_get_max_early_data)(const SSL_SESSION *) = NULL; +int (*SSL_write_early_data)(SSL *, const void *, size_t, size_t *) = NULL; +int (*SSL_read_early_data)(SSL *, void *, size_t, size_t *) = NULL; +int (*SSL_CTX_set_max_early_data)(SSL_CTX *, uint32_t) = NULL; +#else +static const long Cryptography_HAS_TLSv1_3 = 1; +#endif + +#if CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 && !CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_GET_PROTO_VERSION = 0; + +long (*SSL_CTX_get_min_proto_version)(SSL_CTX *) = NULL; +long (*SSL_CTX_get_max_proto_version)(SSL_CTX *) = NULL; +long (*SSL_get_min_proto_version)(SSL *) = NULL; +long (*SSL_get_max_proto_version)(SSL *) = NULL; +#else +static const long Cryptography_HAS_GET_PROTO_VERSION = 1; +#endif + + +#if CRYPTOGRAPHY_IS_LIBRESSL +int i2d_re_X509_tbs(X509 *x, unsigned char **pp) +{ + /* in 1.0.2+ this function also sets x->cert_info->enc.modified = 1 + but older OpenSSLs don't have the enc ASN1_ENCODING member in the + X509 struct. Setting modified to 1 marks the encoding + (x->cert_info->enc.enc) as invalid, but since the entire struct isn't + present we don't care. */ + return i2d_X509_CINF(x->cert_info, pp); +} +#endif + +/* Being kept around for pyOpenSSL */ +X509_REVOKED *Cryptography_X509_REVOKED_dup(X509_REVOKED *rev) { + return X509_REVOKED_dup(rev); +} +/* Added in 1.1.0 but we need it in all versions now due to the great + opaquing. */ +#if CRYPTOGRAPHY_IS_LIBRESSL +int i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp) +{ + req->req_info->enc.modified = 1; + return i2d_X509_REQ_INFO(req->req_info, pp); +} +int i2d_re_X509_CRL_tbs(X509_CRL *crl, unsigned char **pp) { + crl->crl->enc.modified = 1; + return i2d_X509_CRL_INFO(crl->crl, pp); +} +#endif + + + + + + +#if !CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_102_VERIFICATION = 1; +#else +static const long Cryptography_HAS_102_VERIFICATION = 0; +static const long X509_V_ERR_SUITE_B_INVALID_VERSION = 0; +static const long X509_V_ERR_SUITE_B_INVALID_ALGORITHM = 0; +static const long X509_V_ERR_SUITE_B_INVALID_CURVE = 0; +static const long X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM = 0; +static const long X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED = 0; +static const long X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 = 0; +static const long X509_V_FLAG_SUITEB_128_LOS_ONLY = 0; +static const long X509_V_FLAG_SUITEB_192_LOS = 0; +static const long X509_V_FLAG_SUITEB_128_LOS = 0; +#endif + +#if CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_110_VERIFICATION_PARAMS = 0; +#ifndef X509_CHECK_FLAG_NEVER_CHECK_SUBJECT +static const long X509_CHECK_FLAG_NEVER_CHECK_SUBJECT = 0; +#endif +#else +static const long Cryptography_HAS_110_VERIFICATION_PARAMS = 1; +#endif + +#if CRYPTOGRAPHY_IS_LIBRESSL +static const long Cryptography_HAS_X509_STORE_CTX_GET_ISSUER = 0; +typedef void *X509_STORE_CTX_get_issuer_fn; +X509_STORE_CTX_get_issuer_fn (*X509_STORE_get_get_issuer)(X509_STORE *) = NULL; +void (*X509_STORE_set_get_issuer)(X509_STORE *, + X509_STORE_CTX_get_issuer_fn) = NULL; +#else +static const long Cryptography_HAS_X509_STORE_CTX_GET_ISSUER = 1; +#endif + + + +typedef struct { + char *password; + int length; + int called; + int error; + int maxsize; +} CRYPTOGRAPHY_PASSWORD_DATA; + +int Cryptography_pem_password_cb(char *buf, int size, + int rwflag, void *userdata) { + /* The password cb is only invoked if OpenSSL decides the private + key is encrypted. So this path only occurs if it needs a password */ + CRYPTOGRAPHY_PASSWORD_DATA *st = (CRYPTOGRAPHY_PASSWORD_DATA *)userdata; + st->called += 1; + st->maxsize = size; + if (st->length == 0) { + st->error = -1; + return 0; + } else if (st->length < size) { + memcpy(buf, st->password, st->length); + return st->length; + } else { + st->error = -2; + return 0; + } +} + +#define CRYPTOGRAPHY_PACKAGE_VERSION "3.3.2" + +/************************************************************/ + +static void *_cffi_types[] = { +/* 0 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1056), // ACCESS_DESCRIPTION *()(Cryptography_STACK_OF_ACCESS_DESCRIPTION *, int) +/* 1 */ _CFFI_OP(_CFFI_OP_POINTER, 3034), // Cryptography_STACK_OF_ACCESS_DESCRIPTION * +/* 2 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), // int +/* 3 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 4 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1056), // ACCESS_DESCRIPTION *()(void) +/* 5 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 6 */ _CFFI_OP(_CFFI_OP_FUNCTION, 757), // ASN1_ENUMERATED *()(void) +/* 7 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 8 */ _CFFI_OP(_CFFI_OP_FUNCTION, 9), // ASN1_GENERALIZEDTIME *()(ASN1_GENERALIZEDTIME *, time_t) +/* 9 */ _CFFI_OP(_CFFI_OP_POINTER, 3010), // ASN1_GENERALIZEDTIME * +/* 10 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, _cffi_prim_int(sizeof(time_t), ( + ((time_t)-1) | 0 /* check that time_t is an integer type */ + ) <= 0)), // time_t +/* 11 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 12 */ _CFFI_OP(_CFFI_OP_FUNCTION, 9), // ASN1_GENERALIZEDTIME *()(ASN1_OCTET_STRING *, ASN1_GENERALIZEDTIME * *) +/* 13 */ _CFFI_OP(_CFFI_OP_POINTER, 3017), // ASN1_OCTET_STRING * +/* 14 */ _CFFI_OP(_CFFI_OP_POINTER, 9), // ASN1_GENERALIZEDTIME * * +/* 15 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 16 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3009), // ASN1_GENERALIZEDTIME const *()(OCSP_BASICRESP const *) +/* 17 */ _CFFI_OP(_CFFI_OP_POINTER, 3078), // OCSP_BASICRESP const * +/* 18 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 19 */ _CFFI_OP(_CFFI_OP_FUNCTION, 21), // ASN1_INTEGER *()(BIGNUM *, ASN1_INTEGER *) +/* 20 */ _CFFI_OP(_CFFI_OP_POINTER, 3021), // BIGNUM * +/* 21 */ _CFFI_OP(_CFFI_OP_POINTER, 3012), // ASN1_INTEGER * +/* 22 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 23 */ _CFFI_OP(_CFFI_OP_FUNCTION, 21), // ASN1_INTEGER *()(Cryptography_STACK_OF_ASN1_INTEGER *, int) +/* 24 */ _CFFI_OP(_CFFI_OP_POINTER, 3035), // Cryptography_STACK_OF_ASN1_INTEGER * +/* 25 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 26 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 27 */ _CFFI_OP(_CFFI_OP_FUNCTION, 21), // ASN1_INTEGER *()(X509 *) +/* 28 */ _CFFI_OP(_CFFI_OP_POINTER, 3119), // X509 * +/* 29 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 30 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3011), // ASN1_INTEGER const *()(X509_REVOKED const *) +/* 31 */ _CFFI_OP(_CFFI_OP_POINTER, 3131), // X509_REVOKED const * +/* 32 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 33 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3013), // ASN1_NULL *()(void) +/* 34 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 35 */ _CFFI_OP(_CFFI_OP_FUNCTION, 607), // ASN1_OBJECT *()(Cryptography_STACK_OF_ASN1_OBJECT *, int) +/* 36 */ _CFFI_OP(_CFFI_OP_POINTER, 3036), // Cryptography_STACK_OF_ASN1_OBJECT * +/* 37 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 38 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 39 */ _CFFI_OP(_CFFI_OP_FUNCTION, 607), // ASN1_OBJECT *()(X509_EXTENSION *) +/* 40 */ _CFFI_OP(_CFFI_OP_POINTER, 3125), // X509_EXTENSION * +/* 41 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 42 */ _CFFI_OP(_CFFI_OP_FUNCTION, 607), // ASN1_OBJECT *()(X509_NAME_ENTRY *) +/* 43 */ _CFFI_OP(_CFFI_OP_POINTER, 3128), // X509_NAME_ENTRY * +/* 44 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 45 */ _CFFI_OP(_CFFI_OP_FUNCTION, 607), // ASN1_OBJECT *()(char const *, int) +/* 46 */ _CFFI_OP(_CFFI_OP_POINTER, 3135), // char const * +/* 47 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 48 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 49 */ _CFFI_OP(_CFFI_OP_FUNCTION, 13), // ASN1_OCTET_STRING *()(ASN1_OCTET_STRING *, long) +/* 50 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 51 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), // long +/* 52 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 53 */ _CFFI_OP(_CFFI_OP_FUNCTION, 13), // ASN1_OCTET_STRING *()(X509 *) +/* 54 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 55 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 56 */ _CFFI_OP(_CFFI_OP_FUNCTION, 13), // ASN1_OCTET_STRING *()(X509_CRL *) +/* 57 */ _CFFI_OP(_CFFI_OP_POINTER, 3124), // X509_CRL * +/* 58 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 59 */ _CFFI_OP(_CFFI_OP_FUNCTION, 13), // ASN1_OCTET_STRING *()(X509_EXTENSION *) +/* 60 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 61 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 62 */ _CFFI_OP(_CFFI_OP_FUNCTION, 13), // ASN1_OCTET_STRING *()(X509_NAME_ENTRY *) +/* 63 */ _CFFI_OP(_CFFI_OP_NOOP, 43), +/* 64 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 65 */ _CFFI_OP(_CFFI_OP_FUNCTION, 13), // ASN1_OCTET_STRING *()(void) +/* 66 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 67 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3016), // ASN1_OCTET_STRING const *()(OCSP_BASICRESP const *) +/* 68 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 69 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 70 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3016), // ASN1_OCTET_STRING const *()(X509_REVOKED const *) +/* 71 */ _CFFI_OP(_CFFI_OP_NOOP, 31), +/* 72 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 73 */ _CFFI_OP(_CFFI_OP_FUNCTION, 801), // ASN1_TYPE *()(ASN1_TYPE * *, unsigned char const * *, long) +/* 74 */ _CFFI_OP(_CFFI_OP_POINTER, 801), // ASN1_TYPE * * +/* 75 */ _CFFI_OP(_CFFI_OP_POINTER, 103), // unsigned char const * * +/* 76 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 77 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 78 */ _CFFI_OP(_CFFI_OP_FUNCTION, 801), // ASN1_TYPE *()(X509_ATTRIBUTE *, int) +/* 79 */ _CFFI_OP(_CFFI_OP_POINTER, 3123), // X509_ATTRIBUTE * +/* 80 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 81 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 82 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2557), // AUTHORITY_KEYID *()(void) +/* 83 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 84 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2560), // BASIC_CONSTRAINTS *()(void) +/* 85 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 86 */ _CFFI_OP(_CFFI_OP_FUNCTION, 20), // BIGNUM *()(ASN1_INTEGER *, BIGNUM *) +/* 87 */ _CFFI_OP(_CFFI_OP_NOOP, 21), +/* 88 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 89 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 90 */ _CFFI_OP(_CFFI_OP_FUNCTION, 20), // BIGNUM *()(BIGNUM *, BIGNUM const *, BIGNUM const *, BN_CTX *) +/* 91 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 92 */ _CFFI_OP(_CFFI_OP_POINTER, 3021), // BIGNUM const * +/* 93 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 94 */ _CFFI_OP(_CFFI_OP_POINTER, 3024), // BN_CTX * +/* 95 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 96 */ _CFFI_OP(_CFFI_OP_FUNCTION, 20), // BIGNUM *()(BIGNUM const *) +/* 97 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 98 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 99 */ _CFFI_OP(_CFFI_OP_FUNCTION, 20), // BIGNUM *()(BN_CTX *) +/* 100 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 101 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 102 */ _CFFI_OP(_CFFI_OP_FUNCTION, 20), // BIGNUM *()(unsigned char const *, int, BIGNUM *) +/* 103 */ _CFFI_OP(_CFFI_OP_POINTER, 3140), // unsigned char const * +/* 104 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 105 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 106 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 107 */ _CFFI_OP(_CFFI_OP_FUNCTION, 20), // BIGNUM *()(void) +/* 108 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 109 */ _CFFI_OP(_CFFI_OP_FUNCTION, 92), // BIGNUM const *()(EC_KEY const *) +/* 110 */ _CFFI_OP(_CFFI_OP_POINTER, 3055), // EC_KEY const * +/* 111 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 112 */ _CFFI_OP(_CFFI_OP_FUNCTION, 92), // BIGNUM const *()(void) +/* 113 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 114 */ _CFFI_OP(_CFFI_OP_FUNCTION, 186), // BIO *()(BIO_METHOD *) +/* 115 */ _CFFI_OP(_CFFI_OP_POINTER, 3023), // BIO_METHOD * +/* 116 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 117 */ _CFFI_OP(_CFFI_OP_FUNCTION, 186), // BIO *()(char const *, char const *) +/* 118 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 119 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 120 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 121 */ _CFFI_OP(_CFFI_OP_FUNCTION, 186), // BIO *()(int, int) +/* 122 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 123 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 124 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 125 */ _CFFI_OP(_CFFI_OP_FUNCTION, 186), // BIO *()(void const *, int) +/* 126 */ _CFFI_OP(_CFFI_OP_POINTER, 3142), // void const * +/* 127 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 128 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 129 */ _CFFI_OP(_CFFI_OP_FUNCTION, 115), // BIO_METHOD *()(void) +/* 130 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 131 */ _CFFI_OP(_CFFI_OP_FUNCTION, 94), // BN_CTX *()(void) +/* 132 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 133 */ _CFFI_OP(_CFFI_OP_FUNCTION, 830), // BN_MONT_CTX *()(void) +/* 134 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 135 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1031), // CMAC_CTX *()(void) +/* 136 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 137 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1), // Cryptography_STACK_OF_ACCESS_DESCRIPTION *()(void) +/* 138 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 139 */ _CFFI_OP(_CFFI_OP_FUNCTION, 24), // Cryptography_STACK_OF_ASN1_INTEGER *()(void) +/* 140 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 141 */ _CFFI_OP(_CFFI_OP_FUNCTION, 36), // Cryptography_STACK_OF_ASN1_OBJECT *()(void) +/* 142 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 143 */ _CFFI_OP(_CFFI_OP_FUNCTION, 204), // Cryptography_STACK_OF_DIST_POINT *()(void) +/* 144 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 145 */ _CFFI_OP(_CFFI_OP_FUNCTION, 329), // Cryptography_STACK_OF_GENERAL_SUBTREE *()(void) +/* 146 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 147 */ _CFFI_OP(_CFFI_OP_FUNCTION, 449), // Cryptography_STACK_OF_POLICYINFO *()(void) +/* 148 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 149 */ _CFFI_OP(_CFFI_OP_FUNCTION, 455), // Cryptography_STACK_OF_POLICYQUALINFO *()(void) +/* 150 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 151 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1101), // Cryptography_STACK_OF_SCT *()(void) +/* 152 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 153 */ _CFFI_OP(_CFFI_OP_FUNCTION, 413), // Cryptography_STACK_OF_X509 *()(OCSP_BASICRESP const *) +/* 154 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 155 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 156 */ _CFFI_OP(_CFFI_OP_FUNCTION, 413), // Cryptography_STACK_OF_X509 *()(SSL const *) +/* 157 */ _CFFI_OP(_CFFI_OP_POINTER, 3111), // SSL const * +/* 158 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 159 */ _CFFI_OP(_CFFI_OP_FUNCTION, 413), // Cryptography_STACK_OF_X509 *()(X509_STORE_CTX *) +/* 160 */ _CFFI_OP(_CFFI_OP_POINTER, 3133), // X509_STORE_CTX * +/* 161 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 162 */ _CFFI_OP(_CFFI_OP_FUNCTION, 413), // Cryptography_STACK_OF_X509 *()(void) +/* 163 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 164 */ _CFFI_OP(_CFFI_OP_FUNCTION, 565), // Cryptography_STACK_OF_X509_CRL *()(void) +/* 165 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 166 */ _CFFI_OP(_CFFI_OP_FUNCTION, 633), // Cryptography_STACK_OF_X509_NAME *()(SSL const *) +/* 167 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 168 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 169 */ _CFFI_OP(_CFFI_OP_FUNCTION, 633), // Cryptography_STACK_OF_X509_NAME *()(char const *) +/* 170 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 171 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 172 */ _CFFI_OP(_CFFI_OP_FUNCTION, 633), // Cryptography_STACK_OF_X509_NAME *()(void) +/* 173 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 174 */ _CFFI_OP(_CFFI_OP_FUNCTION, 175), // Cryptography_STACK_OF_X509_NAME_ENTRY *()(Cryptography_STACK_OF_X509_NAME_ENTRY *) +/* 175 */ _CFFI_OP(_CFFI_OP_POINTER, 3046), // Cryptography_STACK_OF_X509_NAME_ENTRY * +/* 176 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 177 */ _CFFI_OP(_CFFI_OP_FUNCTION, 175), // Cryptography_STACK_OF_X509_NAME_ENTRY *()(void) +/* 178 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 179 */ _CFFI_OP(_CFFI_OP_FUNCTION, 666), // Cryptography_STACK_OF_X509_OBJECT *()(X509_STORE *) +/* 180 */ _CFFI_OP(_CFFI_OP_POINTER, 3132), // X509_STORE * +/* 181 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 182 */ _CFFI_OP(_CFFI_OP_FUNCTION, 682), // Cryptography_STACK_OF_X509_REVOKED *()(X509_CRL *) +/* 183 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 184 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 185 */ _CFFI_OP(_CFFI_OP_FUNCTION, 196), // DH *()(BIO *, DH * *) +/* 186 */ _CFFI_OP(_CFFI_OP_POINTER, 3022), // BIO * +/* 187 */ _CFFI_OP(_CFFI_OP_POINTER, 196), // DH * * +/* 188 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 189 */ _CFFI_OP(_CFFI_OP_FUNCTION, 196), // DH *()(BIO *, DH * *, int(*)(char *, int, int, void *), void *) +/* 190 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 191 */ _CFFI_OP(_CFFI_OP_NOOP, 187), +/* 192 */ _CFFI_OP(_CFFI_OP_POINTER, 2160), // int(*)(char *, int, int, void *) +/* 193 */ _CFFI_OP(_CFFI_OP_POINTER, 3142), // void * +/* 194 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 195 */ _CFFI_OP(_CFFI_OP_FUNCTION, 196), // DH *()(DH *) +/* 196 */ _CFFI_OP(_CFFI_OP_POINTER, 3049), // DH * +/* 197 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 198 */ _CFFI_OP(_CFFI_OP_FUNCTION, 196), // DH *()(EVP_PKEY *) +/* 199 */ _CFFI_OP(_CFFI_OP_POINTER, 3066), // EVP_PKEY * +/* 200 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 201 */ _CFFI_OP(_CFFI_OP_FUNCTION, 196), // DH *()(void) +/* 202 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 203 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1077), // DIST_POINT *()(Cryptography_STACK_OF_DIST_POINT *, int) +/* 204 */ _CFFI_OP(_CFFI_OP_POINTER, 3037), // Cryptography_STACK_OF_DIST_POINT * +/* 205 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 206 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 207 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1077), // DIST_POINT *()(void) +/* 208 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 209 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2644), // DIST_POINT_NAME *()(void) +/* 210 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 211 */ _CFFI_OP(_CFFI_OP_FUNCTION, 212), // DSA *()(DSA *) +/* 212 */ _CFFI_OP(_CFFI_OP_POINTER, 3052), // DSA * +/* 213 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 214 */ _CFFI_OP(_CFFI_OP_FUNCTION, 212), // DSA *()(EVP_PKEY *) +/* 215 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 216 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 217 */ _CFFI_OP(_CFFI_OP_FUNCTION, 212), // DSA *()(void) +/* 218 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 219 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2661), // EC_GROUP *()(int) +/* 220 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 221 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 222 */ _CFFI_OP(_CFFI_OP_FUNCTION, 238), // EC_GROUP const *()(EC_KEY const *) +/* 223 */ _CFFI_OP(_CFFI_OP_NOOP, 110), +/* 224 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 225 */ _CFFI_OP(_CFFI_OP_FUNCTION, 893), // EC_KEY *()(BIO *, EC_KEY * *) +/* 226 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 227 */ _CFFI_OP(_CFFI_OP_POINTER, 893), // EC_KEY * * +/* 228 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 229 */ _CFFI_OP(_CFFI_OP_FUNCTION, 893), // EC_KEY *()(EVP_PKEY *) +/* 230 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 231 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 232 */ _CFFI_OP(_CFFI_OP_FUNCTION, 893), // EC_KEY *()(int) +/* 233 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 234 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 235 */ _CFFI_OP(_CFFI_OP_FUNCTION, 893), // EC_KEY *()(void) +/* 236 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 237 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1298), // EC_METHOD const *()(EC_GROUP const *) +/* 238 */ _CFFI_OP(_CFFI_OP_POINTER, 3054), // EC_GROUP const * +/* 239 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 240 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1207), // EC_POINT *()(EC_GROUP const *) +/* 241 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 242 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 243 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1207), // EC_POINT *()(EC_POINT const *, EC_GROUP const *) +/* 244 */ _CFFI_OP(_CFFI_OP_POINTER, 3057), // EC_POINT const * +/* 245 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 246 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 247 */ _CFFI_OP(_CFFI_OP_FUNCTION, 244), // EC_POINT const *()(EC_GROUP const *) +/* 248 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 249 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 250 */ _CFFI_OP(_CFFI_OP_FUNCTION, 244), // EC_POINT const *()(EC_KEY const *) +/* 251 */ _CFFI_OP(_CFFI_OP_NOOP, 110), +/* 252 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 253 */ _CFFI_OP(_CFFI_OP_FUNCTION, 282), // ENGINE *()(char const *) +/* 254 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 255 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 256 */ _CFFI_OP(_CFFI_OP_FUNCTION, 282), // ENGINE *()(void) +/* 257 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 258 */ _CFFI_OP(_CFFI_OP_FUNCTION, 885), // EVP_CIPHER const *()(EVP_CIPHER_CTX const *) +/* 259 */ _CFFI_OP(_CFFI_OP_POINTER, 3063), // EVP_CIPHER_CTX const * +/* 260 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 261 */ _CFFI_OP(_CFFI_OP_FUNCTION, 885), // EVP_CIPHER const *()(char const *) +/* 262 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 263 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 264 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1318), // EVP_CIPHER_CTX *()(void) +/* 265 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 266 */ _CFFI_OP(_CFFI_OP_FUNCTION, 354), // EVP_MD const *()(char const *) +/* 267 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 268 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 269 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1351), // EVP_MD_CTX *()(void) +/* 270 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 271 */ _CFFI_OP(_CFFI_OP_FUNCTION, 199), // EVP_PKEY *()(BIO *, EVP_PKEY * *) +/* 272 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 273 */ _CFFI_OP(_CFFI_OP_POINTER, 199), // EVP_PKEY * * +/* 274 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 275 */ _CFFI_OP(_CFFI_OP_FUNCTION, 199), // EVP_PKEY *()(BIO *, EVP_PKEY * *, int(*)(char *, int, int, void *), void *) +/* 276 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 277 */ _CFFI_OP(_CFFI_OP_NOOP, 273), +/* 278 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 279 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 280 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 281 */ _CFFI_OP(_CFFI_OP_FUNCTION, 199), // EVP_PKEY *()(ENGINE *, char const *, UI_METHOD *, void *) +/* 282 */ _CFFI_OP(_CFFI_OP_POINTER, 3061), // ENGINE * +/* 283 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 284 */ _CFFI_OP(_CFFI_OP_POINTER, 3117), // UI_METHOD * +/* 285 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 286 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 287 */ _CFFI_OP(_CFFI_OP_FUNCTION, 199), // EVP_PKEY *()(NETSCAPE_SPKI *) +/* 288 */ _CFFI_OP(_CFFI_OP_POINTER, 3075), // NETSCAPE_SPKI * +/* 289 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 290 */ _CFFI_OP(_CFFI_OP_FUNCTION, 199), // EVP_PKEY *()(X509 *) +/* 291 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 292 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 293 */ _CFFI_OP(_CFFI_OP_FUNCTION, 199), // EVP_PKEY *()(X509_REQ *) +/* 294 */ _CFFI_OP(_CFFI_OP_POINTER, 3130), // X509_REQ * +/* 295 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 296 */ _CFFI_OP(_CFFI_OP_FUNCTION, 199), // EVP_PKEY *()(int, ENGINE *, unsigned char const *, size_t) +/* 297 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 298 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 299 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 300 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), // size_t +/* 301 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 302 */ _CFFI_OP(_CFFI_OP_FUNCTION, 199), // EVP_PKEY *()(void) +/* 303 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 304 */ _CFFI_OP(_CFFI_OP_FUNCTION, 309), // EVP_PKEY_CTX *()(EVP_PKEY *, ENGINE *) +/* 305 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 306 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 307 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 308 */ _CFFI_OP(_CFFI_OP_FUNCTION, 309), // EVP_PKEY_CTX *()(EVP_PKEY_CTX *) +/* 309 */ _CFFI_OP(_CFFI_OP_POINTER, 3067), // EVP_PKEY_CTX * +/* 310 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 311 */ _CFFI_OP(_CFFI_OP_FUNCTION, 309), // EVP_PKEY_CTX *()(int, ENGINE *) +/* 312 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 313 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 314 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 315 */ _CFFI_OP(_CFFI_OP_FUNCTION, 928), // GENERAL_NAME *()(GENERAL_NAMES *, int) +/* 316 */ _CFFI_OP(_CFFI_OP_POINTER, 3070), // GENERAL_NAMES * +/* 317 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 318 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 319 */ _CFFI_OP(_CFFI_OP_FUNCTION, 928), // GENERAL_NAME *()(void) +/* 320 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 321 */ _CFFI_OP(_CFFI_OP_FUNCTION, 316), // GENERAL_NAMES *()(GENERAL_NAMES * *, unsigned char const * *, long) +/* 322 */ _CFFI_OP(_CFFI_OP_POINTER, 316), // GENERAL_NAMES * * +/* 323 */ _CFFI_OP(_CFFI_OP_NOOP, 75), +/* 324 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 325 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 326 */ _CFFI_OP(_CFFI_OP_FUNCTION, 316), // GENERAL_NAMES *()(void) +/* 327 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 328 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1084), // GENERAL_SUBTREE *()(Cryptography_STACK_OF_GENERAL_SUBTREE *, int) +/* 329 */ _CFFI_OP(_CFFI_OP_POINTER, 3038), // Cryptography_STACK_OF_GENERAL_SUBTREE * +/* 330 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 331 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 332 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1084), // GENERAL_SUBTREE *()(void) +/* 333 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 334 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1515), // HMAC_CTX *()(void) +/* 335 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 336 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2702), // ISSUING_DIST_POINT *()(void) +/* 337 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 338 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2705), // NAME_CONSTRAINTS *()(void) +/* 339 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 340 */ _CFFI_OP(_CFFI_OP_FUNCTION, 288), // NETSCAPE_SPKI *()(char const *, int) +/* 341 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 342 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 343 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 344 */ _CFFI_OP(_CFFI_OP_FUNCTION, 288), // NETSCAPE_SPKI *()(void) +/* 345 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 346 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2711), // NOTICEREF *()(void) +/* 347 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 348 */ _CFFI_OP(_CFFI_OP_FUNCTION, 387), // OCSP_BASICRESP *()(OCSP_RESPONSE *) +/* 349 */ _CFFI_OP(_CFFI_OP_POINTER, 3085), // OCSP_RESPONSE * +/* 350 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 351 */ _CFFI_OP(_CFFI_OP_FUNCTION, 387), // OCSP_BASICRESP *()(void) +/* 352 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 353 */ _CFFI_OP(_CFFI_OP_FUNCTION, 366), // OCSP_CERTID *()(EVP_MD const *, X509 const *, X509 const *) +/* 354 */ _CFFI_OP(_CFFI_OP_POINTER, 3064), // EVP_MD const * +/* 355 */ _CFFI_OP(_CFFI_OP_POINTER, 3119), // X509 const * +/* 356 */ _CFFI_OP(_CFFI_OP_NOOP, 355), +/* 357 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 358 */ _CFFI_OP(_CFFI_OP_FUNCTION, 366), // OCSP_CERTID *()(OCSP_ONEREQ *) +/* 359 */ _CFFI_OP(_CFFI_OP_POINTER, 3081), // OCSP_ONEREQ * +/* 360 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 361 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3079), // OCSP_CERTID const *()(OCSP_SINGLERESP const *) +/* 362 */ _CFFI_OP(_CFFI_OP_POINTER, 3086), // OCSP_SINGLERESP const * +/* 363 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 364 */ _CFFI_OP(_CFFI_OP_FUNCTION, 359), // OCSP_ONEREQ *()(OCSP_REQUEST *, OCSP_CERTID *) +/* 365 */ _CFFI_OP(_CFFI_OP_POINTER, 3082), // OCSP_REQUEST * +/* 366 */ _CFFI_OP(_CFFI_OP_POINTER, 3080), // OCSP_CERTID * +/* 367 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 368 */ _CFFI_OP(_CFFI_OP_FUNCTION, 359), // OCSP_ONEREQ *()(OCSP_REQUEST *, int) +/* 369 */ _CFFI_OP(_CFFI_OP_NOOP, 365), +/* 370 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 371 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 372 */ _CFFI_OP(_CFFI_OP_FUNCTION, 365), // OCSP_REQUEST *()(BIO *, OCSP_REQUEST * *) +/* 373 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 374 */ _CFFI_OP(_CFFI_OP_POINTER, 365), // OCSP_REQUEST * * +/* 375 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 376 */ _CFFI_OP(_CFFI_OP_FUNCTION, 365), // OCSP_REQUEST *()(void) +/* 377 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 378 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3083), // OCSP_RESPDATA const *()(OCSP_BASICRESP const *) +/* 379 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 380 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 381 */ _CFFI_OP(_CFFI_OP_FUNCTION, 349), // OCSP_RESPONSE *()(BIO *, OCSP_RESPONSE * *) +/* 382 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 383 */ _CFFI_OP(_CFFI_OP_POINTER, 349), // OCSP_RESPONSE * * +/* 384 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 385 */ _CFFI_OP(_CFFI_OP_FUNCTION, 349), // OCSP_RESPONSE *()(int, OCSP_BASICRESP *) +/* 386 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 387 */ _CFFI_OP(_CFFI_OP_POINTER, 3078), // OCSP_BASICRESP * +/* 388 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 389 */ _CFFI_OP(_CFFI_OP_FUNCTION, 594), // OCSP_SINGLERESP *()(OCSP_BASICRESP *, OCSP_CERTID *, int, int, ASN1_OCTET_STRING *, ASN1_OCTET_STRING *, ASN1_OCTET_STRING *) +/* 390 */ _CFFI_OP(_CFFI_OP_NOOP, 387), +/* 391 */ _CFFI_OP(_CFFI_OP_NOOP, 366), +/* 392 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 393 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 394 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 395 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 396 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 397 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 398 */ _CFFI_OP(_CFFI_OP_FUNCTION, 594), // OCSP_SINGLERESP *()(OCSP_BASICRESP *, int) +/* 399 */ _CFFI_OP(_CFFI_OP_NOOP, 387), +/* 400 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 401 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 402 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2726), // OTHERNAME *()(void) +/* 403 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 404 */ _CFFI_OP(_CFFI_OP_FUNCTION, 940), // PKCS12 *()(BIO *, PKCS12 * *) +/* 405 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 406 */ _CFFI_OP(_CFFI_OP_POINTER, 940), // PKCS12 * * +/* 407 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 408 */ _CFFI_OP(_CFFI_OP_FUNCTION, 940), // PKCS12 *()(char *, char *, EVP_PKEY *, X509 *, Cryptography_STACK_OF_X509 *, int, int, int, int, int) +/* 409 */ _CFFI_OP(_CFFI_OP_POINTER, 3135), // char * +/* 410 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 411 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 412 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 413 */ _CFFI_OP(_CFFI_OP_POINTER, 3043), // Cryptography_STACK_OF_X509 * +/* 414 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 415 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 416 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 417 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 418 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 419 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 420 */ _CFFI_OP(_CFFI_OP_FUNCTION, 442), // PKCS7 *()(BIO *, BIO * *) +/* 421 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 422 */ _CFFI_OP(_CFFI_OP_POINTER, 186), // BIO * * +/* 423 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 424 */ _CFFI_OP(_CFFI_OP_FUNCTION, 442), // PKCS7 *()(BIO *, PKCS7 * *) +/* 425 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 426 */ _CFFI_OP(_CFFI_OP_POINTER, 442), // PKCS7 * * +/* 427 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 428 */ _CFFI_OP(_CFFI_OP_FUNCTION, 442), // PKCS7 *()(BIO *, PKCS7 * *, int(*)(char *, int, int, void *), void *) +/* 429 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 430 */ _CFFI_OP(_CFFI_OP_NOOP, 426), +/* 431 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 432 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 433 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 434 */ _CFFI_OP(_CFFI_OP_FUNCTION, 442), // PKCS7 *()(X509 *, EVP_PKEY *, Cryptography_STACK_OF_X509 *, BIO *, int) +/* 435 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 436 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 437 */ _CFFI_OP(_CFFI_OP_NOOP, 413), +/* 438 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 439 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 440 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 441 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3098), // PKCS7_SIGNER_INFO *()(PKCS7 *, X509 *, EVP_PKEY *, EVP_MD const *, int) +/* 442 */ _CFFI_OP(_CFFI_OP_POINTER, 3089), // PKCS7 * +/* 443 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 444 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 445 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 446 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 447 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 448 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1091), // POLICYINFO *()(Cryptography_STACK_OF_POLICYINFO *, int) +/* 449 */ _CFFI_OP(_CFFI_OP_POINTER, 3039), // Cryptography_STACK_OF_POLICYINFO * +/* 450 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 451 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 452 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1091), // POLICYINFO *()(void) +/* 453 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 454 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1098), // POLICYQUALINFO *()(Cryptography_STACK_OF_POLICYQUALINFO *, int) +/* 455 */ _CFFI_OP(_CFFI_OP_POINTER, 3040), // Cryptography_STACK_OF_POLICYQUALINFO * +/* 456 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 457 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 458 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1098), // POLICYQUALINFO *()(void) +/* 459 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 460 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2741), // POLICY_CONSTRAINTS *()(void) +/* 461 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 462 */ _CFFI_OP(_CFFI_OP_FUNCTION, 476), // RSA *()(BIO *, RSA * *) +/* 463 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 464 */ _CFFI_OP(_CFFI_OP_POINTER, 476), // RSA * * +/* 465 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 466 */ _CFFI_OP(_CFFI_OP_FUNCTION, 476), // RSA *()(BIO *, RSA * *, int(*)(char *, int, int, void *), void *) +/* 467 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 468 */ _CFFI_OP(_CFFI_OP_NOOP, 464), +/* 469 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 470 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 471 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 472 */ _CFFI_OP(_CFFI_OP_FUNCTION, 476), // RSA *()(EVP_PKEY *) +/* 473 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 474 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 475 */ _CFFI_OP(_CFFI_OP_FUNCTION, 476), // RSA *()(RSA *) +/* 476 */ _CFFI_OP(_CFFI_OP_POINTER, 3107), // RSA * +/* 477 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 478 */ _CFFI_OP(_CFFI_OP_FUNCTION, 476), // RSA *()(void) +/* 479 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 480 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1102), // SCT *()(Cryptography_STACK_OF_SCT const *, int) +/* 481 */ _CFFI_OP(_CFFI_OP_POINTER, 3041), // Cryptography_STACK_OF_SCT const * +/* 482 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 483 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 484 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1102), // SCT *()(void) +/* 485 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 486 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3109), // SRTP_PROTECTION_PROFILE *()(SSL *) +/* 487 */ _CFFI_OP(_CFFI_OP_POINTER, 3111), // SSL * +/* 488 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 489 */ _CFFI_OP(_CFFI_OP_FUNCTION, 487), // SSL *()(SSL_CTX *) +/* 490 */ _CFFI_OP(_CFFI_OP_POINTER, 3113), // SSL_CTX * +/* 491 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 492 */ _CFFI_OP(_CFFI_OP_FUNCTION, 733), // SSL_CIPHER const *()(Cryptography_STACK_OF_SSL_CIPHER *, int) +/* 493 */ _CFFI_OP(_CFFI_OP_POINTER, 3042), // Cryptography_STACK_OF_SSL_CIPHER * +/* 494 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 495 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 496 */ _CFFI_OP(_CFFI_OP_FUNCTION, 733), // SSL_CIPHER const *()(SSL const *) +/* 497 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 498 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 499 */ _CFFI_OP(_CFFI_OP_FUNCTION, 490), // SSL_CTX *()(SSL *, SSL_CTX *) +/* 500 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 501 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 502 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 503 */ _CFFI_OP(_CFFI_OP_FUNCTION, 490), // SSL_CTX *()(SSL_METHOD *) +/* 504 */ _CFFI_OP(_CFFI_OP_POINTER, 3115), // SSL_METHOD * +/* 505 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 506 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3114), // SSL_METHOD const *()(void) +/* 507 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 508 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1666), // SSL_SESSION *()(SSL *) +/* 509 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 510 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 511 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1666), // SSL_SESSION *()(SSL const *) +/* 512 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 513 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 514 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2873), // USERNOTICE *()(void) +/* 515 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 516 */ _CFFI_OP(_CFFI_OP_FUNCTION, 28), // X509 *()(BIO *, X509 * *) +/* 517 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 518 */ _CFFI_OP(_CFFI_OP_POINTER, 28), // X509 * * +/* 519 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 520 */ _CFFI_OP(_CFFI_OP_FUNCTION, 28), // X509 *()(BIO *, X509 * *, int(*)(char *, int, int, void *), void *) +/* 521 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 522 */ _CFFI_OP(_CFFI_OP_NOOP, 518), +/* 523 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 524 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 525 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 526 */ _CFFI_OP(_CFFI_OP_FUNCTION, 28), // X509 *()(Cryptography_STACK_OF_X509 *, int) +/* 527 */ _CFFI_OP(_CFFI_OP_NOOP, 413), +/* 528 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 529 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 530 */ _CFFI_OP(_CFFI_OP_FUNCTION, 28), // X509 *()(SSL const *) +/* 531 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 532 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 533 */ _CFFI_OP(_CFFI_OP_FUNCTION, 28), // X509 *()(X509 *) +/* 534 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 535 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 536 */ _CFFI_OP(_CFFI_OP_FUNCTION, 28), // X509 *()(X509_OBJECT *) +/* 537 */ _CFFI_OP(_CFFI_OP_POINTER, 3129), // X509_OBJECT * +/* 538 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 539 */ _CFFI_OP(_CFFI_OP_FUNCTION, 28), // X509 *()(X509_STORE_CTX *) +/* 540 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 541 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 542 */ _CFFI_OP(_CFFI_OP_FUNCTION, 28), // X509 *()(void) +/* 543 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 544 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3121), // X509_ALGOR const *()(OCSP_BASICRESP const *) +/* 545 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 546 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 547 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3121), // X509_ALGOR const *()(X509 const *) +/* 548 */ _CFFI_OP(_CFFI_OP_NOOP, 355), +/* 549 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 550 */ _CFFI_OP(_CFFI_OP_FUNCTION, 79), // X509_ATTRIBUTE *()(X509_REQ const *, int) +/* 551 */ _CFFI_OP(_CFFI_OP_POINTER, 3130), // X509_REQ const * +/* 552 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 553 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 554 */ _CFFI_OP(_CFFI_OP_FUNCTION, 57), // X509_CRL *()(BIO *, X509_CRL * *) +/* 555 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 556 */ _CFFI_OP(_CFFI_OP_POINTER, 57), // X509_CRL * * +/* 557 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 558 */ _CFFI_OP(_CFFI_OP_FUNCTION, 57), // X509_CRL *()(BIO *, X509_CRL * *, int(*)(char *, int, int, void *), void *) +/* 559 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 560 */ _CFFI_OP(_CFFI_OP_NOOP, 556), +/* 561 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 562 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 563 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 564 */ _CFFI_OP(_CFFI_OP_FUNCTION, 57), // X509_CRL *()(Cryptography_STACK_OF_X509_CRL *, int) +/* 565 */ _CFFI_OP(_CFFI_OP_POINTER, 3044), // Cryptography_STACK_OF_X509_CRL * +/* 566 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 567 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 568 */ _CFFI_OP(_CFFI_OP_FUNCTION, 57), // X509_CRL *()(X509_CRL *) +/* 569 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 570 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 571 */ _CFFI_OP(_CFFI_OP_FUNCTION, 57), // X509_CRL *()(void) +/* 572 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 573 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(CONF *, X509V3_CTX *, char *, char *) +/* 574 */ _CFFI_OP(_CFFI_OP_POINTER, 3028), // CONF * +/* 575 */ _CFFI_OP(_CFFI_OP_POINTER, 3120), // X509V3_CTX * +/* 576 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 577 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 578 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 579 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(Cryptography_LHASH_OF_CONF_VALUE *, X509V3_CTX *, int, char *) +/* 580 */ _CFFI_OP(_CFFI_OP_POINTER, 3033), // Cryptography_LHASH_OF_CONF_VALUE * +/* 581 */ _CFFI_OP(_CFFI_OP_NOOP, 575), +/* 582 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 583 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 584 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 585 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(OCSP_BASICRESP *, int) +/* 586 */ _CFFI_OP(_CFFI_OP_NOOP, 387), +/* 587 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 588 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 589 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(OCSP_REQUEST *, int) +/* 590 */ _CFFI_OP(_CFFI_OP_NOOP, 365), +/* 591 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 592 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 593 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(OCSP_SINGLERESP *, int) +/* 594 */ _CFFI_OP(_CFFI_OP_POINTER, 3086), // OCSP_SINGLERESP * +/* 595 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 596 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 597 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(X509 *, int) +/* 598 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 599 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 600 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 601 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(X509_CRL *, int) +/* 602 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 603 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 604 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 605 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(X509_EXTENSION * *, ASN1_OBJECT *, int, ASN1_OCTET_STRING *) +/* 606 */ _CFFI_OP(_CFFI_OP_POINTER, 40), // X509_EXTENSION * * +/* 607 */ _CFFI_OP(_CFFI_OP_POINTER, 3015), // ASN1_OBJECT * +/* 608 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 609 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 610 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 611 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(X509_EXTENSION *) +/* 612 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 613 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 614 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(X509_EXTENSIONS *, int) +/* 615 */ _CFFI_OP(_CFFI_OP_POINTER, 3126), // X509_EXTENSIONS * +/* 616 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 617 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 618 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(X509_REVOKED *, int) +/* 619 */ _CFFI_OP(_CFFI_OP_POINTER, 3131), // X509_REVOKED * +/* 620 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 621 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 622 */ _CFFI_OP(_CFFI_OP_FUNCTION, 40), // X509_EXTENSION *()(int, int, void *) +/* 623 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 624 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 625 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 626 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 627 */ _CFFI_OP(_CFFI_OP_FUNCTION, 615), // X509_EXTENSIONS *()(X509_REQ *) +/* 628 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 629 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 630 */ _CFFI_OP(_CFFI_OP_FUNCTION, 615), // X509_EXTENSIONS *()(void) +/* 631 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 632 */ _CFFI_OP(_CFFI_OP_FUNCTION, 643), // X509_NAME *()(Cryptography_STACK_OF_X509_NAME *, int) +/* 633 */ _CFFI_OP(_CFFI_OP_POINTER, 3045), // Cryptography_STACK_OF_X509_NAME * +/* 634 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 635 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 636 */ _CFFI_OP(_CFFI_OP_FUNCTION, 643), // X509_NAME *()(X509 *) +/* 637 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 638 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 639 */ _CFFI_OP(_CFFI_OP_FUNCTION, 643), // X509_NAME *()(X509_CRL *) +/* 640 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 641 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 642 */ _CFFI_OP(_CFFI_OP_FUNCTION, 643), // X509_NAME *()(X509_NAME *) +/* 643 */ _CFFI_OP(_CFFI_OP_POINTER, 3127), // X509_NAME * +/* 644 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 645 */ _CFFI_OP(_CFFI_OP_FUNCTION, 643), // X509_NAME *()(X509_REQ *) +/* 646 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 647 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 648 */ _CFFI_OP(_CFFI_OP_FUNCTION, 643), // X509_NAME *()(void) +/* 649 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 650 */ _CFFI_OP(_CFFI_OP_FUNCTION, 43), // X509_NAME_ENTRY *()(Cryptography_STACK_OF_X509_NAME_ENTRY *, int) +/* 651 */ _CFFI_OP(_CFFI_OP_NOOP, 175), +/* 652 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 653 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 654 */ _CFFI_OP(_CFFI_OP_FUNCTION, 43), // X509_NAME_ENTRY *()(X509_NAME *, int) +/* 655 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 656 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 657 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 658 */ _CFFI_OP(_CFFI_OP_FUNCTION, 43), // X509_NAME_ENTRY *()(X509_NAME_ENTRY * *, ASN1_OBJECT *, int, unsigned char const *, int) +/* 659 */ _CFFI_OP(_CFFI_OP_POINTER, 43), // X509_NAME_ENTRY * * +/* 660 */ _CFFI_OP(_CFFI_OP_NOOP, 607), +/* 661 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 662 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 663 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 664 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 665 */ _CFFI_OP(_CFFI_OP_FUNCTION, 537), // X509_OBJECT *()(Cryptography_STACK_OF_X509_OBJECT *, int) +/* 666 */ _CFFI_OP(_CFFI_OP_POINTER, 3047), // Cryptography_STACK_OF_X509_OBJECT * +/* 667 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 668 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 669 */ _CFFI_OP(_CFFI_OP_FUNCTION, 294), // X509_REQ *()(BIO *, X509_REQ * *) +/* 670 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 671 */ _CFFI_OP(_CFFI_OP_POINTER, 294), // X509_REQ * * +/* 672 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 673 */ _CFFI_OP(_CFFI_OP_FUNCTION, 294), // X509_REQ *()(BIO *, X509_REQ * *, int(*)(char *, int, int, void *), void *) +/* 674 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 675 */ _CFFI_OP(_CFFI_OP_NOOP, 671), +/* 676 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 677 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 678 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 679 */ _CFFI_OP(_CFFI_OP_FUNCTION, 294), // X509_REQ *()(void) +/* 680 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 681 */ _CFFI_OP(_CFFI_OP_FUNCTION, 619), // X509_REVOKED *()(Cryptography_STACK_OF_X509_REVOKED *, int) +/* 682 */ _CFFI_OP(_CFFI_OP_POINTER, 3048), // Cryptography_STACK_OF_X509_REVOKED * +/* 683 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 684 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 685 */ _CFFI_OP(_CFFI_OP_FUNCTION, 619), // X509_REVOKED *()(X509_REVOKED *) +/* 686 */ _CFFI_OP(_CFFI_OP_NOOP, 619), +/* 687 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 688 */ _CFFI_OP(_CFFI_OP_FUNCTION, 619), // X509_REVOKED *()(void) +/* 689 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 690 */ _CFFI_OP(_CFFI_OP_FUNCTION, 180), // X509_STORE *()(SSL_CTX const *) +/* 691 */ _CFFI_OP(_CFFI_OP_POINTER, 3113), // SSL_CTX const * +/* 692 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 693 */ _CFFI_OP(_CFFI_OP_FUNCTION, 180), // X509_STORE *()(void) +/* 694 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 695 */ _CFFI_OP(_CFFI_OP_FUNCTION, 160), // X509_STORE_CTX *()(void) +/* 696 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 697 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2085), // X509_VERIFY_PARAM *()(SSL *) +/* 698 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 699 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 700 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2085), // X509_VERIFY_PARAM *()(SSL_CTX *) +/* 701 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 702 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 703 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2085), // X509_VERIFY_PARAM *()(X509_STORE *) +/* 704 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 705 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 706 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2085), // X509_VERIFY_PARAM *()(X509_STORE_CTX *) +/* 707 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 708 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 709 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2085), // X509_VERIFY_PARAM *()(void) +/* 710 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 711 */ _CFFI_OP(_CFFI_OP_FUNCTION, 409), // char *()(BIGNUM const *) +/* 712 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 713 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 714 */ _CFFI_OP(_CFFI_OP_FUNCTION, 409), // char *()(NETSCAPE_SPKI *) +/* 715 */ _CFFI_OP(_CFFI_OP_NOOP, 288), +/* 716 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 717 */ _CFFI_OP(_CFFI_OP_FUNCTION, 409), // char *()(X509_NAME *, char *, int) +/* 718 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 719 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 720 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 721 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 722 */ _CFFI_OP(_CFFI_OP_FUNCTION, 46), // char const *()(ENGINE const *) +/* 723 */ _CFFI_OP(_CFFI_OP_POINTER, 3061), // ENGINE const * +/* 724 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 725 */ _CFFI_OP(_CFFI_OP_FUNCTION, 46), // char const *()(SSL const *) +/* 726 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 727 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 728 */ _CFFI_OP(_CFFI_OP_FUNCTION, 46), // char const *()(SSL const *, int) +/* 729 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 730 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 731 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 732 */ _CFFI_OP(_CFFI_OP_FUNCTION, 46), // char const *()(SSL_CIPHER const *) +/* 733 */ _CFFI_OP(_CFFI_OP_POINTER, 3112), // SSL_CIPHER const * +/* 734 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 735 */ _CFFI_OP(_CFFI_OP_FUNCTION, 46), // char const *()(int) +/* 736 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 737 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 738 */ _CFFI_OP(_CFFI_OP_FUNCTION, 46), // char const *()(long) +/* 739 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 740 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 741 */ _CFFI_OP(_CFFI_OP_FUNCTION, 46), // char const *()(unsigned long) +/* 742 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), // unsigned long +/* 743 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 744 */ _CFFI_OP(_CFFI_OP_FUNCTION, 46), // char const *()(void) +/* 745 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 746 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1646), // ct_log_entry_type_t()(SCT const *) +/* 747 */ _CFFI_OP(_CFFI_OP_POINTER, 3108), // SCT const * +/* 748 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 749 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(AES_KEY *, unsigned char const *, unsigned char *, unsigned char const *, unsigned int) +/* 750 */ _CFFI_OP(_CFFI_OP_POINTER, 3007), // AES_KEY * +/* 751 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 752 */ _CFFI_OP(_CFFI_OP_POINTER, 3140), // unsigned char * +/* 753 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 754 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), // unsigned int +/* 755 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 756 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ASN1_ENUMERATED *, long) +/* 757 */ _CFFI_OP(_CFFI_OP_POINTER, 3008), // ASN1_ENUMERATED * +/* 758 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 759 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 760 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ASN1_INTEGER *, long) +/* 761 */ _CFFI_OP(_CFFI_OP_NOOP, 21), +/* 762 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 763 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 764 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ASN1_OBJECT const *) +/* 765 */ _CFFI_OP(_CFFI_OP_POINTER, 3015), // ASN1_OBJECT const * +/* 766 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 767 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ASN1_OCTET_STRING * *, ASN1_OBJECT * *, ASN1_OCTET_STRING * *, ASN1_INTEGER * *, OCSP_CERTID *) +/* 768 */ _CFFI_OP(_CFFI_OP_POINTER, 13), // ASN1_OCTET_STRING * * +/* 769 */ _CFFI_OP(_CFFI_OP_POINTER, 607), // ASN1_OBJECT * * +/* 770 */ _CFFI_OP(_CFFI_OP_NOOP, 768), +/* 771 */ _CFFI_OP(_CFFI_OP_POINTER, 21), // ASN1_INTEGER * * +/* 772 */ _CFFI_OP(_CFFI_OP_NOOP, 366), +/* 773 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 774 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ASN1_OCTET_STRING *) +/* 775 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 776 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 777 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ASN1_OCTET_STRING *, char const *) +/* 778 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 779 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 780 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 781 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ASN1_OCTET_STRING *, int) +/* 782 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 783 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 784 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 785 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ASN1_OCTET_STRING *, int, int) +/* 786 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 787 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 788 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 789 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 790 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ASN1_OCTET_STRING *, unsigned char const *, int) +/* 791 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 792 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 793 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 794 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 795 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ASN1_OCTET_STRING *, void const *, int) +/* 796 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 797 */ _CFFI_OP(_CFFI_OP_NOOP, 126), +/* 798 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 799 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 800 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ASN1_TYPE *, unsigned char * *) +/* 801 */ _CFFI_OP(_CFFI_OP_POINTER, 3018), // ASN1_TYPE * +/* 802 */ _CFFI_OP(_CFFI_OP_POINTER, 752), // unsigned char * * +/* 803 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 804 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM * *, char const *) +/* 805 */ _CFFI_OP(_CFFI_OP_POINTER, 20), // BIGNUM * * +/* 806 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 807 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 808 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM *, BIGNUM const *) +/* 809 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 810 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 811 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 812 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM *, BIGNUM const *, BIGNUM const *) +/* 813 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 814 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 815 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 816 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 817 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM *, BIGNUM const *, BIGNUM const *, BIGNUM const *, BN_CTX *) +/* 818 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 819 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 820 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 821 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 822 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 823 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 824 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM *, BIGNUM const *, BIGNUM const *, BIGNUM const *, BN_CTX *, BN_MONT_CTX *) +/* 825 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 826 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 827 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 828 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 829 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 830 */ _CFFI_OP(_CFFI_OP_POINTER, 3026), // BN_MONT_CTX * +/* 831 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 832 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM *, BIGNUM const *, BIGNUM const *, BN_CTX *) +/* 833 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 834 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 835 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 836 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 837 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 838 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM *, BN_ULONG) +/* 839 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 840 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, _cffi_prim_int(sizeof(BN_ULONG), ( + ((BN_ULONG)-1) | 0 /* check that BN_ULONG is an integer type */ + ) <= 0)), // BN_ULONG +/* 841 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 842 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM *, int, int, BIGNUM const *, BIGNUM const *, BN_GENCB *) +/* 843 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 844 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 845 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 846 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 847 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 848 */ _CFFI_OP(_CFFI_OP_POINTER, 3025), // BN_GENCB * +/* 849 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 850 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM const *) +/* 851 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 852 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 853 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM const *, BIGNUM const *) +/* 854 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 855 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 856 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 857 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM const *, int, BN_CTX *, BN_GENCB *) +/* 858 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 859 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 860 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 861 */ _CFFI_OP(_CFFI_OP_NOOP, 848), +/* 862 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 863 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIGNUM const *, unsigned char *) +/* 864 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 865 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 866 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 867 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *) +/* 868 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 869 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 870 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, ASN1_INTEGER *) +/* 871 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 872 */ _CFFI_OP(_CFFI_OP_NOOP, 21), +/* 873 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 874 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, DH *) +/* 875 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 876 */ _CFFI_OP(_CFFI_OP_NOOP, 196), +/* 877 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 878 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, DSA *) +/* 879 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 880 */ _CFFI_OP(_CFFI_OP_NOOP, 212), +/* 881 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 882 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, DSA *, EVP_CIPHER const *, unsigned char *, int, int(*)(char *, int, int, void *), void *) +/* 883 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 884 */ _CFFI_OP(_CFFI_OP_NOOP, 212), +/* 885 */ _CFFI_OP(_CFFI_OP_POINTER, 3062), // EVP_CIPHER const * +/* 886 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 887 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 888 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 889 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 890 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 891 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, EC_KEY *) +/* 892 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 893 */ _CFFI_OP(_CFFI_OP_POINTER, 3055), // EC_KEY * +/* 894 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 895 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, EC_KEY *, EVP_CIPHER const *, unsigned char *, int, int(*)(char *, int, int, void *), void *) +/* 896 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 897 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 898 */ _CFFI_OP(_CFFI_OP_NOOP, 885), +/* 899 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 900 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 901 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 902 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 903 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 904 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, EVP_PKEY *) +/* 905 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 906 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 907 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 908 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, EVP_PKEY *, EVP_CIPHER const *, char *, int, int(*)(char *, int, int, void *), void *) +/* 909 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 910 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 911 */ _CFFI_OP(_CFFI_OP_NOOP, 885), +/* 912 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 913 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 914 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 915 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 916 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 917 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, EVP_PKEY *, EVP_CIPHER const *, unsigned char *, int, int(*)(char *, int, int, void *), void *) +/* 918 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 919 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 920 */ _CFFI_OP(_CFFI_OP_NOOP, 885), +/* 921 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 922 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 923 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 924 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 925 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 926 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, GENERAL_NAME *) +/* 927 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 928 */ _CFFI_OP(_CFFI_OP_POINTER, 3069), // GENERAL_NAME * +/* 929 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 930 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, OCSP_REQUEST *) +/* 931 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 932 */ _CFFI_OP(_CFFI_OP_NOOP, 365), +/* 933 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 934 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, OCSP_RESPONSE *) +/* 935 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 936 */ _CFFI_OP(_CFFI_OP_NOOP, 349), +/* 937 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 938 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, PKCS12 *) +/* 939 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 940 */ _CFFI_OP(_CFFI_OP_POINTER, 3088), // PKCS12 * +/* 941 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 942 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, PKCS7 *) +/* 943 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 944 */ _CFFI_OP(_CFFI_OP_NOOP, 442), +/* 945 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 946 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, PKCS7 *, BIO *, int) +/* 947 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 948 */ _CFFI_OP(_CFFI_OP_NOOP, 442), +/* 949 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 950 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 951 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 952 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, RSA *) +/* 953 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 954 */ _CFFI_OP(_CFFI_OP_NOOP, 476), +/* 955 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 956 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, RSA *, EVP_CIPHER const *, unsigned char *, int, int(*)(char *, int, int, void *), void *) +/* 957 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 958 */ _CFFI_OP(_CFFI_OP_NOOP, 476), +/* 959 */ _CFFI_OP(_CFFI_OP_NOOP, 885), +/* 960 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 961 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 962 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 963 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 964 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 965 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, RSA const *) +/* 966 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 967 */ _CFFI_OP(_CFFI_OP_POINTER, 3107), // RSA const * +/* 968 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 969 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, RSA const *, int) +/* 970 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 971 */ _CFFI_OP(_CFFI_OP_NOOP, 967), +/* 972 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 973 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 974 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, X509 *) +/* 975 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 976 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 977 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 978 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, X509 *, unsigned long, unsigned long) +/* 979 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 980 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 981 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 982 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 983 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 984 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, X509_CRL *) +/* 985 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 986 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 987 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 988 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, X509_EXTENSION *, unsigned long, int) +/* 989 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 990 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 991 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 992 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 993 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 994 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, X509_NAME *, int, unsigned long) +/* 995 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 996 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 997 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 998 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 999 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1000 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, X509_REQ *) +/* 1001 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 1002 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 1003 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1004 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, X509_REQ *, unsigned long, unsigned long) +/* 1005 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 1006 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 1007 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 1008 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 1009 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1010 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, char *, int) +/* 1011 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 1012 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 1013 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1014 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1015 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, void *, int) +/* 1016 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 1017 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1018 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1019 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1020 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BIO *, void const *, int) +/* 1021 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 1022 */ _CFFI_OP(_CFFI_OP_NOOP, 126), +/* 1023 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1024 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1025 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(BN_MONT_CTX *, BIGNUM const *, BN_CTX *) +/* 1026 */ _CFFI_OP(_CFFI_OP_NOOP, 830), +/* 1027 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 1028 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1029 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1030 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(CMAC_CTX *, CMAC_CTX const *) +/* 1031 */ _CFFI_OP(_CFFI_OP_POINTER, 3027), // CMAC_CTX * +/* 1032 */ _CFFI_OP(_CFFI_OP_POINTER, 3027), // CMAC_CTX const * +/* 1033 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1034 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(CMAC_CTX *, unsigned char *, size_t *) +/* 1035 */ _CFFI_OP(_CFFI_OP_NOOP, 1031), +/* 1036 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1037 */ _CFFI_OP(_CFFI_OP_POINTER, 300), // size_t * +/* 1038 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1039 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(CMAC_CTX *, void const *, size_t) +/* 1040 */ _CFFI_OP(_CFFI_OP_NOOP, 1031), +/* 1041 */ _CFFI_OP(_CFFI_OP_NOOP, 126), +/* 1042 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1043 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1044 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(CMAC_CTX *, void const *, size_t, EVP_CIPHER const *, ENGINE *) +/* 1045 */ _CFFI_OP(_CFFI_OP_NOOP, 1031), +/* 1046 */ _CFFI_OP(_CFFI_OP_NOOP, 126), +/* 1047 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1048 */ _CFFI_OP(_CFFI_OP_NOOP, 885), +/* 1049 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 1050 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1051 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_ACCESS_DESCRIPTION *) +/* 1052 */ _CFFI_OP(_CFFI_OP_NOOP, 1), +/* 1053 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1054 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_ACCESS_DESCRIPTION *, ACCESS_DESCRIPTION *) +/* 1055 */ _CFFI_OP(_CFFI_OP_NOOP, 1), +/* 1056 */ _CFFI_OP(_CFFI_OP_POINTER, 3006), // ACCESS_DESCRIPTION * +/* 1057 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1058 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_ASN1_INTEGER *) +/* 1059 */ _CFFI_OP(_CFFI_OP_NOOP, 24), +/* 1060 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1061 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_ASN1_INTEGER *, ASN1_INTEGER *) +/* 1062 */ _CFFI_OP(_CFFI_OP_NOOP, 24), +/* 1063 */ _CFFI_OP(_CFFI_OP_NOOP, 21), +/* 1064 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1065 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_ASN1_OBJECT *) +/* 1066 */ _CFFI_OP(_CFFI_OP_NOOP, 36), +/* 1067 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1068 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_ASN1_OBJECT *, ASN1_OBJECT *) +/* 1069 */ _CFFI_OP(_CFFI_OP_NOOP, 36), +/* 1070 */ _CFFI_OP(_CFFI_OP_NOOP, 607), +/* 1071 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1072 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_DIST_POINT *) +/* 1073 */ _CFFI_OP(_CFFI_OP_NOOP, 204), +/* 1074 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1075 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_DIST_POINT *, DIST_POINT *) +/* 1076 */ _CFFI_OP(_CFFI_OP_NOOP, 204), +/* 1077 */ _CFFI_OP(_CFFI_OP_POINTER, 3050), // DIST_POINT * +/* 1078 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1079 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_GENERAL_SUBTREE *) +/* 1080 */ _CFFI_OP(_CFFI_OP_NOOP, 329), +/* 1081 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1082 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_GENERAL_SUBTREE *, GENERAL_SUBTREE *) +/* 1083 */ _CFFI_OP(_CFFI_OP_NOOP, 329), +/* 1084 */ _CFFI_OP(_CFFI_OP_POINTER, 3071), // GENERAL_SUBTREE * +/* 1085 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1086 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_POLICYINFO *) +/* 1087 */ _CFFI_OP(_CFFI_OP_NOOP, 449), +/* 1088 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1089 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_POLICYINFO *, POLICYINFO *) +/* 1090 */ _CFFI_OP(_CFFI_OP_NOOP, 449), +/* 1091 */ _CFFI_OP(_CFFI_OP_POINTER, 3103), // POLICYINFO * +/* 1092 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1093 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_POLICYQUALINFO *) +/* 1094 */ _CFFI_OP(_CFFI_OP_NOOP, 455), +/* 1095 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1096 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_POLICYQUALINFO *, POLICYQUALINFO *) +/* 1097 */ _CFFI_OP(_CFFI_OP_NOOP, 455), +/* 1098 */ _CFFI_OP(_CFFI_OP_POINTER, 3104), // POLICYQUALINFO * +/* 1099 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1100 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_SCT *, SCT *) +/* 1101 */ _CFFI_OP(_CFFI_OP_POINTER, 3041), // Cryptography_STACK_OF_SCT * +/* 1102 */ _CFFI_OP(_CFFI_OP_POINTER, 3108), // SCT * +/* 1103 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1104 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_SCT const *) +/* 1105 */ _CFFI_OP(_CFFI_OP_NOOP, 481), +/* 1106 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1107 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_SSL_CIPHER *) +/* 1108 */ _CFFI_OP(_CFFI_OP_NOOP, 493), +/* 1109 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1110 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_X509 *) +/* 1111 */ _CFFI_OP(_CFFI_OP_NOOP, 413), +/* 1112 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1113 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_X509 *, X509 *) +/* 1114 */ _CFFI_OP(_CFFI_OP_NOOP, 413), +/* 1115 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1116 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1117 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_X509_CRL *) +/* 1118 */ _CFFI_OP(_CFFI_OP_NOOP, 565), +/* 1119 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1120 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_X509_CRL *, X509_CRL *) +/* 1121 */ _CFFI_OP(_CFFI_OP_NOOP, 565), +/* 1122 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 1123 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1124 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_X509_NAME *) +/* 1125 */ _CFFI_OP(_CFFI_OP_NOOP, 633), +/* 1126 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1127 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_X509_NAME *, X509_NAME *) +/* 1128 */ _CFFI_OP(_CFFI_OP_NOOP, 633), +/* 1129 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 1130 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1131 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_X509_NAME_ENTRY *) +/* 1132 */ _CFFI_OP(_CFFI_OP_NOOP, 175), +/* 1133 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1134 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_X509_NAME_ENTRY *, X509_NAME_ENTRY *) +/* 1135 */ _CFFI_OP(_CFFI_OP_NOOP, 175), +/* 1136 */ _CFFI_OP(_CFFI_OP_NOOP, 43), +/* 1137 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1138 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_X509_OBJECT *) +/* 1139 */ _CFFI_OP(_CFFI_OP_NOOP, 666), +/* 1140 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1141 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(Cryptography_STACK_OF_X509_REVOKED *) +/* 1142 */ _CFFI_OP(_CFFI_OP_NOOP, 682), +/* 1143 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1144 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(DH *) +/* 1145 */ _CFFI_OP(_CFFI_OP_NOOP, 196), +/* 1146 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1147 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(DH *, BIGNUM *, BIGNUM *) +/* 1148 */ _CFFI_OP(_CFFI_OP_NOOP, 196), +/* 1149 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1150 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1151 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1152 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(DH *, BIGNUM *, BIGNUM *, BIGNUM *) +/* 1153 */ _CFFI_OP(_CFFI_OP_NOOP, 196), +/* 1154 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1155 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1156 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1157 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1158 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(DH *, int, int, BN_GENCB *) +/* 1159 */ _CFFI_OP(_CFFI_OP_NOOP, 196), +/* 1160 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1161 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1162 */ _CFFI_OP(_CFFI_OP_NOOP, 848), +/* 1163 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1164 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(DH const *) +/* 1165 */ _CFFI_OP(_CFFI_OP_POINTER, 3049), // DH const * +/* 1166 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1167 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(DH const *, int *) +/* 1168 */ _CFFI_OP(_CFFI_OP_NOOP, 1165), +/* 1169 */ _CFFI_OP(_CFFI_OP_POINTER, 2), // int * +/* 1170 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1171 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(DSA *) +/* 1172 */ _CFFI_OP(_CFFI_OP_NOOP, 212), +/* 1173 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1174 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(DSA *, BIGNUM *, BIGNUM *) +/* 1175 */ _CFFI_OP(_CFFI_OP_NOOP, 212), +/* 1176 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1177 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1178 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1179 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(DSA *, BIGNUM *, BIGNUM *, BIGNUM *) +/* 1180 */ _CFFI_OP(_CFFI_OP_NOOP, 212), +/* 1181 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1182 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1183 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1184 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1185 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(DSA *, int, unsigned char *, int, int *, unsigned long *, BN_GENCB *) +/* 1186 */ _CFFI_OP(_CFFI_OP_NOOP, 212), +/* 1187 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1188 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1189 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1190 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 1191 */ _CFFI_OP(_CFFI_OP_POINTER, 742), // unsigned long * +/* 1192 */ _CFFI_OP(_CFFI_OP_NOOP, 848), +/* 1193 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1194 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(DSA const *) +/* 1195 */ _CFFI_OP(_CFFI_OP_POINTER, 3052), // DSA const * +/* 1196 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1197 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *) +/* 1198 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1199 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1200 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, BIGNUM *, BN_CTX *) +/* 1201 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1202 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1203 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1204 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1205 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, EC_POINT *, BIGNUM const *, BIGNUM const *, BN_CTX *) +/* 1206 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1207 */ _CFFI_OP(_CFFI_OP_POINTER, 3057), // EC_POINT * +/* 1208 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 1209 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 1210 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1211 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1212 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, EC_POINT *, BIGNUM const *, EC_POINT const *, BIGNUM const *, BN_CTX *) +/* 1213 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1214 */ _CFFI_OP(_CFFI_OP_NOOP, 1207), +/* 1215 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 1216 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 1217 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 1218 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1219 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1220 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, EC_POINT *, BIGNUM const *, int, BN_CTX *) +/* 1221 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1222 */ _CFFI_OP(_CFFI_OP_NOOP, 1207), +/* 1223 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 1224 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1225 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1226 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1227 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, EC_POINT *, BN_CTX *) +/* 1228 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1229 */ _CFFI_OP(_CFFI_OP_NOOP, 1207), +/* 1230 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1231 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1232 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, EC_POINT *, EC_POINT const *, BN_CTX *) +/* 1233 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1234 */ _CFFI_OP(_CFFI_OP_NOOP, 1207), +/* 1235 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 1236 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1237 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1238 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, EC_POINT *, EC_POINT const *, EC_POINT const *, BN_CTX *) +/* 1239 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1240 */ _CFFI_OP(_CFFI_OP_NOOP, 1207), +/* 1241 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 1242 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 1243 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1244 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1245 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, EC_POINT *, unsigned char const *, size_t, BN_CTX *) +/* 1246 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1247 */ _CFFI_OP(_CFFI_OP_NOOP, 1207), +/* 1248 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1249 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1250 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1251 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1252 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, EC_POINT const *) +/* 1253 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1254 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 1255 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1256 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, EC_POINT const *, BIGNUM *, BIGNUM *, BN_CTX *) +/* 1257 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1258 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 1259 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1260 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1261 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1262 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1263 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, EC_POINT const *, BN_CTX *) +/* 1264 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1265 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 1266 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1267 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1268 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_GROUP const *, EC_POINT const *, EC_POINT const *, BN_CTX *) +/* 1269 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1270 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 1271 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 1272 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1273 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1274 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_KEY *) +/* 1275 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 1276 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1277 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_KEY *, BIGNUM *, BIGNUM *) +/* 1278 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 1279 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1280 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1281 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1282 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_KEY *, BIGNUM const *) +/* 1283 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 1284 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 1285 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1286 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_KEY *, EC_GROUP const *) +/* 1287 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 1288 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 1289 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1290 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_KEY *, EC_POINT const *) +/* 1291 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 1292 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 1293 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1294 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_KEY const *) +/* 1295 */ _CFFI_OP(_CFFI_OP_NOOP, 110), +/* 1296 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1297 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EC_METHOD const *) +/* 1298 */ _CFFI_OP(_CFFI_OP_POINTER, 3056), // EC_METHOD const * +/* 1299 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1300 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ENGINE *) +/* 1301 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 1302 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1303 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ENGINE *, char const *, char const *, int) +/* 1304 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 1305 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 1306 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 1307 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1308 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1309 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(ENGINE *, char const *, long, void *, void(*)(void), int) +/* 1310 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 1311 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 1312 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 1313 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1314 */ _CFFI_OP(_CFFI_OP_POINTER, 2998), // void(*)(void) +/* 1315 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1316 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1317 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_CIPHER_CTX *) +/* 1318 */ _CFFI_OP(_CFFI_OP_POINTER, 3063), // EVP_CIPHER_CTX * +/* 1319 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1320 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_CIPHER_CTX *, EVP_CIPHER const *, ENGINE *, unsigned char const *, unsigned char const *, int) +/* 1321 */ _CFFI_OP(_CFFI_OP_NOOP, 1318), +/* 1322 */ _CFFI_OP(_CFFI_OP_NOOP, 885), +/* 1323 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 1324 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1325 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1326 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1327 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1328 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_CIPHER_CTX *, int) +/* 1329 */ _CFFI_OP(_CFFI_OP_NOOP, 1318), +/* 1330 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1331 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1332 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_CIPHER_CTX *, int, int, void *) +/* 1333 */ _CFFI_OP(_CFFI_OP_NOOP, 1318), +/* 1334 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1335 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1336 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1337 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1338 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_CIPHER_CTX *, unsigned char *, int *) +/* 1339 */ _CFFI_OP(_CFFI_OP_NOOP, 1318), +/* 1340 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1341 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 1342 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1343 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_CIPHER_CTX *, unsigned char *, int *, unsigned char const *, int) +/* 1344 */ _CFFI_OP(_CFFI_OP_NOOP, 1318), +/* 1345 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1346 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 1347 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1348 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1349 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1350 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, EVP_MD const *) +/* 1351 */ _CFFI_OP(_CFFI_OP_POINTER, 3065), // EVP_MD_CTX * +/* 1352 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 1353 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1354 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, EVP_MD const *, ENGINE *) +/* 1355 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 1356 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 1357 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 1358 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1359 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, EVP_MD_CTX const *) +/* 1360 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 1361 */ _CFFI_OP(_CFFI_OP_POINTER, 3065), // EVP_MD_CTX const * +/* 1362 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1363 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, EVP_PKEY_CTX * *, EVP_MD const *, ENGINE *, EVP_PKEY *) +/* 1364 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 1365 */ _CFFI_OP(_CFFI_OP_POINTER, 309), // EVP_PKEY_CTX * * +/* 1366 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 1367 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 1368 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1369 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1370 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, unsigned char *, size_t *) +/* 1371 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 1372 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1373 */ _CFFI_OP(_CFFI_OP_NOOP, 1037), +/* 1374 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1375 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, unsigned char *, size_t *, unsigned char const *, size_t) +/* 1376 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 1377 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1378 */ _CFFI_OP(_CFFI_OP_NOOP, 1037), +/* 1379 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1380 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1381 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1382 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, unsigned char *, size_t) +/* 1383 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 1384 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1385 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1386 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1387 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, unsigned char *, unsigned int *) +/* 1388 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 1389 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1390 */ _CFFI_OP(_CFFI_OP_POINTER, 754), // unsigned int * +/* 1391 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1392 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, unsigned char *, unsigned int *, EVP_PKEY *) +/* 1393 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 1394 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1395 */ _CFFI_OP(_CFFI_OP_NOOP, 1390), +/* 1396 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1397 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1398 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, unsigned char const *, size_t, unsigned char const *, size_t) +/* 1399 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 1400 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1401 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1402 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1403 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1404 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1405 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, unsigned char const *, unsigned int, EVP_PKEY *) +/* 1406 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 1407 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1408 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 1409 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1410 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1411 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_MD_CTX *, void const *, size_t) +/* 1412 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 1413 */ _CFFI_OP(_CFFI_OP_NOOP, 126), +/* 1414 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1415 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1416 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY *) +/* 1417 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1418 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1419 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY *, DH *) +/* 1420 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1421 */ _CFFI_OP(_CFFI_OP_NOOP, 196), +/* 1422 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1423 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY *, DSA *) +/* 1424 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1425 */ _CFFI_OP(_CFFI_OP_NOOP, 212), +/* 1426 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1427 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY *, EC_KEY *) +/* 1428 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1429 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 1430 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1431 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY *, RSA *) +/* 1432 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1433 */ _CFFI_OP(_CFFI_OP_NOOP, 476), +/* 1434 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1435 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY *, int) +/* 1436 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1437 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1438 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1439 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY *, unsigned char const *, size_t) +/* 1440 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1441 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1442 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1443 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1444 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY const *) +/* 1445 */ _CFFI_OP(_CFFI_OP_POINTER, 3066), // EVP_PKEY const * +/* 1446 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1447 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY const *, EVP_PKEY const *) +/* 1448 */ _CFFI_OP(_CFFI_OP_NOOP, 1445), +/* 1449 */ _CFFI_OP(_CFFI_OP_NOOP, 1445), +/* 1450 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1451 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY const *, unsigned char *, size_t *) +/* 1452 */ _CFFI_OP(_CFFI_OP_NOOP, 1445), +/* 1453 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1454 */ _CFFI_OP(_CFFI_OP_NOOP, 1037), +/* 1455 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1456 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY_CTX *) +/* 1457 */ _CFFI_OP(_CFFI_OP_NOOP, 309), +/* 1458 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1459 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY_CTX *, EVP_MD *) +/* 1460 */ _CFFI_OP(_CFFI_OP_NOOP, 309), +/* 1461 */ _CFFI_OP(_CFFI_OP_POINTER, 3064), // EVP_MD * +/* 1462 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1463 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY_CTX *, EVP_MD const *) +/* 1464 */ _CFFI_OP(_CFFI_OP_NOOP, 309), +/* 1465 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 1466 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1467 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY_CTX *, EVP_PKEY * *) +/* 1468 */ _CFFI_OP(_CFFI_OP_NOOP, 309), +/* 1469 */ _CFFI_OP(_CFFI_OP_NOOP, 273), +/* 1470 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1471 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY_CTX *, EVP_PKEY *) +/* 1472 */ _CFFI_OP(_CFFI_OP_NOOP, 309), +/* 1473 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1474 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1475 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY_CTX *, int) +/* 1476 */ _CFFI_OP(_CFFI_OP_NOOP, 309), +/* 1477 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1478 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1479 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY_CTX *, unsigned char *, int) +/* 1480 */ _CFFI_OP(_CFFI_OP_NOOP, 309), +/* 1481 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1482 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1483 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1484 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY_CTX *, unsigned char *, size_t *) +/* 1485 */ _CFFI_OP(_CFFI_OP_NOOP, 309), +/* 1486 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1487 */ _CFFI_OP(_CFFI_OP_NOOP, 1037), +/* 1488 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1489 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY_CTX *, unsigned char *, size_t *, unsigned char const *, size_t) +/* 1490 */ _CFFI_OP(_CFFI_OP_NOOP, 309), +/* 1491 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1492 */ _CFFI_OP(_CFFI_OP_NOOP, 1037), +/* 1493 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1494 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1495 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1496 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(EVP_PKEY_CTX *, unsigned char const *, size_t, unsigned char const *, size_t) +/* 1497 */ _CFFI_OP(_CFFI_OP_NOOP, 309), +/* 1498 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1499 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1500 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1501 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1502 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1503 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(GENERAL_NAMES *) +/* 1504 */ _CFFI_OP(_CFFI_OP_NOOP, 316), +/* 1505 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1506 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(GENERAL_NAMES *, GENERAL_NAME *) +/* 1507 */ _CFFI_OP(_CFFI_OP_NOOP, 316), +/* 1508 */ _CFFI_OP(_CFFI_OP_NOOP, 928), +/* 1509 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1510 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(GENERAL_NAMES *, unsigned char * *) +/* 1511 */ _CFFI_OP(_CFFI_OP_NOOP, 316), +/* 1512 */ _CFFI_OP(_CFFI_OP_NOOP, 802), +/* 1513 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1514 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(HMAC_CTX *, HMAC_CTX *) +/* 1515 */ _CFFI_OP(_CFFI_OP_POINTER, 3072), // HMAC_CTX * +/* 1516 */ _CFFI_OP(_CFFI_OP_NOOP, 1515), +/* 1517 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1518 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(HMAC_CTX *, unsigned char *, unsigned int *) +/* 1519 */ _CFFI_OP(_CFFI_OP_NOOP, 1515), +/* 1520 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1521 */ _CFFI_OP(_CFFI_OP_NOOP, 1390), +/* 1522 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1523 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(HMAC_CTX *, unsigned char const *, size_t) +/* 1524 */ _CFFI_OP(_CFFI_OP_NOOP, 1515), +/* 1525 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1526 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1527 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1528 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(HMAC_CTX *, void const *, int, EVP_MD const *, ENGINE *) +/* 1529 */ _CFFI_OP(_CFFI_OP_NOOP, 1515), +/* 1530 */ _CFFI_OP(_CFFI_OP_NOOP, 126), +/* 1531 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1532 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 1533 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 1534 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1535 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(NETSCAPE_SPKI *, EVP_PKEY *) +/* 1536 */ _CFFI_OP(_CFFI_OP_NOOP, 288), +/* 1537 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1538 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1539 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(NETSCAPE_SPKI *, EVP_PKEY *, EVP_MD const *) +/* 1540 */ _CFFI_OP(_CFFI_OP_NOOP, 288), +/* 1541 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1542 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 1543 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1544 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(OCSP_BASICRESP *) +/* 1545 */ _CFFI_OP(_CFFI_OP_NOOP, 387), +/* 1546 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1547 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(OCSP_BASICRESP *, X509 *) +/* 1548 */ _CFFI_OP(_CFFI_OP_NOOP, 387), +/* 1549 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1550 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1551 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(OCSP_BASICRESP *, X509 *, EVP_PKEY *, EVP_MD const *, Cryptography_STACK_OF_X509 *, unsigned long) +/* 1552 */ _CFFI_OP(_CFFI_OP_NOOP, 387), +/* 1553 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1554 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1555 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 1556 */ _CFFI_OP(_CFFI_OP_NOOP, 413), +/* 1557 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 1558 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1559 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(OCSP_BASICRESP *, X509_EXTENSION *, int) +/* 1560 */ _CFFI_OP(_CFFI_OP_NOOP, 387), +/* 1561 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 1562 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1563 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1564 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(OCSP_BASICRESP const *, ASN1_OCTET_STRING const * *, X509_NAME const * *) +/* 1565 */ _CFFI_OP(_CFFI_OP_NOOP, 17), +/* 1566 */ _CFFI_OP(_CFFI_OP_POINTER, 3016), // ASN1_OCTET_STRING const * * +/* 1567 */ _CFFI_OP(_CFFI_OP_POINTER, 2003), // X509_NAME const * * +/* 1568 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1569 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(OCSP_REQUEST *) +/* 1570 */ _CFFI_OP(_CFFI_OP_NOOP, 365), +/* 1571 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1572 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(OCSP_REQUEST *, X509_EXTENSION *, int) +/* 1573 */ _CFFI_OP(_CFFI_OP_NOOP, 365), +/* 1574 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 1575 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1576 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1577 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(OCSP_RESPDATA *, unsigned char * *) +/* 1578 */ _CFFI_OP(_CFFI_OP_POINTER, 3084), // OCSP_RESPDATA * +/* 1579 */ _CFFI_OP(_CFFI_OP_NOOP, 802), +/* 1580 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1581 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(OCSP_RESPONSE *) +/* 1582 */ _CFFI_OP(_CFFI_OP_NOOP, 349), +/* 1583 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1584 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(OCSP_SINGLERESP *) +/* 1585 */ _CFFI_OP(_CFFI_OP_NOOP, 594), +/* 1586 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1587 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(OCSP_SINGLERESP *, int *, ASN1_GENERALIZEDTIME * *, ASN1_GENERALIZEDTIME * *, ASN1_GENERALIZEDTIME * *) +/* 1588 */ _CFFI_OP(_CFFI_OP_NOOP, 594), +/* 1589 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 1590 */ _CFFI_OP(_CFFI_OP_NOOP, 14), +/* 1591 */ _CFFI_OP(_CFFI_OP_NOOP, 14), +/* 1592 */ _CFFI_OP(_CFFI_OP_NOOP, 14), +/* 1593 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1594 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(PKCS12 *, char const *, EVP_PKEY * *, X509 * *, Cryptography_STACK_OF_X509 * *) +/* 1595 */ _CFFI_OP(_CFFI_OP_NOOP, 940), +/* 1596 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 1597 */ _CFFI_OP(_CFFI_OP_NOOP, 273), +/* 1598 */ _CFFI_OP(_CFFI_OP_NOOP, 518), +/* 1599 */ _CFFI_OP(_CFFI_OP_POINTER, 413), // Cryptography_STACK_OF_X509 * * +/* 1600 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1601 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(PKCS7 *) +/* 1602 */ _CFFI_OP(_CFFI_OP_NOOP, 442), +/* 1603 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1604 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(PKCS7 *, BIO *, int) +/* 1605 */ _CFFI_OP(_CFFI_OP_NOOP, 442), +/* 1606 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 1607 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1608 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1609 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(PKCS7 *, Cryptography_STACK_OF_X509 *, X509_STORE *, BIO *, BIO *, int) +/* 1610 */ _CFFI_OP(_CFFI_OP_NOOP, 442), +/* 1611 */ _CFFI_OP(_CFFI_OP_NOOP, 413), +/* 1612 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 1613 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 1614 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 1615 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1616 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1617 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(RAND_METHOD const *) +/* 1618 */ _CFFI_OP(_CFFI_OP_POINTER, 3106), // RAND_METHOD const * +/* 1619 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1620 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(RSA *, BIGNUM *, BIGNUM *) +/* 1621 */ _CFFI_OP(_CFFI_OP_NOOP, 476), +/* 1622 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1623 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1624 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1625 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(RSA *, BIGNUM *, BIGNUM *, BIGNUM *) +/* 1626 */ _CFFI_OP(_CFFI_OP_NOOP, 476), +/* 1627 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1628 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1629 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1630 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1631 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(RSA *, BN_CTX *) +/* 1632 */ _CFFI_OP(_CFFI_OP_NOOP, 476), +/* 1633 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 1634 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1635 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(RSA *, int, BIGNUM *, BN_GENCB *) +/* 1636 */ _CFFI_OP(_CFFI_OP_NOOP, 476), +/* 1637 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1638 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 1639 */ _CFFI_OP(_CFFI_OP_NOOP, 848), +/* 1640 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1641 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(RSA const *) +/* 1642 */ _CFFI_OP(_CFFI_OP_NOOP, 967), +/* 1643 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1644 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SCT *, ct_log_entry_type_t) +/* 1645 */ _CFFI_OP(_CFFI_OP_NOOP, 1102), +/* 1646 */ _CFFI_OP(_CFFI_OP_ENUM, 0), // ct_log_entry_type_t +/* 1647 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1648 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SCT *, sct_source_t) +/* 1649 */ _CFFI_OP(_CFFI_OP_NOOP, 1102), +/* 1650 */ _CFFI_OP(_CFFI_OP_ENUM, 2), // sct_source_t +/* 1651 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1652 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SCT *, sct_version_t) +/* 1653 */ _CFFI_OP(_CFFI_OP_NOOP, 1102), +/* 1654 */ _CFFI_OP(_CFFI_OP_ENUM, 3), // sct_version_t +/* 1655 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1656 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SCT *, unsigned char *, size_t) +/* 1657 */ _CFFI_OP(_CFFI_OP_NOOP, 1102), +/* 1658 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1659 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1660 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1661 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *) +/* 1662 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1663 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1664 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, SSL_SESSION *) +/* 1665 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1666 */ _CFFI_OP(_CFFI_OP_POINTER, 3116), // SSL_SESSION * +/* 1667 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1668 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, char const *) +/* 1669 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1670 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 1671 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1672 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, int *, void *) +/* 1673 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1674 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 1675 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1676 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1677 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, int) +/* 1678 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1679 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1680 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1681 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, int, int *, int *, int *, unsigned char *, unsigned char *) +/* 1682 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1683 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1684 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 1685 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 1686 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 1687 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1688 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1689 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1690 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, int, void *) +/* 1691 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1692 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1693 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1694 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1695 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, unsigned char *, size_t, char const *, size_t, unsigned char const *, size_t, int) +/* 1696 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1697 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1698 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1699 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 1700 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1701 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1702 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1703 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1704 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1705 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, unsigned char *, unsigned int *) +/* 1706 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1707 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1708 */ _CFFI_OP(_CFFI_OP_NOOP, 1390), +/* 1709 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1710 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, unsigned char const * *, unsigned char *, unsigned char const *, unsigned int, void *) +/* 1711 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1712 */ _CFFI_OP(_CFFI_OP_NOOP, 75), +/* 1713 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1714 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1715 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 1716 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1717 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1718 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, unsigned char const *, unsigned int) +/* 1719 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1720 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1721 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 1722 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1723 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, unsigned int, unsigned char const * *, size_t *, int *, void *) +/* 1724 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1725 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 1726 */ _CFFI_OP(_CFFI_OP_NOOP, 75), +/* 1727 */ _CFFI_OP(_CFFI_OP_NOOP, 1037), +/* 1728 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 1729 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1730 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1731 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, unsigned int, unsigned char const *, size_t, int *, void *) +/* 1732 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1733 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 1734 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1735 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1736 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 1737 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1738 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1739 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, void *) +/* 1740 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1741 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1742 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1743 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, void *, int) +/* 1744 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1745 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1746 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1747 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1748 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, void *, size_t, size_t *) +/* 1749 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1750 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1751 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1752 */ _CFFI_OP(_CFFI_OP_NOOP, 1037), +/* 1753 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1754 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, void const *, int) +/* 1755 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1756 */ _CFFI_OP(_CFFI_OP_NOOP, 126), +/* 1757 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1758 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1759 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL *, void const *, size_t, size_t *) +/* 1760 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 1761 */ _CFFI_OP(_CFFI_OP_NOOP, 126), +/* 1762 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 1763 */ _CFFI_OP(_CFFI_OP_NOOP, 1037), +/* 1764 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1765 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL const *) +/* 1766 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 1767 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1768 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL const *, int) +/* 1769 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 1770 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1771 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1772 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CIPHER const *) +/* 1773 */ _CFFI_OP(_CFFI_OP_NOOP, 733), +/* 1774 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1775 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CIPHER const *, int *) +/* 1776 */ _CFFI_OP(_CFFI_OP_NOOP, 733), +/* 1777 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 1778 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1779 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CTX *) +/* 1780 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 1781 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1782 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CTX *, EVP_PKEY *) +/* 1783 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 1784 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1785 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1786 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CTX *, X509 *) +/* 1787 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 1788 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1789 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1790 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CTX *, char const *) +/* 1791 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 1792 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 1793 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1794 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CTX *, char const *, char const *) +/* 1795 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 1796 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 1797 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 1798 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1799 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CTX *, char const *, int) +/* 1800 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 1801 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 1802 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1803 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1804 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CTX *, int, void *) +/* 1805 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 1806 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1807 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1808 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1809 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CTX *, uint32_t) +/* 1810 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 1811 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 22), // uint32_t +/* 1812 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1813 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CTX *, unsigned char const *, unsigned int) +/* 1814 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 1815 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1816 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 1817 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1818 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CTX *, unsigned int, int(*)(SSL *, unsigned int, unsigned char const * *, size_t *, int *, void *), void(*)(SSL *, unsigned int, unsigned char const *, void *), void *, int(*)(SSL *, unsigned int, unsigned char const *, size_t, int *, void *), void *) +/* 1819 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 1820 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 1821 */ _CFFI_OP(_CFFI_OP_POINTER, 1723), // int(*)(SSL *, unsigned int, unsigned char const * *, size_t *, int *, void *) +/* 1822 */ _CFFI_OP(_CFFI_OP_POINTER, 2782), // void(*)(SSL *, unsigned int, unsigned char const *, void *) +/* 1823 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1824 */ _CFFI_OP(_CFFI_OP_POINTER, 1731), // int(*)(SSL *, unsigned int, unsigned char const *, size_t, int *, void *) +/* 1825 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 1826 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1827 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_CTX const *) +/* 1828 */ _CFFI_OP(_CFFI_OP_NOOP, 691), +/* 1829 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1830 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_SESSION *, unsigned char const *, unsigned int) +/* 1831 */ _CFFI_OP(_CFFI_OP_NOOP, 1666), +/* 1832 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1833 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 1834 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1835 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(SSL_SESSION const *) +/* 1836 */ _CFFI_OP(_CFFI_OP_POINTER, 3116), // SSL_SESSION const * +/* 1837 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1838 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 * *, X509_STORE_CTX *, X509 *) +/* 1839 */ _CFFI_OP(_CFFI_OP_NOOP, 518), +/* 1840 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 1841 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1842 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1843 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 *) +/* 1844 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1845 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1846 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 *, ASN1_INTEGER *) +/* 1847 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1848 */ _CFFI_OP(_CFFI_OP_NOOP, 21), +/* 1849 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1850 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 *, ASN1_OCTET_STRING *) +/* 1851 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1852 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 1853 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1854 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 *, EVP_PKEY *) +/* 1855 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1856 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1857 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1858 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 *, EVP_PKEY *, EVP_MD const *) +/* 1859 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1860 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1861 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 1862 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1863 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 *, X509_EXTENSION *, int) +/* 1864 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1865 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 1866 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1867 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1868 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 *, X509_NAME *) +/* 1869 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1870 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 1871 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1872 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 *, long) +/* 1873 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1874 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 1875 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1876 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 *, unsigned char * *) +/* 1877 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 1878 */ _CFFI_OP(_CFFI_OP_NOOP, 802), +/* 1879 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1880 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 const *) +/* 1881 */ _CFFI_OP(_CFFI_OP_NOOP, 355), +/* 1882 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1883 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 const *, EVP_MD const *, unsigned char *, unsigned int *) +/* 1884 */ _CFFI_OP(_CFFI_OP_NOOP, 355), +/* 1885 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 1886 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1887 */ _CFFI_OP(_CFFI_OP_NOOP, 1390), +/* 1888 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1889 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509 const *, X509 const *) +/* 1890 */ _CFFI_OP(_CFFI_OP_NOOP, 355), +/* 1891 */ _CFFI_OP(_CFFI_OP_NOOP, 355), +/* 1892 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1893 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_ATTRIBUTE const *) +/* 1894 */ _CFFI_OP(_CFFI_OP_POINTER, 3123), // X509_ATTRIBUTE const * +/* 1895 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1896 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_CRL *) +/* 1897 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 1898 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1899 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_CRL *, ASN1_OCTET_STRING *) +/* 1900 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 1901 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 1902 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1903 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_CRL *, EVP_PKEY *) +/* 1904 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 1905 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1906 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1907 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_CRL *, EVP_PKEY *, EVP_MD const *) +/* 1908 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 1909 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 1910 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 1911 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1912 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_CRL *, X509_EXTENSION *, int) +/* 1913 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 1914 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 1915 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1916 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1917 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_CRL *, X509_NAME *) +/* 1918 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 1919 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 1920 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1921 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_CRL *, X509_REVOKED * *, ASN1_INTEGER *) +/* 1922 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 1923 */ _CFFI_OP(_CFFI_OP_POINTER, 619), // X509_REVOKED * * +/* 1924 */ _CFFI_OP(_CFFI_OP_NOOP, 21), +/* 1925 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1926 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_CRL *, X509_REVOKED *) +/* 1927 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 1928 */ _CFFI_OP(_CFFI_OP_NOOP, 619), +/* 1929 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1930 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_CRL *, long) +/* 1931 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 1932 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 1933 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1934 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_CRL *, unsigned char * *) +/* 1935 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 1936 */ _CFFI_OP(_CFFI_OP_NOOP, 802), +/* 1937 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1938 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_CRL const *, X509_CRL const *) +/* 1939 */ _CFFI_OP(_CFFI_OP_POINTER, 3124), // X509_CRL const * +/* 1940 */ _CFFI_OP(_CFFI_OP_NOOP, 1939), +/* 1941 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1942 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_EXTENSION *) +/* 1943 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 1944 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1945 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_EXTENSIONS *) +/* 1946 */ _CFFI_OP(_CFFI_OP_NOOP, 615), +/* 1947 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1948 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_EXTENSIONS *, X509_EXTENSION *) +/* 1949 */ _CFFI_OP(_CFFI_OP_NOOP, 615), +/* 1950 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 1951 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1952 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_EXTENSIONS *, X509_EXTENSION *, int) +/* 1953 */ _CFFI_OP(_CFFI_OP_NOOP, 615), +/* 1954 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 1955 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1956 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1957 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_NAME *) +/* 1958 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 1959 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1960 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_NAME *, ASN1_OBJECT *, int, unsigned char *, int, int, int) +/* 1961 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 1962 */ _CFFI_OP(_CFFI_OP_NOOP, 607), +/* 1963 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1964 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1965 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1966 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1967 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1968 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1969 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_NAME *, X509_NAME_ENTRY *, int, int) +/* 1970 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 1971 */ _CFFI_OP(_CFFI_OP_NOOP, 43), +/* 1972 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1973 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1974 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1975 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_NAME *, char const *, int, unsigned char const *, int, int, int) +/* 1976 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 1977 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 1978 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1979 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 1980 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1981 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1982 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1983 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1984 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_NAME *, int, int) +/* 1985 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 1986 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1987 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1988 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1989 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_NAME *, int, int, unsigned char *, int, int, int) +/* 1990 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 1991 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1992 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1993 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 1994 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1995 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1996 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 1997 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 1998 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_NAME *, unsigned char * *) +/* 1999 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 2000 */ _CFFI_OP(_CFFI_OP_NOOP, 802), +/* 2001 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2002 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_NAME const *, X509_NAME const *) +/* 2003 */ _CFFI_OP(_CFFI_OP_POINTER, 3127), // X509_NAME const * +/* 2004 */ _CFFI_OP(_CFFI_OP_NOOP, 2003), +/* 2005 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2006 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_NAME_ENTRY *) +/* 2007 */ _CFFI_OP(_CFFI_OP_NOOP, 43), +/* 2008 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2009 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_OBJECT const *) +/* 2010 */ _CFFI_OP(_CFFI_OP_POINTER, 3129), // X509_OBJECT const * +/* 2011 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2012 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REQ *, ASN1_OBJECT const *, int, unsigned char const *, int) +/* 2013 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 2014 */ _CFFI_OP(_CFFI_OP_NOOP, 765), +/* 2015 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2016 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2017 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2018 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2019 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REQ *, EVP_PKEY *) +/* 2020 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 2021 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 2022 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2023 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REQ *, EVP_PKEY *, EVP_MD const *) +/* 2024 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 2025 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 2026 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 2027 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2028 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REQ *, X509_EXTENSIONS *) +/* 2029 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 2030 */ _CFFI_OP(_CFFI_OP_NOOP, 615), +/* 2031 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2032 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REQ *, X509_NAME *) +/* 2033 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 2034 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 2035 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2036 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REQ *, long) +/* 2037 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 2038 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 2039 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2040 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REQ *, unsigned char * *) +/* 2041 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 2042 */ _CFFI_OP(_CFFI_OP_NOOP, 802), +/* 2043 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2044 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REQ const *, ASN1_OBJECT const *, int) +/* 2045 */ _CFFI_OP(_CFFI_OP_NOOP, 551), +/* 2046 */ _CFFI_OP(_CFFI_OP_NOOP, 765), +/* 2047 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2048 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2049 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REVOKED *) +/* 2050 */ _CFFI_OP(_CFFI_OP_NOOP, 619), +/* 2051 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2052 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REVOKED *, ASN1_INTEGER *) +/* 2053 */ _CFFI_OP(_CFFI_OP_NOOP, 619), +/* 2054 */ _CFFI_OP(_CFFI_OP_NOOP, 21), +/* 2055 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2056 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REVOKED *, ASN1_OCTET_STRING *) +/* 2057 */ _CFFI_OP(_CFFI_OP_NOOP, 619), +/* 2058 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 2059 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2060 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REVOKED *, X509_EXTENSION *, int) +/* 2061 */ _CFFI_OP(_CFFI_OP_NOOP, 619), +/* 2062 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 2063 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2064 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2065 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_REVOKED *, int, void *, int, unsigned long) +/* 2066 */ _CFFI_OP(_CFFI_OP_NOOP, 619), +/* 2067 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2068 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2069 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2070 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 2071 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2072 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_STORE *) +/* 2073 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 2074 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2075 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_STORE *, X509 *) +/* 2076 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 2077 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 2078 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2079 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_STORE *, X509_CRL *) +/* 2080 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 2081 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 2082 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2083 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_STORE *, X509_VERIFY_PARAM *) +/* 2084 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 2085 */ _CFFI_OP(_CFFI_OP_POINTER, 3134), // X509_VERIFY_PARAM * +/* 2086 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2087 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_STORE *, char const *, char const *) +/* 2088 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 2089 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2090 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2091 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2092 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_STORE *, unsigned long) +/* 2093 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 2094 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 2095 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2096 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_STORE_CTX *) +/* 2097 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2098 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2099 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_STORE_CTX *, X509_STORE *, X509 *, Cryptography_STACK_OF_X509 *) +/* 2100 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2101 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 2102 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 2103 */ _CFFI_OP(_CFFI_OP_NOOP, 413), +/* 2104 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2105 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_STORE_CTX *, char const *) +/* 2106 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2107 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2108 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2109 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_STORE_CTX *, int, void *) +/* 2110 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2111 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2112 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2113 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2114 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_STORE_CTX *, void *) +/* 2115 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2116 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2117 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2118 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_VERIFY_PARAM *, ASN1_OBJECT *) +/* 2119 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2120 */ _CFFI_OP(_CFFI_OP_NOOP, 607), +/* 2121 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2122 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_VERIFY_PARAM *, Cryptography_STACK_OF_ASN1_OBJECT *) +/* 2123 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2124 */ _CFFI_OP(_CFFI_OP_NOOP, 36), +/* 2125 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2126 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_VERIFY_PARAM *, char const *) +/* 2127 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2128 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2129 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2130 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_VERIFY_PARAM *, char const *, size_t) +/* 2131 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2132 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2133 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2134 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2135 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_VERIFY_PARAM *, int) +/* 2136 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2137 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2138 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2139 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_VERIFY_PARAM *, unsigned char const *, size_t) +/* 2140 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2141 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2142 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2143 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2144 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_VERIFY_PARAM *, unsigned long) +/* 2145 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2146 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 2147 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2148 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(X509_VERIFY_PARAM const *) +/* 2149 */ _CFFI_OP(_CFFI_OP_POINTER, 3134), // X509_VERIFY_PARAM const * +/* 2150 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2151 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(char *) +/* 2152 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 2153 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2154 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(char *, int, ASN1_OBJECT const *, int) +/* 2155 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 2156 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2157 */ _CFFI_OP(_CFFI_OP_NOOP, 765), +/* 2158 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2159 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2160 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(char *, int, int, void *) +/* 2161 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 2162 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2163 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2164 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2165 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2166 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(char const *) +/* 2167 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2168 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2169 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(char const *, int, unsigned char const *, int, int, EVP_MD const *, int, unsigned char *) +/* 2170 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2171 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2172 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2173 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2174 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2175 */ _CFFI_OP(_CFFI_OP_NOOP, 354), +/* 2176 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2177 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2178 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2179 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(char const *, size_t, unsigned char const *, size_t, uint64_t, uint64_t, uint64_t, uint64_t, unsigned char *, size_t) +/* 2180 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2181 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2182 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2183 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2184 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 24), // uint64_t +/* 2185 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 24), +/* 2186 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 24), +/* 2187 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 24), +/* 2188 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2189 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2190 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2191 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(int) +/* 2192 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2193 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2194 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(int, X509_STORE_CTX *) +/* 2195 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2196 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2197 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2198 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(int, int) +/* 2199 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2200 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2201 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2202 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(int, unsigned char const *, int, unsigned char *, unsigned int *, DSA *) +/* 2203 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2204 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2205 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2206 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2207 */ _CFFI_OP(_CFFI_OP_NOOP, 1390), +/* 2208 */ _CFFI_OP(_CFFI_OP_NOOP, 212), +/* 2209 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2210 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(int, unsigned char const *, int, unsigned char *, unsigned int *, EC_KEY *) +/* 2211 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2212 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2213 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2214 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2215 */ _CFFI_OP(_CFFI_OP_NOOP, 1390), +/* 2216 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 2217 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2218 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(int, unsigned char const *, int, unsigned char const *, int, DSA *) +/* 2219 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2220 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2221 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2222 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2223 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2224 */ _CFFI_OP(_CFFI_OP_NOOP, 212), +/* 2225 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2226 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(int, unsigned char const *, int, unsigned char const *, int, EC_KEY *) +/* 2227 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2228 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2229 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2230 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2231 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2232 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 2233 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2234 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(long, void *, CRYPTO_EX_new *, CRYPTO_EX_dup *, CRYPTO_EX_free *) +/* 2235 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 2236 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2237 */ _CFFI_OP(_CFFI_OP_POINTER, 3032), // CRYPTO_EX_new * +/* 2238 */ _CFFI_OP(_CFFI_OP_POINTER, 3030), // CRYPTO_EX_dup * +/* 2239 */ _CFFI_OP(_CFFI_OP_POINTER, 3031), // CRYPTO_EX_free * +/* 2240 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2241 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(unsigned char * *, ASN1_OCTET_STRING *) +/* 2242 */ _CFFI_OP(_CFFI_OP_NOOP, 802), +/* 2243 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 2244 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2245 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(unsigned char * *, unsigned char *, unsigned char const *, unsigned int, unsigned char const *, unsigned int) +/* 2246 */ _CFFI_OP(_CFFI_OP_NOOP, 802), +/* 2247 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2248 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2249 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 2250 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2251 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 2252 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2253 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(unsigned char *, BIGNUM const *, DH *) +/* 2254 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2255 */ _CFFI_OP(_CFFI_OP_NOOP, 92), +/* 2256 */ _CFFI_OP(_CFFI_OP_NOOP, 196), +/* 2257 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2258 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(unsigned char *, int) +/* 2259 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2260 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2261 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2262 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(unsigned int) +/* 2263 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 2264 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2265 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(unsigned long) +/* 2266 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 2267 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2268 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(void *(*)(size_t, char const *, int), void *(*)(void *, size_t, char const *, int), void(*)(void *, char const *, int)) +/* 2269 */ _CFFI_OP(_CFFI_OP_POINTER, 2511), // void *(*)(size_t, char const *, int) +/* 2270 */ _CFFI_OP(_CFFI_OP_POINTER, 2516), // void *(*)(void *, size_t, char const *, int) +/* 2271 */ _CFFI_OP(_CFFI_OP_POINTER, 2988), // void(*)(void *, char const *, int) +/* 2272 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2273 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(void *, size_t, EC_POINT const *, EC_KEY *, void *(*)(void const *, size_t, void *, size_t *)) +/* 2274 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2275 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2276 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 2277 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 2278 */ _CFFI_OP(_CFFI_OP_POINTER, 2527), // void *(*)(void const *, size_t, void *, size_t *) +/* 2279 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2280 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // int()(void) +/* 2281 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2282 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2926), // int(*()(X509_STORE *))(X509 * *, X509_STORE_CTX *, X509 *) +/* 2283 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 2284 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2285 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(ASN1_ENUMERATED *) +/* 2286 */ _CFFI_OP(_CFFI_OP_NOOP, 757), +/* 2287 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2288 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(BIO *, char * *) +/* 2289 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 2290 */ _CFFI_OP(_CFFI_OP_POINTER, 409), // char * * +/* 2291 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2292 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(BIO *, int) +/* 2293 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 2294 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2295 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2296 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL *) +/* 2297 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2298 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2299 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL *, EVP_PKEY * *) +/* 2300 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2301 */ _CFFI_OP(_CFFI_OP_NOOP, 273), +/* 2302 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2303 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL *, int) +/* 2304 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2305 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2306 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2307 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL *, long) +/* 2308 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2309 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 2310 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2311 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL *, time_t *, long *) +/* 2312 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2313 */ _CFFI_OP(_CFFI_OP_POINTER, 10), // time_t * +/* 2314 */ _CFFI_OP(_CFFI_OP_POINTER, 51), // long * +/* 2315 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2316 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL *, unsigned char *, int) +/* 2317 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2318 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2319 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2320 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2321 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL *, unsigned char const * *) +/* 2322 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2323 */ _CFFI_OP(_CFFI_OP_NOOP, 75), +/* 2324 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2325 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL const *) +/* 2326 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 2327 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2328 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL_CTX *) +/* 2329 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2330 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2331 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL_CTX *, char const *) +/* 2332 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2333 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2334 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2335 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL_CTX *, int(*)(SSL *, void *)) +/* 2336 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2337 */ _CFFI_OP(_CFFI_OP_POINTER, 1739), // int(*)(SSL *, void *) +/* 2338 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2339 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL_CTX *, int) +/* 2340 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2341 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2342 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2343 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL_CTX *, long) +/* 2344 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2345 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 2346 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2347 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL_CTX *, void *) +/* 2348 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2349 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2350 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2351 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL_CTX const *) +/* 2352 */ _CFFI_OP(_CFFI_OP_NOOP, 691), +/* 2353 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2354 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(SSL_SESSION const *) +/* 2355 */ _CFFI_OP(_CFFI_OP_NOOP, 1836), +/* 2356 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2357 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(X509 *) +/* 2358 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 2359 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2360 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(X509_CRL *) +/* 2361 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 2362 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2363 */ _CFFI_OP(_CFFI_OP_FUNCTION, 51), // long()(X509_REQ *) +/* 2364 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 2365 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2366 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1654), // sct_version_t()(SCT const *) +/* 2367 */ _CFFI_OP(_CFFI_OP_NOOP, 747), +/* 2368 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2369 */ _CFFI_OP(_CFFI_OP_FUNCTION, 300), // size_t()(BIO *) +/* 2370 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 2371 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2372 */ _CFFI_OP(_CFFI_OP_FUNCTION, 300), // size_t()(EC_GROUP const *, EC_POINT const *, point_conversion_form_t, unsigned char *, size_t, BN_CTX *) +/* 2373 */ _CFFI_OP(_CFFI_OP_NOOP, 238), +/* 2374 */ _CFFI_OP(_CFFI_OP_NOOP, 244), +/* 2375 */ _CFFI_OP(_CFFI_OP_ENUM, 1), // point_conversion_form_t +/* 2376 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2377 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2378 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 2379 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2380 */ _CFFI_OP(_CFFI_OP_FUNCTION, 300), // size_t()(EC_builtin_curve *, size_t) +/* 2381 */ _CFFI_OP(_CFFI_OP_POINTER, 3058), // EC_builtin_curve * +/* 2382 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2383 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2384 */ _CFFI_OP(_CFFI_OP_FUNCTION, 300), // size_t()(EVP_PKEY *, unsigned char * *) +/* 2385 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 2386 */ _CFFI_OP(_CFFI_OP_NOOP, 802), +/* 2387 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2388 */ _CFFI_OP(_CFFI_OP_FUNCTION, 300), // size_t()(SCT const *, unsigned char * *) +/* 2389 */ _CFFI_OP(_CFFI_OP_NOOP, 747), +/* 2390 */ _CFFI_OP(_CFFI_OP_NOOP, 802), +/* 2391 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2392 */ _CFFI_OP(_CFFI_OP_FUNCTION, 300), // size_t()(SSL const *, unsigned char *, size_t) +/* 2393 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 2394 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2395 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2396 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2397 */ _CFFI_OP(_CFFI_OP_FUNCTION, 300), // size_t()(SSL const *, void *, size_t) +/* 2398 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 2399 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2400 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2401 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2402 */ _CFFI_OP(_CFFI_OP_FUNCTION, 300), // size_t()(SSL_SESSION const *, unsigned char *, size_t) +/* 2403 */ _CFFI_OP(_CFFI_OP_NOOP, 1836), +/* 2404 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2405 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2406 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2407 */ _CFFI_OP(_CFFI_OP_FUNCTION, 1811), // uint32_t()(SSL_SESSION const *) +/* 2408 */ _CFFI_OP(_CFFI_OP_NOOP, 1836), +/* 2409 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2410 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2184), // uint64_t()(SCT const *) +/* 2411 */ _CFFI_OP(_CFFI_OP_NOOP, 747), +/* 2412 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2413 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2184), // uint64_t()(SSL_CIPHER const *) +/* 2414 */ _CFFI_OP(_CFFI_OP_NOOP, 733), +/* 2415 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2416 */ _CFFI_OP(_CFFI_OP_FUNCTION, 752), // unsigned char *()(ASN1_OCTET_STRING *) +/* 2417 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 2418 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2419 */ _CFFI_OP(_CFFI_OP_FUNCTION, 752), // unsigned char *()(X509 *, int *) +/* 2420 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 2421 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 2422 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2423 */ _CFFI_OP(_CFFI_OP_FUNCTION, 103), // unsigned char const *()(SSL_SESSION const *, unsigned int *) +/* 2424 */ _CFFI_OP(_CFFI_OP_NOOP, 1836), +/* 2425 */ _CFFI_OP(_CFFI_OP_NOOP, 1390), +/* 2426 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2427 */ _CFFI_OP(_CFFI_OP_FUNCTION, 754), // unsigned int()(SSL *, char const *, char *, unsigned int, unsigned char *, unsigned int) +/* 2428 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2429 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2430 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 2431 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 2432 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2433 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 2434 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2435 */ _CFFI_OP(_CFFI_OP_FUNCTION, 754), // unsigned int()(SSL *, char const *, unsigned char *, unsigned int) +/* 2436 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2437 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2438 */ _CFFI_OP(_CFFI_OP_NOOP, 752), +/* 2439 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 2440 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2441 */ _CFFI_OP(_CFFI_OP_FUNCTION, 742), // unsigned long()(SSL *) +/* 2442 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2443 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2444 */ _CFFI_OP(_CFFI_OP_FUNCTION, 742), // unsigned long()(SSL *, unsigned long) +/* 2445 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2446 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 2447 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2448 */ _CFFI_OP(_CFFI_OP_FUNCTION, 742), // unsigned long()(SSL_CTX *) +/* 2449 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2450 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2451 */ _CFFI_OP(_CFFI_OP_FUNCTION, 742), // unsigned long()(SSL_CTX *, DH *) +/* 2452 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2453 */ _CFFI_OP(_CFFI_OP_NOOP, 196), +/* 2454 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2455 */ _CFFI_OP(_CFFI_OP_FUNCTION, 742), // unsigned long()(SSL_CTX *, EC_KEY *) +/* 2456 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2457 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 2458 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2459 */ _CFFI_OP(_CFFI_OP_FUNCTION, 742), // unsigned long()(SSL_CTX *, X509 *) +/* 2460 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2461 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 2462 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2463 */ _CFFI_OP(_CFFI_OP_FUNCTION, 742), // unsigned long()(SSL_CTX *, unsigned long) +/* 2464 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2465 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 2466 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2467 */ _CFFI_OP(_CFFI_OP_FUNCTION, 742), // unsigned long()(X509 *) +/* 2468 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 2469 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2470 */ _CFFI_OP(_CFFI_OP_FUNCTION, 742), // unsigned long()(X509_NAME *) +/* 2471 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 2472 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2473 */ _CFFI_OP(_CFFI_OP_FUNCTION, 742), // unsigned long()(X509_VERIFY_PARAM *) +/* 2474 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2475 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2476 */ _CFFI_OP(_CFFI_OP_FUNCTION, 742), // unsigned long()(void) +/* 2477 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2478 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(SSL const *, int) +/* 2479 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 2480 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2481 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2482 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(SSL_CTX const *, int) +/* 2483 */ _CFFI_OP(_CFFI_OP_NOOP, 691), +/* 2484 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2485 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2486 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(X509 *, int, int *, int *) +/* 2487 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 2488 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2489 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 2490 */ _CFFI_OP(_CFFI_OP_NOOP, 1169), +/* 2491 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2492 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(X509V3_CTX *) +/* 2493 */ _CFFI_OP(_CFFI_OP_NOOP, 575), +/* 2494 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2495 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(X509_ATTRIBUTE *, int, int, void *) +/* 2496 */ _CFFI_OP(_CFFI_OP_NOOP, 79), +/* 2497 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2498 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2499 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2500 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2501 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(X509_EXTENSION *) +/* 2502 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 2503 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2504 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(X509_STORE_CTX *, int) +/* 2505 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2506 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2507 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2508 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(size_t) +/* 2509 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2510 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2511 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(size_t, char const *, int) +/* 2512 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2513 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2514 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2515 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2516 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(void *, size_t, char const *, int) +/* 2517 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2518 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2519 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2520 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2521 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2522 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(void *, unsigned char const * *, long) +/* 2523 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2524 */ _CFFI_OP(_CFFI_OP_NOOP, 75), +/* 2525 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 9), +/* 2526 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2527 */ _CFFI_OP(_CFFI_OP_FUNCTION, 193), // void *()(void const *, size_t, void *, size_t *) +/* 2528 */ _CFFI_OP(_CFFI_OP_NOOP, 126), +/* 2529 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2530 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2531 */ _CFFI_OP(_CFFI_OP_NOOP, 1037), +/* 2532 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2533 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(ACCESS_DESCRIPTION *) +/* 2534 */ _CFFI_OP(_CFFI_OP_NOOP, 1056), +/* 2535 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2536 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(ASN1_ENUMERATED *) +/* 2537 */ _CFFI_OP(_CFFI_OP_NOOP, 757), +/* 2538 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2539 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(ASN1_GENERALIZEDTIME *) +/* 2540 */ _CFFI_OP(_CFFI_OP_NOOP, 9), +/* 2541 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2542 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(ASN1_INTEGER *) +/* 2543 */ _CFFI_OP(_CFFI_OP_NOOP, 21), +/* 2544 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2545 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(ASN1_OBJECT *) +/* 2546 */ _CFFI_OP(_CFFI_OP_NOOP, 607), +/* 2547 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2548 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(ASN1_OCTET_STRING *) +/* 2549 */ _CFFI_OP(_CFFI_OP_NOOP, 13), +/* 2550 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2551 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(ASN1_OCTET_STRING const * *, X509_ALGOR const * *, X509 const *) +/* 2552 */ _CFFI_OP(_CFFI_OP_NOOP, 1566), +/* 2553 */ _CFFI_OP(_CFFI_OP_POINTER, 3121), // X509_ALGOR const * * +/* 2554 */ _CFFI_OP(_CFFI_OP_NOOP, 355), +/* 2555 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2556 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(AUTHORITY_KEYID *) +/* 2557 */ _CFFI_OP(_CFFI_OP_POINTER, 3019), // AUTHORITY_KEYID * +/* 2558 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2559 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(BASIC_CONSTRAINTS *) +/* 2560 */ _CFFI_OP(_CFFI_OP_POINTER, 3020), // BASIC_CONSTRAINTS * +/* 2561 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2562 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(BIGNUM *) +/* 2563 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 2564 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2565 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(BIGNUM *, int) +/* 2566 */ _CFFI_OP(_CFFI_OP_NOOP, 20), +/* 2567 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2568 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2569 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(BIO *) +/* 2570 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 2571 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2572 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(BN_CTX *) +/* 2573 */ _CFFI_OP(_CFFI_OP_NOOP, 94), +/* 2574 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2575 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(BN_MONT_CTX *) +/* 2576 */ _CFFI_OP(_CFFI_OP_NOOP, 830), +/* 2577 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2578 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(CMAC_CTX *) +/* 2579 */ _CFFI_OP(_CFFI_OP_NOOP, 1031), +/* 2580 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2581 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_ACCESS_DESCRIPTION *) +/* 2582 */ _CFFI_OP(_CFFI_OP_NOOP, 1), +/* 2583 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2584 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_ACCESS_DESCRIPTION *, void(*)(ACCESS_DESCRIPTION *)) +/* 2585 */ _CFFI_OP(_CFFI_OP_NOOP, 1), +/* 2586 */ _CFFI_OP(_CFFI_OP_POINTER, 2533), // void(*)(ACCESS_DESCRIPTION *) +/* 2587 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2588 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_ASN1_INTEGER *) +/* 2589 */ _CFFI_OP(_CFFI_OP_NOOP, 24), +/* 2590 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2591 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_ASN1_OBJECT *) +/* 2592 */ _CFFI_OP(_CFFI_OP_NOOP, 36), +/* 2593 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2594 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_DIST_POINT *) +/* 2595 */ _CFFI_OP(_CFFI_OP_NOOP, 204), +/* 2596 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2597 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_DIST_POINT *, void(*)(DIST_POINT *)) +/* 2598 */ _CFFI_OP(_CFFI_OP_NOOP, 204), +/* 2599 */ _CFFI_OP(_CFFI_OP_POINTER, 2640), // void(*)(DIST_POINT *) +/* 2600 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2601 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_GENERAL_SUBTREE *) +/* 2602 */ _CFFI_OP(_CFFI_OP_NOOP, 329), +/* 2603 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2604 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_POLICYINFO *) +/* 2605 */ _CFFI_OP(_CFFI_OP_NOOP, 449), +/* 2606 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2607 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_POLICYINFO *, void(*)(POLICYINFO *)) +/* 2608 */ _CFFI_OP(_CFFI_OP_NOOP, 449), +/* 2609 */ _CFFI_OP(_CFFI_OP_POINTER, 2734), // void(*)(POLICYINFO *) +/* 2610 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2611 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_POLICYQUALINFO *) +/* 2612 */ _CFFI_OP(_CFFI_OP_NOOP, 455), +/* 2613 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2614 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_SCT *) +/* 2615 */ _CFFI_OP(_CFFI_OP_NOOP, 1101), +/* 2616 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2617 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_X509 *) +/* 2618 */ _CFFI_OP(_CFFI_OP_NOOP, 413), +/* 2619 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2620 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_X509_CRL *) +/* 2621 */ _CFFI_OP(_CFFI_OP_NOOP, 565), +/* 2622 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2623 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(Cryptography_STACK_OF_X509_NAME *) +/* 2624 */ _CFFI_OP(_CFFI_OP_NOOP, 633), +/* 2625 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2626 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(DH *) +/* 2627 */ _CFFI_OP(_CFFI_OP_NOOP, 196), +/* 2628 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2629 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(DH const *, BIGNUM const * *, BIGNUM const * *) +/* 2630 */ _CFFI_OP(_CFFI_OP_NOOP, 1165), +/* 2631 */ _CFFI_OP(_CFFI_OP_POINTER, 92), // BIGNUM const * * +/* 2632 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2633 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2634 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(DH const *, BIGNUM const * *, BIGNUM const * *, BIGNUM const * *) +/* 2635 */ _CFFI_OP(_CFFI_OP_NOOP, 1165), +/* 2636 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2637 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2638 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2639 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2640 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(DIST_POINT *) +/* 2641 */ _CFFI_OP(_CFFI_OP_NOOP, 1077), +/* 2642 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2643 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(DIST_POINT_NAME *) +/* 2644 */ _CFFI_OP(_CFFI_OP_POINTER, 3051), // DIST_POINT_NAME * +/* 2645 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2646 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(DSA *) +/* 2647 */ _CFFI_OP(_CFFI_OP_NOOP, 212), +/* 2648 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2649 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(DSA const *, BIGNUM const * *, BIGNUM const * *) +/* 2650 */ _CFFI_OP(_CFFI_OP_NOOP, 1195), +/* 2651 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2652 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2653 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2654 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(DSA const *, BIGNUM const * *, BIGNUM const * *, BIGNUM const * *) +/* 2655 */ _CFFI_OP(_CFFI_OP_NOOP, 1195), +/* 2656 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2657 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2658 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2659 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2660 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(EC_GROUP *) +/* 2661 */ _CFFI_OP(_CFFI_OP_POINTER, 3054), // EC_GROUP * +/* 2662 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2663 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(EC_KEY *) +/* 2664 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 2665 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2666 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(EC_KEY *, int) +/* 2667 */ _CFFI_OP(_CFFI_OP_NOOP, 893), +/* 2668 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2669 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2670 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(EC_POINT *) +/* 2671 */ _CFFI_OP(_CFFI_OP_NOOP, 1207), +/* 2672 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2673 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(ENGINE *) +/* 2674 */ _CFFI_OP(_CFFI_OP_NOOP, 282), +/* 2675 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2676 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(EVP_CIPHER_CTX *) +/* 2677 */ _CFFI_OP(_CFFI_OP_NOOP, 1318), +/* 2678 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2679 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(EVP_MD_CTX *) +/* 2680 */ _CFFI_OP(_CFFI_OP_NOOP, 1351), +/* 2681 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2682 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(EVP_PKEY *) +/* 2683 */ _CFFI_OP(_CFFI_OP_NOOP, 199), +/* 2684 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2685 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(EVP_PKEY_CTX *) +/* 2686 */ _CFFI_OP(_CFFI_OP_NOOP, 309), +/* 2687 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2688 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(GENERAL_NAME *) +/* 2689 */ _CFFI_OP(_CFFI_OP_NOOP, 928), +/* 2690 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2691 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(GENERAL_NAMES *) +/* 2692 */ _CFFI_OP(_CFFI_OP_NOOP, 316), +/* 2693 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2694 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(GENERAL_NAMES *, void(*)(GENERAL_NAME *)) +/* 2695 */ _CFFI_OP(_CFFI_OP_NOOP, 316), +/* 2696 */ _CFFI_OP(_CFFI_OP_POINTER, 2688), // void(*)(GENERAL_NAME *) +/* 2697 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2698 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(HMAC_CTX *) +/* 2699 */ _CFFI_OP(_CFFI_OP_NOOP, 1515), +/* 2700 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2701 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(ISSUING_DIST_POINT *) +/* 2702 */ _CFFI_OP(_CFFI_OP_POINTER, 3073), // ISSUING_DIST_POINT * +/* 2703 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2704 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(NAME_CONSTRAINTS *) +/* 2705 */ _CFFI_OP(_CFFI_OP_POINTER, 3074), // NAME_CONSTRAINTS * +/* 2706 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2707 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(NETSCAPE_SPKI *) +/* 2708 */ _CFFI_OP(_CFFI_OP_NOOP, 288), +/* 2709 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2710 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(NOTICEREF *) +/* 2711 */ _CFFI_OP(_CFFI_OP_POINTER, 3076), // NOTICEREF * +/* 2712 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2713 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(OCSP_BASICRESP *) +/* 2714 */ _CFFI_OP(_CFFI_OP_NOOP, 387), +/* 2715 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2716 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(OCSP_CERTID *) +/* 2717 */ _CFFI_OP(_CFFI_OP_NOOP, 366), +/* 2718 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2719 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(OCSP_REQUEST *) +/* 2720 */ _CFFI_OP(_CFFI_OP_NOOP, 365), +/* 2721 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2722 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(OCSP_RESPONSE *) +/* 2723 */ _CFFI_OP(_CFFI_OP_NOOP, 349), +/* 2724 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2725 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(OTHERNAME *) +/* 2726 */ _CFFI_OP(_CFFI_OP_POINTER, 3087), // OTHERNAME * +/* 2727 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2728 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(PKCS12 *) +/* 2729 */ _CFFI_OP(_CFFI_OP_NOOP, 940), +/* 2730 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2731 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(PKCS7 *) +/* 2732 */ _CFFI_OP(_CFFI_OP_NOOP, 442), +/* 2733 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2734 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(POLICYINFO *) +/* 2735 */ _CFFI_OP(_CFFI_OP_NOOP, 1091), +/* 2736 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2737 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(POLICYQUALINFO *) +/* 2738 */ _CFFI_OP(_CFFI_OP_NOOP, 1098), +/* 2739 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2740 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(POLICY_CONSTRAINTS *) +/* 2741 */ _CFFI_OP(_CFFI_OP_POINTER, 3105), // POLICY_CONSTRAINTS * +/* 2742 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2743 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(RSA *) +/* 2744 */ _CFFI_OP(_CFFI_OP_NOOP, 476), +/* 2745 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2746 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(RSA const *, BIGNUM const * *, BIGNUM const * *) +/* 2747 */ _CFFI_OP(_CFFI_OP_NOOP, 967), +/* 2748 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2749 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2750 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2751 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(RSA const *, BIGNUM const * *, BIGNUM const * *, BIGNUM const * *) +/* 2752 */ _CFFI_OP(_CFFI_OP_NOOP, 967), +/* 2753 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2754 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2755 */ _CFFI_OP(_CFFI_OP_NOOP, 2631), +/* 2756 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2757 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SCT *, uint64_t) +/* 2758 */ _CFFI_OP(_CFFI_OP_NOOP, 1102), +/* 2759 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 24), +/* 2760 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2761 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL *) +/* 2762 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2763 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2764 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL *, BIO *, BIO *) +/* 2765 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2766 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 2767 */ _CFFI_OP(_CFFI_OP_NOOP, 186), +/* 2768 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2769 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL *, char *) +/* 2770 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2771 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 2772 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2773 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL *, int(*)(SSL *, void *), void *) +/* 2774 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2775 */ _CFFI_OP(_CFFI_OP_NOOP, 2337), +/* 2776 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2777 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2778 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL *, int) +/* 2779 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2780 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2781 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2782 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL *, unsigned int, unsigned char const *, void *) +/* 2783 */ _CFFI_OP(_CFFI_OP_NOOP, 487), +/* 2784 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 2785 */ _CFFI_OP(_CFFI_OP_NOOP, 103), +/* 2786 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2787 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2788 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL const *, char const *) +/* 2789 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 2790 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2791 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2792 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL const *, int, int) +/* 2793 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 2794 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2795 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2796 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2797 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL const *, unsigned char const * *, unsigned int *) +/* 2798 */ _CFFI_OP(_CFFI_OP_NOOP, 157), +/* 2799 */ _CFFI_OP(_CFFI_OP_NOOP, 75), +/* 2800 */ _CFFI_OP(_CFFI_OP_NOOP, 1390), +/* 2801 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2802 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *) +/* 2803 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2804 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2805 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, Cryptography_STACK_OF_X509_NAME *) +/* 2806 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2807 */ _CFFI_OP(_CFFI_OP_NOOP, 633), +/* 2808 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2809 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, X509_STORE *) +/* 2810 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2811 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 2812 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2813 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, int(*)(SSL *, int *, void *)) +/* 2814 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2815 */ _CFFI_OP(_CFFI_OP_POINTER, 1672), // int(*)(SSL *, int *, void *) +/* 2816 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2817 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, int(*)(SSL *, unsigned char *, unsigned int *)) +/* 2818 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2819 */ _CFFI_OP(_CFFI_OP_POINTER, 1705), // int(*)(SSL *, unsigned char *, unsigned int *) +/* 2820 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2821 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, int(*)(SSL *, unsigned char const * *, unsigned char *, unsigned char const *, unsigned int, void *), void *) +/* 2822 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2823 */ _CFFI_OP(_CFFI_OP_POINTER, 1710), // int(*)(SSL *, unsigned char const * *, unsigned char *, unsigned char const *, unsigned int, void *) +/* 2824 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2825 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2826 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, int(*)(SSL *, void *), void *) +/* 2827 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2828 */ _CFFI_OP(_CFFI_OP_NOOP, 2337), +/* 2829 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2830 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2831 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, int(*)(X509_STORE_CTX *, void *), void *) +/* 2832 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2833 */ _CFFI_OP(_CFFI_OP_POINTER, 2114), // int(*)(X509_STORE_CTX *, void *) +/* 2834 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2835 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2836 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, int(*)(char *, int, int, void *)) +/* 2837 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2838 */ _CFFI_OP(_CFFI_OP_NOOP, 192), +/* 2839 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2840 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, int) +/* 2841 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2842 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2843 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2844 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, int, int(*)(int, X509_STORE_CTX *)) +/* 2845 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2846 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2847 */ _CFFI_OP(_CFFI_OP_POINTER, 2194), // int(*)(int, X509_STORE_CTX *) +/* 2848 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2849 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, unsigned int(*)(SSL *, char const *, char *, unsigned int, unsigned char *, unsigned int)) +/* 2850 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2851 */ _CFFI_OP(_CFFI_OP_POINTER, 2427), // unsigned int(*)(SSL *, char const *, char *, unsigned int, unsigned char *, unsigned int) +/* 2852 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2853 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, unsigned int(*)(SSL *, char const *, unsigned char *, unsigned int)) +/* 2854 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2855 */ _CFFI_OP(_CFFI_OP_POINTER, 2435), // unsigned int(*)(SSL *, char const *, unsigned char *, unsigned int) +/* 2856 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2857 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, void *) +/* 2858 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2859 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2860 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2861 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, void(*)(SSL const *, char const *)) +/* 2862 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2863 */ _CFFI_OP(_CFFI_OP_POINTER, 2788), // void(*)(SSL const *, char const *) +/* 2864 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2865 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_CTX *, void(*)(SSL const *, int, int)) +/* 2866 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 2867 */ _CFFI_OP(_CFFI_OP_POINTER, 2792), // void(*)(SSL const *, int, int) +/* 2868 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2869 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(SSL_SESSION *) +/* 2870 */ _CFFI_OP(_CFFI_OP_NOOP, 1666), +/* 2871 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2872 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(USERNOTICE *) +/* 2873 */ _CFFI_OP(_CFFI_OP_POINTER, 3118), // USERNOTICE * +/* 2874 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2875 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509 *) +/* 2876 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 2877 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2878 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509V3_CTX *, X509 *, X509 *, X509_REQ *, X509_CRL *, int) +/* 2879 */ _CFFI_OP(_CFFI_OP_NOOP, 575), +/* 2880 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 2881 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 2882 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 2883 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 2884 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2885 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2886 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_CRL *) +/* 2887 */ _CFFI_OP(_CFFI_OP_NOOP, 57), +/* 2888 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2889 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_CRL const *, ASN1_OCTET_STRING const * *, X509_ALGOR const * *) +/* 2890 */ _CFFI_OP(_CFFI_OP_NOOP, 1939), +/* 2891 */ _CFFI_OP(_CFFI_OP_NOOP, 1566), +/* 2892 */ _CFFI_OP(_CFFI_OP_NOOP, 2553), +/* 2893 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2894 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_EXTENSION *) +/* 2895 */ _CFFI_OP(_CFFI_OP_NOOP, 40), +/* 2896 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2897 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_EXTENSIONS *) +/* 2898 */ _CFFI_OP(_CFFI_OP_NOOP, 615), +/* 2899 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2900 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_EXTENSIONS *, void(*)(X509_EXTENSION *)) +/* 2901 */ _CFFI_OP(_CFFI_OP_NOOP, 615), +/* 2902 */ _CFFI_OP(_CFFI_OP_POINTER, 2894), // void(*)(X509_EXTENSION *) +/* 2903 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2904 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_NAME *) +/* 2905 */ _CFFI_OP(_CFFI_OP_NOOP, 643), +/* 2906 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2907 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_NAME_ENTRY *) +/* 2908 */ _CFFI_OP(_CFFI_OP_NOOP, 43), +/* 2909 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2910 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_REQ *) +/* 2911 */ _CFFI_OP(_CFFI_OP_NOOP, 294), +/* 2912 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2913 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_REQ const *, ASN1_OCTET_STRING const * *, X509_ALGOR const * *) +/* 2914 */ _CFFI_OP(_CFFI_OP_NOOP, 551), +/* 2915 */ _CFFI_OP(_CFFI_OP_NOOP, 1566), +/* 2916 */ _CFFI_OP(_CFFI_OP_NOOP, 2553), +/* 2917 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2918 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_REVOKED *) +/* 2919 */ _CFFI_OP(_CFFI_OP_NOOP, 619), +/* 2920 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2921 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_STORE *) +/* 2922 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 2923 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2924 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_STORE *, int(*)(X509 * *, X509_STORE_CTX *, X509 *)) +/* 2925 */ _CFFI_OP(_CFFI_OP_NOOP, 180), +/* 2926 */ _CFFI_OP(_CFFI_OP_POINTER, 1838), // int(*)(X509 * *, X509_STORE_CTX *, X509 *) +/* 2927 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2928 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_STORE_CTX *) +/* 2929 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2930 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2931 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_STORE_CTX *, Cryptography_STACK_OF_X509 *) +/* 2932 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2933 */ _CFFI_OP(_CFFI_OP_NOOP, 413), +/* 2934 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2935 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_STORE_CTX *, Cryptography_STACK_OF_X509_CRL *) +/* 2936 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2937 */ _CFFI_OP(_CFFI_OP_NOOP, 565), +/* 2938 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2939 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_STORE_CTX *, X509 *) +/* 2940 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2941 */ _CFFI_OP(_CFFI_OP_NOOP, 28), +/* 2942 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2943 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_STORE_CTX *, X509_VERIFY_PARAM *) +/* 2944 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2945 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2946 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2947 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_STORE_CTX *, int(*)(int, X509_STORE_CTX *)) +/* 2948 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2949 */ _CFFI_OP(_CFFI_OP_NOOP, 2847), +/* 2950 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2951 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_STORE_CTX *, int) +/* 2952 */ _CFFI_OP(_CFFI_OP_NOOP, 160), +/* 2953 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2954 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2955 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_VERIFY_PARAM *) +/* 2956 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2957 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2958 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_VERIFY_PARAM *, int) +/* 2959 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2960 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2961 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2962 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_VERIFY_PARAM *, time_t) +/* 2963 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2964 */ _CFFI_OP(_CFFI_OP_NOOP, 10), +/* 2965 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2966 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(X509_VERIFY_PARAM *, unsigned int) +/* 2967 */ _CFFI_OP(_CFFI_OP_NOOP, 2085), +/* 2968 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 8), +/* 2969 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2970 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(char const *) +/* 2971 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2972 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2973 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(int, int, int, char const *, int) +/* 2974 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2975 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2976 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2977 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2978 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2979 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2980 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(unsigned long, char *, size_t) +/* 2981 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 10), +/* 2982 */ _CFFI_OP(_CFFI_OP_NOOP, 409), +/* 2983 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 28), +/* 2984 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2985 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(void *) +/* 2986 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2987 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2988 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(void *, char const *, int) +/* 2989 */ _CFFI_OP(_CFFI_OP_NOOP, 193), +/* 2990 */ _CFFI_OP(_CFFI_OP_NOOP, 46), +/* 2991 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2992 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2993 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(void const *, int, double) +/* 2994 */ _CFFI_OP(_CFFI_OP_NOOP, 126), +/* 2995 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 7), +/* 2996 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 14), // double +/* 2997 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 2998 */ _CFFI_OP(_CFFI_OP_FUNCTION, 3142), // void()(void) +/* 2999 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 3000 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2863), // void(*()(SSL_CTX *))(SSL const *, char const *) +/* 3001 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 3002 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 3003 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2867), // void(*()(SSL_CTX *))(SSL const *, int, int) +/* 3004 */ _CFFI_OP(_CFFI_OP_NOOP, 490), +/* 3005 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 3006 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 4), // ACCESS_DESCRIPTION +/* 3007 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 5), // AES_KEY +/* 3008 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 6), // ASN1_ENUMERATED +/* 3009 */ _CFFI_OP(_CFFI_OP_POINTER, 3010), // ASN1_GENERALIZEDTIME const * +/* 3010 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 7), // ASN1_GENERALIZEDTIME +/* 3011 */ _CFFI_OP(_CFFI_OP_POINTER, 3012), // ASN1_INTEGER const * +/* 3012 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 8), // ASN1_INTEGER +/* 3013 */ _CFFI_OP(_CFFI_OP_POINTER, 3014), // ASN1_NULL * +/* 3014 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 9), // ASN1_NULL +/* 3015 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 10), // ASN1_OBJECT +/* 3016 */ _CFFI_OP(_CFFI_OP_POINTER, 3017), // ASN1_OCTET_STRING const * +/* 3017 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 115), // ASN1_OCTET_STRING +/* 3018 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 11), // ASN1_TYPE +/* 3019 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 12), // AUTHORITY_KEYID +/* 3020 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 13), // BASIC_CONSTRAINTS +/* 3021 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 14), // BIGNUM +/* 3022 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 15), // BIO +/* 3023 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 16), // BIO_METHOD +/* 3024 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 17), // BN_CTX +/* 3025 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 18), // BN_GENCB +/* 3026 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 19), // BN_MONT_CTX +/* 3027 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 20), // CMAC_CTX +/* 3028 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 21), // CONF +/* 3029 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 22), // CRYPTOGRAPHY_PASSWORD_DATA +/* 3030 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 23), // CRYPTO_EX_dup +/* 3031 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 24), // CRYPTO_EX_free +/* 3032 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 25), // CRYPTO_EX_new +/* 3033 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 26), // Cryptography_LHASH_OF_CONF_VALUE +/* 3034 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 27), // Cryptography_STACK_OF_ACCESS_DESCRIPTION +/* 3035 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 28), // Cryptography_STACK_OF_ASN1_INTEGER +/* 3036 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 29), // Cryptography_STACK_OF_ASN1_OBJECT +/* 3037 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 30), // Cryptography_STACK_OF_DIST_POINT +/* 3038 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 31), // Cryptography_STACK_OF_GENERAL_SUBTREE +/* 3039 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 32), // Cryptography_STACK_OF_POLICYINFO +/* 3040 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 33), // Cryptography_STACK_OF_POLICYQUALINFO +/* 3041 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 34), // Cryptography_STACK_OF_SCT +/* 3042 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 35), // Cryptography_STACK_OF_SSL_CIPHER +/* 3043 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 36), // Cryptography_STACK_OF_X509 +/* 3044 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 37), // Cryptography_STACK_OF_X509_CRL +/* 3045 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 38), // Cryptography_STACK_OF_X509_NAME +/* 3046 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 39), // Cryptography_STACK_OF_X509_NAME_ENTRY +/* 3047 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 40), // Cryptography_STACK_OF_X509_OBJECT +/* 3048 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 41), // Cryptography_STACK_OF_X509_REVOKED +/* 3049 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 42), // DH +/* 3050 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 43), // DIST_POINT +/* 3051 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 44), // DIST_POINT_NAME +/* 3052 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 45), // DSA +/* 3053 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 46), // ECDSA_SIG +/* 3054 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 47), // EC_GROUP +/* 3055 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 48), // EC_KEY +/* 3056 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 49), // EC_METHOD +/* 3057 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 50), // EC_POINT +/* 3058 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 51), // EC_builtin_curve +/* 3059 */ _CFFI_OP(_CFFI_OP_POINTER, 3060), // EDIPARTYNAME * +/* 3060 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 52), // EDIPARTYNAME +/* 3061 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 53), // ENGINE +/* 3062 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 54), // EVP_CIPHER +/* 3063 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 55), // EVP_CIPHER_CTX +/* 3064 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 56), // EVP_MD +/* 3065 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 57), // EVP_MD_CTX +/* 3066 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 58), // EVP_PKEY +/* 3067 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 59), // EVP_PKEY_CTX +/* 3068 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 60), // EXTENDED_KEY_USAGE +/* 3069 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 61), // GENERAL_NAME +/* 3070 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 116), // GENERAL_NAMES +/* 3071 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 62), // GENERAL_SUBTREE +/* 3072 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 63), // HMAC_CTX +/* 3073 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 64), // ISSUING_DIST_POINT +/* 3074 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 65), // NAME_CONSTRAINTS +/* 3075 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 66), // NETSCAPE_SPKI +/* 3076 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 67), // NOTICEREF +/* 3077 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 68), // OBJ_NAME +/* 3078 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 69), // OCSP_BASICRESP +/* 3079 */ _CFFI_OP(_CFFI_OP_POINTER, 3080), // OCSP_CERTID const * +/* 3080 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 70), // OCSP_CERTID +/* 3081 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 71), // OCSP_ONEREQ +/* 3082 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 72), // OCSP_REQUEST +/* 3083 */ _CFFI_OP(_CFFI_OP_POINTER, 3084), // OCSP_RESPDATA const * +/* 3084 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 73), // OCSP_RESPDATA +/* 3085 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 74), // OCSP_RESPONSE +/* 3086 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 75), // OCSP_SINGLERESP +/* 3087 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 76), // OTHERNAME +/* 3088 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 77), // PKCS12 +/* 3089 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 78), // PKCS7 +/* 3090 */ _CFFI_OP(_CFFI_OP_POINTER, 3091), // PKCS7_DIGEST * +/* 3091 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 79), // PKCS7_DIGEST +/* 3092 */ _CFFI_OP(_CFFI_OP_POINTER, 3093), // PKCS7_ENCRYPT * +/* 3093 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 80), // PKCS7_ENCRYPT +/* 3094 */ _CFFI_OP(_CFFI_OP_POINTER, 3095), // PKCS7_ENVELOPE * +/* 3095 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 81), // PKCS7_ENVELOPE +/* 3096 */ _CFFI_OP(_CFFI_OP_POINTER, 3097), // PKCS7_SIGNED * +/* 3097 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 82), // PKCS7_SIGNED +/* 3098 */ _CFFI_OP(_CFFI_OP_POINTER, 3099), // PKCS7_SIGNER_INFO * +/* 3099 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 83), // PKCS7_SIGNER_INFO +/* 3100 */ _CFFI_OP(_CFFI_OP_POINTER, 3101), // PKCS7_SIGN_ENVELOPE * +/* 3101 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 84), // PKCS7_SIGN_ENVELOPE +/* 3102 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 85), // PKCS8_PRIV_KEY_INFO +/* 3103 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 86), // POLICYINFO +/* 3104 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 87), // POLICYQUALINFO +/* 3105 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 88), // POLICY_CONSTRAINTS +/* 3106 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 89), // RAND_METHOD +/* 3107 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 90), // RSA +/* 3108 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 91), // SCT +/* 3109 */ _CFFI_OP(_CFFI_OP_POINTER, 3110), // SRTP_PROTECTION_PROFILE * +/* 3110 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 92), // SRTP_PROTECTION_PROFILE +/* 3111 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 93), // SSL +/* 3112 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 94), // SSL_CIPHER +/* 3113 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 95), // SSL_CTX +/* 3114 */ _CFFI_OP(_CFFI_OP_POINTER, 3115), // SSL_METHOD const * +/* 3115 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 96), // SSL_METHOD +/* 3116 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 97), // SSL_SESSION +/* 3117 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 98), // UI_METHOD +/* 3118 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 99), // USERNOTICE +/* 3119 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 100), // X509 +/* 3120 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 101), // X509V3_CTX +/* 3121 */ _CFFI_OP(_CFFI_OP_POINTER, 3122), // X509_ALGOR const * +/* 3122 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 102), // X509_ALGOR +/* 3123 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 103), // X509_ATTRIBUTE +/* 3124 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 104), // X509_CRL +/* 3125 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 105), // X509_EXTENSION +/* 3126 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 106), // X509_EXTENSIONS +/* 3127 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 107), // X509_NAME +/* 3128 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 108), // X509_NAME_ENTRY +/* 3129 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 109), // X509_OBJECT +/* 3130 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 110), // X509_REQ +/* 3131 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 111), // X509_REVOKED +/* 3132 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 112), // X509_STORE +/* 3133 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 113), // X509_STORE_CTX +/* 3134 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 114), // X509_VERIFY_PARAM +/* 3135 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 2), // char +/* 3136 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 0), // union $1 +/* 3137 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 1), // union $2 +/* 3138 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 2), // union $3 +/* 3139 */ _CFFI_OP(_CFFI_OP_STRUCT_UNION, 3), // union $4 +/* 3140 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 4), // unsigned char +/* 3141 */ _CFFI_OP(_CFFI_OP_POINTER, 2522), // void *(*)(void *, unsigned char const * *, long) +/* 3142 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 0), // void +}; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_ACCESS_DESCRIPTION(ACCESS_DESCRIPTION *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { ASN1_OBJECT * *tmp = &p->method; (void)tmp; } + { GENERAL_NAME * *tmp = &p->location; (void)tmp; } +} +struct _cffi_align_typedef_ACCESS_DESCRIPTION { char x; ACCESS_DESCRIPTION y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_ASN1_TYPE(ASN1_TYPE *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + (void)((p->type) | 0); /* check that 'ASN1_TYPE.type' is an integer */ +} +struct _cffi_align_typedef_ASN1_TYPE { char x; ASN1_TYPE y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_AUTHORITY_KEYID(AUTHORITY_KEYID *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { ASN1_OCTET_STRING * *tmp = &p->keyid; (void)tmp; } + { GENERAL_NAMES * *tmp = &p->issuer; (void)tmp; } + { ASN1_INTEGER * *tmp = &p->serial; (void)tmp; } +} +struct _cffi_align_typedef_AUTHORITY_KEYID { char x; AUTHORITY_KEYID y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + (void)((p->ca) | 0); /* check that 'BASIC_CONSTRAINTS.ca' is an integer */ + { ASN1_INTEGER * *tmp = &p->pathlen; (void)tmp; } +} +struct _cffi_align_typedef_BASIC_CONSTRAINTS { char x; BASIC_CONSTRAINTS y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_CRYPTOGRAPHY_PASSWORD_DATA(CRYPTOGRAPHY_PASSWORD_DATA *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { char * *tmp = &p->password; (void)tmp; } + (void)((p->length) | 0); /* check that 'CRYPTOGRAPHY_PASSWORD_DATA.length' is an integer */ + (void)((p->called) | 0); /* check that 'CRYPTOGRAPHY_PASSWORD_DATA.called' is an integer */ + (void)((p->error) | 0); /* check that 'CRYPTOGRAPHY_PASSWORD_DATA.error' is an integer */ + (void)((p->maxsize) | 0); /* check that 'CRYPTOGRAPHY_PASSWORD_DATA.maxsize' is an integer */ +} +struct _cffi_align_typedef_CRYPTOGRAPHY_PASSWORD_DATA { char x; CRYPTOGRAPHY_PASSWORD_DATA y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_DIST_POINT(DIST_POINT *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { DIST_POINT_NAME * *tmp = &p->distpoint; (void)tmp; } + { ASN1_OCTET_STRING * *tmp = &p->reasons; (void)tmp; } + { GENERAL_NAMES * *tmp = &p->CRLissuer; (void)tmp; } +} +struct _cffi_align_typedef_DIST_POINT { char x; DIST_POINT y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_DIST_POINT_NAME(DIST_POINT_NAME *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + (void)((p->type) | 0); /* check that 'DIST_POINT_NAME.type' is an integer */ + /* cannot generate 'union $2' in field 'name': unknown type name */ +} +struct _cffi_align_typedef_DIST_POINT_NAME { char x; DIST_POINT_NAME y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_EC_builtin_curve(EC_builtin_curve *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + (void)((p->nid) | 0); /* check that 'EC_builtin_curve.nid' is an integer */ + { char const * *tmp = &p->comment; (void)tmp; } +} +struct _cffi_align_typedef_EC_builtin_curve { char x; EC_builtin_curve y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_EDIPARTYNAME(EDIPARTYNAME *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; +} +struct _cffi_align_typedef_EDIPARTYNAME { char x; EDIPARTYNAME y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_GENERAL_NAME(GENERAL_NAME *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + (void)((p->type) | 0); /* check that 'GENERAL_NAME.type' is an integer */ + /* cannot generate 'union $1' in field 'd': unknown type name */ +} +struct _cffi_align_typedef_GENERAL_NAME { char x; GENERAL_NAME y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_GENERAL_SUBTREE(GENERAL_SUBTREE *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { GENERAL_NAME * *tmp = &p->base; (void)tmp; } + { ASN1_INTEGER * *tmp = &p->minimum; (void)tmp; } + { ASN1_INTEGER * *tmp = &p->maximum; (void)tmp; } +} +struct _cffi_align_typedef_GENERAL_SUBTREE { char x; GENERAL_SUBTREE y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_ISSUING_DIST_POINT(ISSUING_DIST_POINT *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { DIST_POINT_NAME * *tmp = &p->distpoint; (void)tmp; } + (void)((p->onlyuser) | 0); /* check that 'ISSUING_DIST_POINT.onlyuser' is an integer */ + (void)((p->onlyCA) | 0); /* check that 'ISSUING_DIST_POINT.onlyCA' is an integer */ + { ASN1_OCTET_STRING * *tmp = &p->onlysomereasons; (void)tmp; } + (void)((p->indirectCRL) | 0); /* check that 'ISSUING_DIST_POINT.indirectCRL' is an integer */ + (void)((p->onlyattr) | 0); /* check that 'ISSUING_DIST_POINT.onlyattr' is an integer */ +} +struct _cffi_align_typedef_ISSUING_DIST_POINT { char x; ISSUING_DIST_POINT y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_NAME_CONSTRAINTS(NAME_CONSTRAINTS *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { Cryptography_STACK_OF_GENERAL_SUBTREE * *tmp = &p->permittedSubtrees; (void)tmp; } + { Cryptography_STACK_OF_GENERAL_SUBTREE * *tmp = &p->excludedSubtrees; (void)tmp; } +} +struct _cffi_align_typedef_NAME_CONSTRAINTS { char x; NAME_CONSTRAINTS y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_NOTICEREF(NOTICEREF *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { ASN1_OCTET_STRING * *tmp = &p->organization; (void)tmp; } + { Cryptography_STACK_OF_ASN1_INTEGER * *tmp = &p->noticenos; (void)tmp; } +} +struct _cffi_align_typedef_NOTICEREF { char x; NOTICEREF y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_OBJ_NAME(OBJ_NAME *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + (void)((p->type) | 0); /* check that 'OBJ_NAME.type' is an integer */ + (void)((p->alias) | 0); /* check that 'OBJ_NAME.alias' is an integer */ + { char const * *tmp = &p->name; (void)tmp; } + { char const * *tmp = &p->data; (void)tmp; } +} +struct _cffi_align_typedef_OBJ_NAME { char x; OBJ_NAME y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_OTHERNAME(OTHERNAME *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { ASN1_OBJECT * *tmp = &p->type_id; (void)tmp; } + { ASN1_TYPE * *tmp = &p->value; (void)tmp; } +} +struct _cffi_align_typedef_OTHERNAME { char x; OTHERNAME y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_PKCS7(PKCS7 *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { ASN1_OBJECT * *tmp = &p->type; (void)tmp; } + /* cannot generate 'union $4' in field 'd': unknown type name */ +} +struct _cffi_align_typedef_PKCS7 { char x; PKCS7 y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_PKCS7_SIGNED(PKCS7_SIGNED *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { Cryptography_STACK_OF_X509 * *tmp = &p->cert; (void)tmp; } + { Cryptography_STACK_OF_X509_CRL * *tmp = &p->crl; (void)tmp; } +} +struct _cffi_align_typedef_PKCS7_SIGNED { char x; PKCS7_SIGNED y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { Cryptography_STACK_OF_X509 * *tmp = &p->cert; (void)tmp; } + { Cryptography_STACK_OF_X509_CRL * *tmp = &p->crl; (void)tmp; } +} +struct _cffi_align_typedef_PKCS7_SIGN_ENVELOPE { char x; PKCS7_SIGN_ENVELOPE y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_POLICYINFO(POLICYINFO *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { ASN1_OBJECT * *tmp = &p->policyid; (void)tmp; } + { Cryptography_STACK_OF_POLICYQUALINFO * *tmp = &p->qualifiers; (void)tmp; } +} +struct _cffi_align_typedef_POLICYINFO { char x; POLICYINFO y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_POLICYQUALINFO(POLICYQUALINFO *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { ASN1_OBJECT * *tmp = &p->pqualid; (void)tmp; } + /* cannot generate 'union $3' in field 'd': unknown type name */ +} +struct _cffi_align_typedef_POLICYQUALINFO { char x; POLICYQUALINFO y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_POLICY_CONSTRAINTS(POLICY_CONSTRAINTS *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { ASN1_INTEGER * *tmp = &p->requireExplicitPolicy; (void)tmp; } + { ASN1_INTEGER * *tmp = &p->inhibitPolicyMapping; (void)tmp; } +} +struct _cffi_align_typedef_POLICY_CONSTRAINTS { char x; POLICY_CONSTRAINTS y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_SRTP_PROTECTION_PROFILE(SRTP_PROTECTION_PROFILE *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { char const * *tmp = &p->name; (void)tmp; } + (void)((p->id) | 0); /* check that 'SRTP_PROTECTION_PROFILE.id' is an integer */ +} +struct _cffi_align_typedef_SRTP_PROTECTION_PROFILE { char x; SRTP_PROTECTION_PROFILE y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_USERNOTICE(USERNOTICE *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { NOTICEREF * *tmp = &p->noticeref; (void)tmp; } + { ASN1_OCTET_STRING * *tmp = &p->exptext; (void)tmp; } +} +struct _cffi_align_typedef_USERNOTICE { char x; USERNOTICE y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_X509V3_CTX(X509V3_CTX *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { X509 * *tmp = &p->issuer_cert; (void)tmp; } + { X509 * *tmp = &p->subject_cert; (void)tmp; } +} +struct _cffi_align_typedef_X509V3_CTX { char x; X509V3_CTX y; }; + +_CFFI_UNUSED_FN +static void _cffi_checkfld_typedef_X509_ALGOR(X509_ALGOR *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + { ASN1_OBJECT * *tmp = &p->algorithm; (void)tmp; } +} +struct _cffi_align_typedef_X509_ALGOR { char x; X509_ALGOR y; }; + +static int _cffi_const_CT_LOG_ENTRY_TYPE_NOT_SET(unsigned long long *o) +{ + int n = (CT_LOG_ENTRY_TYPE_NOT_SET) <= 0; + *o = (unsigned long long)((CT_LOG_ENTRY_TYPE_NOT_SET) | 0); /* check that CT_LOG_ENTRY_TYPE_NOT_SET is an integer */ + return n; +} + +static int _cffi_const_CT_LOG_ENTRY_TYPE_X509(unsigned long long *o) +{ + int n = (CT_LOG_ENTRY_TYPE_X509) <= 0; + *o = (unsigned long long)((CT_LOG_ENTRY_TYPE_X509) | 0); /* check that CT_LOG_ENTRY_TYPE_X509 is an integer */ + return n; +} + +static int _cffi_const_CT_LOG_ENTRY_TYPE_PRECERT(unsigned long long *o) +{ + int n = (CT_LOG_ENTRY_TYPE_PRECERT) <= 0; + *o = (unsigned long long)((CT_LOG_ENTRY_TYPE_PRECERT) | 0); /* check that CT_LOG_ENTRY_TYPE_PRECERT is an integer */ + return n; +} + +static int _cffi_const_POINT_CONVERSION_COMPRESSED(unsigned long long *o) +{ + int n = (POINT_CONVERSION_COMPRESSED) <= 0; + *o = (unsigned long long)((POINT_CONVERSION_COMPRESSED) | 0); /* check that POINT_CONVERSION_COMPRESSED is an integer */ + return n; +} + +static int _cffi_const_POINT_CONVERSION_UNCOMPRESSED(unsigned long long *o) +{ + int n = (POINT_CONVERSION_UNCOMPRESSED) <= 0; + *o = (unsigned long long)((POINT_CONVERSION_UNCOMPRESSED) | 0); /* check that POINT_CONVERSION_UNCOMPRESSED is an integer */ + return n; +} + +static int _cffi_const_SCT_SOURCE_UNKNOWN(unsigned long long *o) +{ + int n = (SCT_SOURCE_UNKNOWN) <= 0; + *o = (unsigned long long)((SCT_SOURCE_UNKNOWN) | 0); /* check that SCT_SOURCE_UNKNOWN is an integer */ + return n; +} + +static int _cffi_const_SCT_SOURCE_TLS_EXTENSION(unsigned long long *o) +{ + int n = (SCT_SOURCE_TLS_EXTENSION) <= 0; + *o = (unsigned long long)((SCT_SOURCE_TLS_EXTENSION) | 0); /* check that SCT_SOURCE_TLS_EXTENSION is an integer */ + return n; +} + +static int _cffi_const_SCT_SOURCE_X509V3_EXTENSION(unsigned long long *o) +{ + int n = (SCT_SOURCE_X509V3_EXTENSION) <= 0; + *o = (unsigned long long)((SCT_SOURCE_X509V3_EXTENSION) | 0); /* check that SCT_SOURCE_X509V3_EXTENSION is an integer */ + return n; +} + +static int _cffi_const_SCT_SOURCE_OCSP_STAPLED_RESPONSE(unsigned long long *o) +{ + int n = (SCT_SOURCE_OCSP_STAPLED_RESPONSE) <= 0; + *o = (unsigned long long)((SCT_SOURCE_OCSP_STAPLED_RESPONSE) | 0); /* check that SCT_SOURCE_OCSP_STAPLED_RESPONSE is an integer */ + return n; +} + +static int _cffi_const_SCT_VERSION_NOT_SET(unsigned long long *o) +{ + int n = (SCT_VERSION_NOT_SET) <= 0; + *o = (unsigned long long)((SCT_VERSION_NOT_SET) | 0); /* check that SCT_VERSION_NOT_SET is an integer */ + return n; +} + +static int _cffi_const_SCT_VERSION_V1(unsigned long long *o) +{ + int n = (SCT_VERSION_V1) <= 0; + *o = (unsigned long long)((SCT_VERSION_V1) | 0); /* check that SCT_VERSION_V1 is an integer */ + return n; +} + +static int _cffi_const_CRYPTOGRAPHY_IS_LIBRESSL(unsigned long long *o) +{ + int n = (CRYPTOGRAPHY_IS_LIBRESSL) <= 0; + *o = (unsigned long long)((CRYPTOGRAPHY_IS_LIBRESSL) | 0); /* check that CRYPTOGRAPHY_IS_LIBRESSL is an integer */ + return n; +} + +static int _cffi_const_CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE(unsigned long long *o) +{ + int n = (CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE) <= 0; + *o = (unsigned long long)((CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE) | 0); /* check that CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE is an integer */ + return n; +} + +static int _cffi_const_CRYPTOGRAPHY_OPENSSL_110F_OR_GREATER(unsigned long long *o) +{ + int n = (CRYPTOGRAPHY_OPENSSL_110F_OR_GREATER) <= 0; + *o = (unsigned long long)((CRYPTOGRAPHY_OPENSSL_110F_OR_GREATER) | 0); /* check that CRYPTOGRAPHY_OPENSSL_110F_OR_GREATER is an integer */ + return n; +} + +static int _cffi_const_CRYPTOGRAPHY_OPENSSL_LESS_THAN_111(unsigned long long *o) +{ + int n = (CRYPTOGRAPHY_OPENSSL_LESS_THAN_111) <= 0; + *o = (unsigned long long)((CRYPTOGRAPHY_OPENSSL_LESS_THAN_111) | 0); /* check that CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 is an integer */ + return n; +} + +static int _cffi_const_CRYPTOGRAPHY_OPENSSL_LESS_THAN_111B(unsigned long long *o) +{ + int n = (CRYPTOGRAPHY_OPENSSL_LESS_THAN_111B) <= 0; + *o = (unsigned long long)((CRYPTOGRAPHY_OPENSSL_LESS_THAN_111B) | 0); /* check that CRYPTOGRAPHY_OPENSSL_LESS_THAN_111B is an integer */ + return n; +} + +static void _cffi_const_CRYPTOGRAPHY_PACKAGE_VERSION(char *o) +{ + *(char const * *)o = CRYPTOGRAPHY_PACKAGE_VERSION; +} + +static int _cffi_const_Cryptography_HAS_102_VERIFICATION(unsigned long long *o) +{ + int n = (Cryptography_HAS_102_VERIFICATION) <= 0; + *o = (unsigned long long)((Cryptography_HAS_102_VERIFICATION) | 0); /* check that Cryptography_HAS_102_VERIFICATION is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_110_VERIFICATION_PARAMS(unsigned long long *o) +{ + int n = (Cryptography_HAS_110_VERIFICATION_PARAMS) <= 0; + *o = (unsigned long long)((Cryptography_HAS_110_VERIFICATION_PARAMS) | 0); /* check that Cryptography_HAS_110_VERIFICATION_PARAMS is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_ALPN(unsigned long long *o) +{ + int n = (Cryptography_HAS_ALPN) <= 0; + *o = (unsigned long long)((Cryptography_HAS_ALPN) | 0); /* check that Cryptography_HAS_ALPN is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_CUSTOM_EXT(unsigned long long *o) +{ + int n = (Cryptography_HAS_CUSTOM_EXT) <= 0; + *o = (unsigned long long)((Cryptography_HAS_CUSTOM_EXT) | 0); /* check that Cryptography_HAS_CUSTOM_EXT is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_DTLS(unsigned long long *o) +{ + int n = (Cryptography_HAS_DTLS) <= 0; + *o = (unsigned long long)((Cryptography_HAS_DTLS) | 0); /* check that Cryptography_HAS_DTLS is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_EC2M(unsigned long long *o) +{ + int n = (Cryptography_HAS_EC2M) <= 0; + *o = (unsigned long long)((Cryptography_HAS_EC2M) | 0); /* check that Cryptography_HAS_EC2M is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_ED25519(unsigned long long *o) +{ + int n = (Cryptography_HAS_ED25519) <= 0; + *o = (unsigned long long)((Cryptography_HAS_ED25519) | 0); /* check that Cryptography_HAS_ED25519 is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_ED448(unsigned long long *o) +{ + int n = (Cryptography_HAS_ED448) <= 0; + *o = (unsigned long long)((Cryptography_HAS_ED448) | 0); /* check that Cryptography_HAS_ED448 is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_ENGINE(unsigned long long *o) +{ + int n = (Cryptography_HAS_ENGINE) <= 0; + *o = (unsigned long long)((Cryptography_HAS_ENGINE) | 0); /* check that Cryptography_HAS_ENGINE is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_EVP_DIGESTFINAL_XOF(unsigned long long *o) +{ + int n = (Cryptography_HAS_EVP_DIGESTFINAL_XOF) <= 0; + *o = (unsigned long long)((Cryptography_HAS_EVP_DIGESTFINAL_XOF) | 0); /* check that Cryptography_HAS_EVP_DIGESTFINAL_XOF is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_EVP_PKEY_DHX(unsigned long long *o) +{ + int n = (Cryptography_HAS_EVP_PKEY_DHX) <= 0; + *o = (unsigned long long)((Cryptography_HAS_EVP_PKEY_DHX) | 0); /* check that Cryptography_HAS_EVP_PKEY_DHX is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_EVP_PKEY_get_set_tls_encodedpoint(unsigned long long *o) +{ + int n = (Cryptography_HAS_EVP_PKEY_get_set_tls_encodedpoint) <= 0; + *o = (unsigned long long)((Cryptography_HAS_EVP_PKEY_get_set_tls_encodedpoint) | 0); /* check that Cryptography_HAS_EVP_PKEY_get_set_tls_encodedpoint is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_FIPS(unsigned long long *o) +{ + int n = (Cryptography_HAS_FIPS) <= 0; + *o = (unsigned long long)((Cryptography_HAS_FIPS) | 0); /* check that Cryptography_HAS_FIPS is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_GET_PROTO_VERSION(unsigned long long *o) +{ + int n = (Cryptography_HAS_GET_PROTO_VERSION) <= 0; + *o = (unsigned long long)((Cryptography_HAS_GET_PROTO_VERSION) | 0); /* check that Cryptography_HAS_GET_PROTO_VERSION is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_KEYLOG(unsigned long long *o) +{ + int n = (Cryptography_HAS_KEYLOG) <= 0; + *o = (unsigned long long)((Cryptography_HAS_KEYLOG) | 0); /* check that Cryptography_HAS_KEYLOG is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_MEM_FUNCTIONS(unsigned long long *o) +{ + int n = (Cryptography_HAS_MEM_FUNCTIONS) <= 0; + *o = (unsigned long long)((Cryptography_HAS_MEM_FUNCTIONS) | 0); /* check that Cryptography_HAS_MEM_FUNCTIONS is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_NEXTPROTONEG(unsigned long long *o) +{ + int n = (Cryptography_HAS_NEXTPROTONEG) <= 0; + *o = (unsigned long long)((Cryptography_HAS_NEXTPROTONEG) | 0); /* check that Cryptography_HAS_NEXTPROTONEG is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_ONESHOT_EVP_DIGEST_SIGN_VERIFY(unsigned long long *o) +{ + int n = (Cryptography_HAS_ONESHOT_EVP_DIGEST_SIGN_VERIFY) <= 0; + *o = (unsigned long long)((Cryptography_HAS_ONESHOT_EVP_DIGEST_SIGN_VERIFY) | 0); /* check that Cryptography_HAS_ONESHOT_EVP_DIGEST_SIGN_VERIFY is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_OPENSSL_CLEANUP(unsigned long long *o) +{ + int n = (Cryptography_HAS_OPENSSL_CLEANUP) <= 0; + *o = (unsigned long long)((Cryptography_HAS_OPENSSL_CLEANUP) | 0); /* check that Cryptography_HAS_OPENSSL_CLEANUP is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_OP_NO_COMPRESSION(unsigned long long *o) +{ + int n = (Cryptography_HAS_OP_NO_COMPRESSION) <= 0; + *o = (unsigned long long)((Cryptography_HAS_OP_NO_COMPRESSION) | 0); /* check that Cryptography_HAS_OP_NO_COMPRESSION is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_POLY1305(unsigned long long *o) +{ + int n = (Cryptography_HAS_POLY1305) <= 0; + *o = (unsigned long long)((Cryptography_HAS_POLY1305) | 0); /* check that Cryptography_HAS_POLY1305 is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_PSK(unsigned long long *o) +{ + int n = (Cryptography_HAS_PSK) <= 0; + *o = (unsigned long long)((Cryptography_HAS_PSK) | 0); /* check that Cryptography_HAS_PSK is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_RAW_KEY(unsigned long long *o) +{ + int n = (Cryptography_HAS_RAW_KEY) <= 0; + *o = (unsigned long long)((Cryptography_HAS_RAW_KEY) | 0); /* check that Cryptography_HAS_RAW_KEY is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_RELEASE_BUFFERS(unsigned long long *o) +{ + int n = (Cryptography_HAS_RELEASE_BUFFERS) <= 0; + *o = (unsigned long long)((Cryptography_HAS_RELEASE_BUFFERS) | 0); /* check that Cryptography_HAS_RELEASE_BUFFERS is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_RSA_OAEP_LABEL(unsigned long long *o) +{ + int n = (Cryptography_HAS_RSA_OAEP_LABEL) <= 0; + *o = (unsigned long long)((Cryptography_HAS_RSA_OAEP_LABEL) | 0); /* check that Cryptography_HAS_RSA_OAEP_LABEL is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_RSA_OAEP_MD(unsigned long long *o) +{ + int n = (Cryptography_HAS_RSA_OAEP_MD) <= 0; + *o = (unsigned long long)((Cryptography_HAS_RSA_OAEP_MD) | 0); /* check that Cryptography_HAS_RSA_OAEP_MD is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SCRYPT(unsigned long long *o) +{ + int n = (Cryptography_HAS_SCRYPT) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SCRYPT) | 0); /* check that Cryptography_HAS_SCRYPT is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SCT(unsigned long long *o) +{ + int n = (Cryptography_HAS_SCT) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SCT) | 0); /* check that Cryptography_HAS_SCT is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SECURE_RENEGOTIATION(unsigned long long *o) +{ + int n = (Cryptography_HAS_SECURE_RENEGOTIATION) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SECURE_RENEGOTIATION) | 0); /* check that Cryptography_HAS_SECURE_RENEGOTIATION is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SET_CERT_CB(unsigned long long *o) +{ + int n = (Cryptography_HAS_SET_CERT_CB) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SET_CERT_CB) | 0); /* check that Cryptography_HAS_SET_CERT_CB is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SIGALGS(unsigned long long *o) +{ + int n = (Cryptography_HAS_SIGALGS) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SIGALGS) | 0); /* check that Cryptography_HAS_SIGALGS is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SRTP(unsigned long long *o) +{ + int n = (Cryptography_HAS_SRTP) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SRTP) | 0); /* check that Cryptography_HAS_SRTP is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SSL3_METHOD(unsigned long long *o) +{ + int n = (Cryptography_HAS_SSL3_METHOD) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SSL3_METHOD) | 0); /* check that Cryptography_HAS_SSL3_METHOD is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SSL_CTX_CLEAR_OPTIONS(unsigned long long *o) +{ + int n = (Cryptography_HAS_SSL_CTX_CLEAR_OPTIONS) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SSL_CTX_CLEAR_OPTIONS) | 0); /* check that Cryptography_HAS_SSL_CTX_CLEAR_OPTIONS is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SSL_OP_MSIE_SSLV2_RSA_PADDING(unsigned long long *o) +{ + int n = (Cryptography_HAS_SSL_OP_MSIE_SSLV2_RSA_PADDING) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SSL_OP_MSIE_SSLV2_RSA_PADDING) | 0); /* check that Cryptography_HAS_SSL_OP_MSIE_SSLV2_RSA_PADDING is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SSL_OP_NO_TICKET(unsigned long long *o) +{ + int n = (Cryptography_HAS_SSL_OP_NO_TICKET) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SSL_OP_NO_TICKET) | 0); /* check that Cryptography_HAS_SSL_OP_NO_TICKET is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SSL_SET_SSL_CTX(unsigned long long *o) +{ + int n = (Cryptography_HAS_SSL_SET_SSL_CTX) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SSL_SET_SSL_CTX) | 0); /* check that Cryptography_HAS_SSL_SET_SSL_CTX is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_SSL_ST(unsigned long long *o) +{ + int n = (Cryptography_HAS_SSL_ST) <= 0; + *o = (unsigned long long)((Cryptography_HAS_SSL_ST) | 0); /* check that Cryptography_HAS_SSL_ST is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_TLSEXT_HOSTNAME(unsigned long long *o) +{ + int n = (Cryptography_HAS_TLSEXT_HOSTNAME) <= 0; + *o = (unsigned long long)((Cryptography_HAS_TLSEXT_HOSTNAME) | 0); /* check that Cryptography_HAS_TLSEXT_HOSTNAME is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_TLS_ST(unsigned long long *o) +{ + int n = (Cryptography_HAS_TLS_ST) <= 0; + *o = (unsigned long long)((Cryptography_HAS_TLS_ST) | 0); /* check that Cryptography_HAS_TLS_ST is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_TLSv1_1(unsigned long long *o) +{ + int n = (Cryptography_HAS_TLSv1_1) <= 0; + *o = (unsigned long long)((Cryptography_HAS_TLSv1_1) | 0); /* check that Cryptography_HAS_TLSv1_1 is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_TLSv1_2(unsigned long long *o) +{ + int n = (Cryptography_HAS_TLSv1_2) <= 0; + *o = (unsigned long long)((Cryptography_HAS_TLSv1_2) | 0); /* check that Cryptography_HAS_TLSv1_2 is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_TLSv1_3(unsigned long long *o) +{ + int n = (Cryptography_HAS_TLSv1_3) <= 0; + *o = (unsigned long long)((Cryptography_HAS_TLSv1_3) | 0); /* check that Cryptography_HAS_TLSv1_3 is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_VERIFIED_CHAIN(unsigned long long *o) +{ + int n = (Cryptography_HAS_VERIFIED_CHAIN) <= 0; + *o = (unsigned long long)((Cryptography_HAS_VERIFIED_CHAIN) | 0); /* check that Cryptography_HAS_VERIFIED_CHAIN is an integer */ + return n; +} + +static int _cffi_const_Cryptography_HAS_X509_STORE_CTX_GET_ISSUER(unsigned long long *o) +{ + int n = (Cryptography_HAS_X509_STORE_CTX_GET_ISSUER) <= 0; + *o = (unsigned long long)((Cryptography_HAS_X509_STORE_CTX_GET_ISSUER) | 0); /* check that Cryptography_HAS_X509_STORE_CTX_GET_ISSUER is an integer */ + return n; +} + +static void _cffi_const_Cryptography_osrandom_engine_id(char *o) +{ + *(char const * *)o = Cryptography_osrandom_engine_id; +} + +static void _cffi_const_Cryptography_osrandom_engine_name(char *o) +{ + *(char const * *)o = Cryptography_osrandom_engine_name; +} + +static int _cffi_const_DH_NOT_SUITABLE_GENERATOR(unsigned long long *o) +{ + int n = (DH_NOT_SUITABLE_GENERATOR) <= 0; + *o = (unsigned long long)((DH_NOT_SUITABLE_GENERATOR) | 0); /* check that DH_NOT_SUITABLE_GENERATOR is an integer */ + return n; +} + +static int _cffi_const_ERR_LIB_ASN1(unsigned long long *o) +{ + int n = (ERR_LIB_ASN1) <= 0; + *o = (unsigned long long)((ERR_LIB_ASN1) | 0); /* check that ERR_LIB_ASN1 is an integer */ + return n; +} + +static int _cffi_const_ERR_LIB_EVP(unsigned long long *o) +{ + int n = (ERR_LIB_EVP) <= 0; + *o = (unsigned long long)((ERR_LIB_EVP) | 0); /* check that ERR_LIB_EVP is an integer */ + return n; +} + +static int _cffi_const_ERR_LIB_PEM(unsigned long long *o) +{ + int n = (ERR_LIB_PEM) <= 0; + *o = (unsigned long long)((ERR_LIB_PEM) | 0); /* check that ERR_LIB_PEM is an integer */ + return n; +} + +static int _cffi_const_ERR_LIB_PKCS12(unsigned long long *o) +{ + int n = (ERR_LIB_PKCS12) <= 0; + *o = (unsigned long long)((ERR_LIB_PKCS12) | 0); /* check that ERR_LIB_PKCS12 is an integer */ + return n; +} + +static int _cffi_const_EVP_CTRL_AEAD_GET_TAG(unsigned long long *o) +{ + int n = (EVP_CTRL_AEAD_GET_TAG) <= 0; + *o = (unsigned long long)((EVP_CTRL_AEAD_GET_TAG) | 0); /* check that EVP_CTRL_AEAD_GET_TAG is an integer */ + return n; +} + +static int _cffi_const_EVP_CTRL_AEAD_SET_IVLEN(unsigned long long *o) +{ + int n = (EVP_CTRL_AEAD_SET_IVLEN) <= 0; + *o = (unsigned long long)((EVP_CTRL_AEAD_SET_IVLEN) | 0); /* check that EVP_CTRL_AEAD_SET_IVLEN is an integer */ + return n; +} + +static int _cffi_const_EVP_CTRL_AEAD_SET_TAG(unsigned long long *o) +{ + int n = (EVP_CTRL_AEAD_SET_TAG) <= 0; + *o = (unsigned long long)((EVP_CTRL_AEAD_SET_TAG) | 0); /* check that EVP_CTRL_AEAD_SET_TAG is an integer */ + return n; +} + +static int _cffi_const_EVP_F_EVP_ENCRYPTFINAL_EX(unsigned long long *o) +{ + int n = (EVP_F_EVP_ENCRYPTFINAL_EX) <= 0; + *o = (unsigned long long)((EVP_F_EVP_ENCRYPTFINAL_EX) | 0); /* check that EVP_F_EVP_ENCRYPTFINAL_EX is an integer */ + return n; +} + +static int _cffi_const_EVP_MAX_MD_SIZE(unsigned long long *o) +{ + int n = (EVP_MAX_MD_SIZE) <= 0; + *o = (unsigned long long)((EVP_MAX_MD_SIZE) | 0); /* check that EVP_MAX_MD_SIZE is an integer */ + return n; +} + +static int _cffi_const_EVP_PKEY_DH(unsigned long long *o) +{ + int n = (EVP_PKEY_DH) <= 0; + *o = (unsigned long long)((EVP_PKEY_DH) | 0); /* check that EVP_PKEY_DH is an integer */ + return n; +} + +static int _cffi_const_EVP_PKEY_DHX(unsigned long long *o) +{ + int n = (EVP_PKEY_DHX) <= 0; + *o = (unsigned long long)((EVP_PKEY_DHX) | 0); /* check that EVP_PKEY_DHX is an integer */ + return n; +} + +static int _cffi_const_EVP_PKEY_DSA(unsigned long long *o) +{ + int n = (EVP_PKEY_DSA) <= 0; + *o = (unsigned long long)((EVP_PKEY_DSA) | 0); /* check that EVP_PKEY_DSA is an integer */ + return n; +} + +static int _cffi_const_EVP_PKEY_EC(unsigned long long *o) +{ + int n = (EVP_PKEY_EC) <= 0; + *o = (unsigned long long)((EVP_PKEY_EC) | 0); /* check that EVP_PKEY_EC is an integer */ + return n; +} + +static int _cffi_const_EVP_PKEY_ED25519(unsigned long long *o) +{ + int n = (EVP_PKEY_ED25519) <= 0; + *o = (unsigned long long)((EVP_PKEY_ED25519) | 0); /* check that EVP_PKEY_ED25519 is an integer */ + return n; +} + +static int _cffi_const_EVP_PKEY_ED448(unsigned long long *o) +{ + int n = (EVP_PKEY_ED448) <= 0; + *o = (unsigned long long)((EVP_PKEY_ED448) | 0); /* check that EVP_PKEY_ED448 is an integer */ + return n; +} + +static int _cffi_const_EVP_PKEY_POLY1305(unsigned long long *o) +{ + int n = (EVP_PKEY_POLY1305) <= 0; + *o = (unsigned long long)((EVP_PKEY_POLY1305) | 0); /* check that EVP_PKEY_POLY1305 is an integer */ + return n; +} + +static int _cffi_const_EVP_PKEY_RSA(unsigned long long *o) +{ + int n = (EVP_PKEY_RSA) <= 0; + *o = (unsigned long long)((EVP_PKEY_RSA) | 0); /* check that EVP_PKEY_RSA is an integer */ + return n; +} + +static int _cffi_const_EVP_PKEY_X25519(unsigned long long *o) +{ + int n = (EVP_PKEY_X25519) <= 0; + *o = (unsigned long long)((EVP_PKEY_X25519) | 0); /* check that EVP_PKEY_X25519 is an integer */ + return n; +} + +static int _cffi_const_EVP_PKEY_X448(unsigned long long *o) +{ + int n = (EVP_PKEY_X448) <= 0; + *o = (unsigned long long)((EVP_PKEY_X448) | 0); /* check that EVP_PKEY_X448 is an integer */ + return n; +} + +static int _cffi_const_EVP_R_BAD_DECRYPT(unsigned long long *o) +{ + int n = (EVP_R_BAD_DECRYPT) <= 0; + *o = (unsigned long long)((EVP_R_BAD_DECRYPT) | 0); /* check that EVP_R_BAD_DECRYPT is an integer */ + return n; +} + +static int _cffi_const_EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH(unsigned long long *o) +{ + int n = (EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH) <= 0; + *o = (unsigned long long)((EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH) | 0); /* check that EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH is an integer */ + return n; +} + +static int _cffi_const_EVP_R_UNKNOWN_PBE_ALGORITHM(unsigned long long *o) +{ + int n = (EVP_R_UNKNOWN_PBE_ALGORITHM) <= 0; + *o = (unsigned long long)((EVP_R_UNKNOWN_PBE_ALGORITHM) | 0); /* check that EVP_R_UNKNOWN_PBE_ALGORITHM is an integer */ + return n; +} + +static int _cffi_const_EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM(unsigned long long *o) +{ + int n = (EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM) <= 0; + *o = (unsigned long long)((EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM) | 0); /* check that EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM is an integer */ + return n; +} + +static int _cffi_const_GEN_DIRNAME(unsigned long long *o) +{ + int n = (GEN_DIRNAME) <= 0; + *o = (unsigned long long)((GEN_DIRNAME) | 0); /* check that GEN_DIRNAME is an integer */ + return n; +} + +static int _cffi_const_GEN_DNS(unsigned long long *o) +{ + int n = (GEN_DNS) <= 0; + *o = (unsigned long long)((GEN_DNS) | 0); /* check that GEN_DNS is an integer */ + return n; +} + +static int _cffi_const_GEN_EDIPARTY(unsigned long long *o) +{ + int n = (GEN_EDIPARTY) <= 0; + *o = (unsigned long long)((GEN_EDIPARTY) | 0); /* check that GEN_EDIPARTY is an integer */ + return n; +} + +static int _cffi_const_GEN_EMAIL(unsigned long long *o) +{ + int n = (GEN_EMAIL) <= 0; + *o = (unsigned long long)((GEN_EMAIL) | 0); /* check that GEN_EMAIL is an integer */ + return n; +} + +static int _cffi_const_GEN_IPADD(unsigned long long *o) +{ + int n = (GEN_IPADD) <= 0; + *o = (unsigned long long)((GEN_IPADD) | 0); /* check that GEN_IPADD is an integer */ + return n; +} + +static int _cffi_const_GEN_OTHERNAME(unsigned long long *o) +{ + int n = (GEN_OTHERNAME) <= 0; + *o = (unsigned long long)((GEN_OTHERNAME) | 0); /* check that GEN_OTHERNAME is an integer */ + return n; +} + +static int _cffi_const_GEN_RID(unsigned long long *o) +{ + int n = (GEN_RID) <= 0; + *o = (unsigned long long)((GEN_RID) | 0); /* check that GEN_RID is an integer */ + return n; +} + +static int _cffi_const_GEN_URI(unsigned long long *o) +{ + int n = (GEN_URI) <= 0; + *o = (unsigned long long)((GEN_URI) | 0); /* check that GEN_URI is an integer */ + return n; +} + +static int _cffi_const_GEN_X400(unsigned long long *o) +{ + int n = (GEN_X400) <= 0; + *o = (unsigned long long)((GEN_X400) | 0); /* check that GEN_X400 is an integer */ + return n; +} + +static int _cffi_const_MBSTRING_UTF8(unsigned long long *o) +{ + int n = (MBSTRING_UTF8) <= 0; + *o = (unsigned long long)((MBSTRING_UTF8) | 0); /* check that MBSTRING_UTF8 is an integer */ + return n; +} + +static int _cffi_const_NID_ED25519(unsigned long long *o) +{ + int n = (NID_ED25519) <= 0; + *o = (unsigned long long)((NID_ED25519) | 0); /* check that NID_ED25519 is an integer */ + return n; +} + +static int _cffi_const_NID_ED448(unsigned long long *o) +{ + int n = (NID_ED448) <= 0; + *o = (unsigned long long)((NID_ED448) | 0); /* check that NID_ED448 is an integer */ + return n; +} + +static int _cffi_const_NID_X25519(unsigned long long *o) +{ + int n = (NID_X25519) <= 0; + *o = (unsigned long long)((NID_X25519) | 0); /* check that NID_X25519 is an integer */ + return n; +} + +static int _cffi_const_NID_X448(unsigned long long *o) +{ + int n = (NID_X448) <= 0; + *o = (unsigned long long)((NID_X448) | 0); /* check that NID_X448 is an integer */ + return n; +} + +static int _cffi_const_NID_crl_reason(unsigned long long *o) +{ + int n = (NID_crl_reason) <= 0; + *o = (unsigned long long)((NID_crl_reason) | 0); /* check that NID_crl_reason is an integer */ + return n; +} + +static int _cffi_const_NID_pbe_WithSHA1And3_Key_TripleDES_CBC(unsigned long long *o) +{ + int n = (NID_pbe_WithSHA1And3_Key_TripleDES_CBC) <= 0; + *o = (unsigned long long)((NID_pbe_WithSHA1And3_Key_TripleDES_CBC) | 0); /* check that NID_pbe_WithSHA1And3_Key_TripleDES_CBC is an integer */ + return n; +} + +static int _cffi_const_NID_pkcs7_signed(unsigned long long *o) +{ + int n = (NID_pkcs7_signed) <= 0; + *o = (unsigned long long)((NID_pkcs7_signed) | 0); /* check that NID_pkcs7_signed is an integer */ + return n; +} + +static int _cffi_const_NID_poly1305(unsigned long long *o) +{ + int n = (NID_poly1305) <= 0; + *o = (unsigned long long)((NID_poly1305) | 0); /* check that NID_poly1305 is an integer */ + return n; +} + +static int _cffi_const_NID_subject_alt_name(unsigned long long *o) +{ + int n = (NID_subject_alt_name) <= 0; + *o = (unsigned long long)((NID_subject_alt_name) | 0); /* check that NID_subject_alt_name is an integer */ + return n; +} + +static int _cffi_const_NID_undef(unsigned long long *o) +{ + int n = (NID_undef) <= 0; + *o = (unsigned long long)((NID_undef) | 0); /* check that NID_undef is an integer */ + return n; +} + +static int _cffi_const_OBJ_NAME_TYPE_MD_METH(unsigned long long *o) +{ + int n = (OBJ_NAME_TYPE_MD_METH) <= 0; + *o = (unsigned long long)((OBJ_NAME_TYPE_MD_METH) | 0); /* check that OBJ_NAME_TYPE_MD_METH is an integer */ + return n; +} + +static int _cffi_const_OCSP_NOCERTS(unsigned long long *o) +{ + int n = (OCSP_NOCERTS) <= 0; + *o = (unsigned long long)((OCSP_NOCERTS) | 0); /* check that OCSP_NOCERTS is an integer */ + return n; +} + +static int _cffi_const_OCSP_RESPID_KEY(unsigned long long *o) +{ + int n = (OCSP_RESPID_KEY) <= 0; + *o = (unsigned long long)((OCSP_RESPID_KEY) | 0); /* check that OCSP_RESPID_KEY is an integer */ + return n; +} + +static int _cffi_const_OPENSSL_BUILT_ON(unsigned long long *o) +{ + int n = (OPENSSL_BUILT_ON) <= 0; + *o = (unsigned long long)((OPENSSL_BUILT_ON) | 0); /* check that OPENSSL_BUILT_ON is an integer */ + return n; +} + +static int _cffi_const_OPENSSL_CFLAGS(unsigned long long *o) +{ + int n = (OPENSSL_CFLAGS) <= 0; + *o = (unsigned long long)((OPENSSL_CFLAGS) | 0); /* check that OPENSSL_CFLAGS is an integer */ + return n; +} + +static int _cffi_const_OPENSSL_DIR(unsigned long long *o) +{ + int n = (OPENSSL_DIR) <= 0; + *o = (unsigned long long)((OPENSSL_DIR) | 0); /* check that OPENSSL_DIR is an integer */ + return n; +} + +static int _cffi_const_OPENSSL_EC_NAMED_CURVE(unsigned long long *o) +{ + int n = (OPENSSL_EC_NAMED_CURVE) <= 0; + *o = (unsigned long long)((OPENSSL_EC_NAMED_CURVE) | 0); /* check that OPENSSL_EC_NAMED_CURVE is an integer */ + return n; +} + +static int _cffi_const_OPENSSL_PLATFORM(unsigned long long *o) +{ + int n = (OPENSSL_PLATFORM) <= 0; + *o = (unsigned long long)((OPENSSL_PLATFORM) | 0); /* check that OPENSSL_PLATFORM is an integer */ + return n; +} + +static int _cffi_const_OPENSSL_VERSION(unsigned long long *o) +{ + int n = (OPENSSL_VERSION) <= 0; + *o = (unsigned long long)((OPENSSL_VERSION) | 0); /* check that OPENSSL_VERSION is an integer */ + return n; +} + +static int _cffi_const_OPENSSL_VERSION_NUMBER(unsigned long long *o) +{ + int n = (OPENSSL_VERSION_NUMBER) <= 0; + *o = (unsigned long long)((OPENSSL_VERSION_NUMBER) | 0); /* check that OPENSSL_VERSION_NUMBER is an integer */ + return n; +} + +static void _cffi_const_OPENSSL_VERSION_TEXT(char *o) +{ + *(char const * *)o = OPENSSL_VERSION_TEXT; +} + +static int _cffi_const_PEM_R_UNSUPPORTED_ENCRYPTION(unsigned long long *o) +{ + int n = (PEM_R_UNSUPPORTED_ENCRYPTION) <= 0; + *o = (unsigned long long)((PEM_R_UNSUPPORTED_ENCRYPTION) | 0); /* check that PEM_R_UNSUPPORTED_ENCRYPTION is an integer */ + return n; +} + +static int _cffi_const_PKCS12_R_PKCS12_CIPHERFINAL_ERROR(unsigned long long *o) +{ + int n = (PKCS12_R_PKCS12_CIPHERFINAL_ERROR) <= 0; + *o = (unsigned long long)((PKCS12_R_PKCS12_CIPHERFINAL_ERROR) | 0); /* check that PKCS12_R_PKCS12_CIPHERFINAL_ERROR is an integer */ + return n; +} + +static int _cffi_const_PKCS7_BINARY(unsigned long long *o) +{ + int n = (PKCS7_BINARY) <= 0; + *o = (unsigned long long)((PKCS7_BINARY) | 0); /* check that PKCS7_BINARY is an integer */ + return n; +} + +static int _cffi_const_PKCS7_DETACHED(unsigned long long *o) +{ + int n = (PKCS7_DETACHED) <= 0; + *o = (unsigned long long)((PKCS7_DETACHED) | 0); /* check that PKCS7_DETACHED is an integer */ + return n; +} + +static int _cffi_const_PKCS7_NOATTR(unsigned long long *o) +{ + int n = (PKCS7_NOATTR) <= 0; + *o = (unsigned long long)((PKCS7_NOATTR) | 0); /* check that PKCS7_NOATTR is an integer */ + return n; +} + +static int _cffi_const_PKCS7_NOCERTS(unsigned long long *o) +{ + int n = (PKCS7_NOCERTS) <= 0; + *o = (unsigned long long)((PKCS7_NOCERTS) | 0); /* check that PKCS7_NOCERTS is an integer */ + return n; +} + +static int _cffi_const_PKCS7_NOCHAIN(unsigned long long *o) +{ + int n = (PKCS7_NOCHAIN) <= 0; + *o = (unsigned long long)((PKCS7_NOCHAIN) | 0); /* check that PKCS7_NOCHAIN is an integer */ + return n; +} + +static int _cffi_const_PKCS7_NOINTERN(unsigned long long *o) +{ + int n = (PKCS7_NOINTERN) <= 0; + *o = (unsigned long long)((PKCS7_NOINTERN) | 0); /* check that PKCS7_NOINTERN is an integer */ + return n; +} + +static int _cffi_const_PKCS7_NOSIGS(unsigned long long *o) +{ + int n = (PKCS7_NOSIGS) <= 0; + *o = (unsigned long long)((PKCS7_NOSIGS) | 0); /* check that PKCS7_NOSIGS is an integer */ + return n; +} + +static int _cffi_const_PKCS7_NOSMIMECAP(unsigned long long *o) +{ + int n = (PKCS7_NOSMIMECAP) <= 0; + *o = (unsigned long long)((PKCS7_NOSMIMECAP) | 0); /* check that PKCS7_NOSMIMECAP is an integer */ + return n; +} + +static int _cffi_const_PKCS7_NOVERIFY(unsigned long long *o) +{ + int n = (PKCS7_NOVERIFY) <= 0; + *o = (unsigned long long)((PKCS7_NOVERIFY) | 0); /* check that PKCS7_NOVERIFY is an integer */ + return n; +} + +static int _cffi_const_PKCS7_PARTIAL(unsigned long long *o) +{ + int n = (PKCS7_PARTIAL) <= 0; + *o = (unsigned long long)((PKCS7_PARTIAL) | 0); /* check that PKCS7_PARTIAL is an integer */ + return n; +} + +static int _cffi_const_PKCS7_STREAM(unsigned long long *o) +{ + int n = (PKCS7_STREAM) <= 0; + *o = (unsigned long long)((PKCS7_STREAM) | 0); /* check that PKCS7_STREAM is an integer */ + return n; +} + +static int _cffi_const_PKCS7_TEXT(unsigned long long *o) +{ + int n = (PKCS7_TEXT) <= 0; + *o = (unsigned long long)((PKCS7_TEXT) | 0); /* check that PKCS7_TEXT is an integer */ + return n; +} + +static int _cffi_const_RSA_F4(unsigned long long *o) +{ + int n = (RSA_F4) <= 0; + *o = (unsigned long long)((RSA_F4) | 0); /* check that RSA_F4 is an integer */ + return n; +} + +static int _cffi_const_RSA_NO_PADDING(unsigned long long *o) +{ + int n = (RSA_NO_PADDING) <= 0; + *o = (unsigned long long)((RSA_NO_PADDING) | 0); /* check that RSA_NO_PADDING is an integer */ + return n; +} + +static int _cffi_const_RSA_PKCS1_OAEP_PADDING(unsigned long long *o) +{ + int n = (RSA_PKCS1_OAEP_PADDING) <= 0; + *o = (unsigned long long)((RSA_PKCS1_OAEP_PADDING) | 0); /* check that RSA_PKCS1_OAEP_PADDING is an integer */ + return n; +} + +static int _cffi_const_RSA_PKCS1_PADDING(unsigned long long *o) +{ + int n = (RSA_PKCS1_PADDING) <= 0; + *o = (unsigned long long)((RSA_PKCS1_PADDING) | 0); /* check that RSA_PKCS1_PADDING is an integer */ + return n; +} + +static int _cffi_const_RSA_PKCS1_PSS_PADDING(unsigned long long *o) +{ + int n = (RSA_PKCS1_PSS_PADDING) <= 0; + *o = (unsigned long long)((RSA_PKCS1_PSS_PADDING) | 0); /* check that RSA_PKCS1_PSS_PADDING is an integer */ + return n; +} + +static int _cffi_const_SSL3_RANDOM_SIZE(unsigned long long *o) +{ + int n = (SSL3_RANDOM_SIZE) <= 0; + *o = (unsigned long long)((SSL3_RANDOM_SIZE) | 0); /* check that SSL3_RANDOM_SIZE is an integer */ + return n; +} + +static int _cffi_const_SSLEAY_BUILT_ON(unsigned long long *o) +{ + int n = (SSLEAY_BUILT_ON) <= 0; + *o = (unsigned long long)((SSLEAY_BUILT_ON) | 0); /* check that SSLEAY_BUILT_ON is an integer */ + return n; +} + +static int _cffi_const_SSLEAY_CFLAGS(unsigned long long *o) +{ + int n = (SSLEAY_CFLAGS) <= 0; + *o = (unsigned long long)((SSLEAY_CFLAGS) | 0); /* check that SSLEAY_CFLAGS is an integer */ + return n; +} + +static int _cffi_const_SSLEAY_DIR(unsigned long long *o) +{ + int n = (SSLEAY_DIR) <= 0; + *o = (unsigned long long)((SSLEAY_DIR) | 0); /* check that SSLEAY_DIR is an integer */ + return n; +} + +static int _cffi_const_SSLEAY_PLATFORM(unsigned long long *o) +{ + int n = (SSLEAY_PLATFORM) <= 0; + *o = (unsigned long long)((SSLEAY_PLATFORM) | 0); /* check that SSLEAY_PLATFORM is an integer */ + return n; +} + +static int _cffi_const_SSLEAY_VERSION(unsigned long long *o) +{ + int n = (SSLEAY_VERSION) <= 0; + *o = (unsigned long long)((SSLEAY_VERSION) | 0); /* check that SSLEAY_VERSION is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_ACCEPT_EXIT(unsigned long long *o) +{ + int n = (SSL_CB_ACCEPT_EXIT) <= 0; + *o = (unsigned long long)((SSL_CB_ACCEPT_EXIT) | 0); /* check that SSL_CB_ACCEPT_EXIT is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_ACCEPT_LOOP(unsigned long long *o) +{ + int n = (SSL_CB_ACCEPT_LOOP) <= 0; + *o = (unsigned long long)((SSL_CB_ACCEPT_LOOP) | 0); /* check that SSL_CB_ACCEPT_LOOP is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_ALERT(unsigned long long *o) +{ + int n = (SSL_CB_ALERT) <= 0; + *o = (unsigned long long)((SSL_CB_ALERT) | 0); /* check that SSL_CB_ALERT is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_CONNECT_EXIT(unsigned long long *o) +{ + int n = (SSL_CB_CONNECT_EXIT) <= 0; + *o = (unsigned long long)((SSL_CB_CONNECT_EXIT) | 0); /* check that SSL_CB_CONNECT_EXIT is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_CONNECT_LOOP(unsigned long long *o) +{ + int n = (SSL_CB_CONNECT_LOOP) <= 0; + *o = (unsigned long long)((SSL_CB_CONNECT_LOOP) | 0); /* check that SSL_CB_CONNECT_LOOP is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_EXIT(unsigned long long *o) +{ + int n = (SSL_CB_EXIT) <= 0; + *o = (unsigned long long)((SSL_CB_EXIT) | 0); /* check that SSL_CB_EXIT is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_HANDSHAKE_DONE(unsigned long long *o) +{ + int n = (SSL_CB_HANDSHAKE_DONE) <= 0; + *o = (unsigned long long)((SSL_CB_HANDSHAKE_DONE) | 0); /* check that SSL_CB_HANDSHAKE_DONE is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_HANDSHAKE_START(unsigned long long *o) +{ + int n = (SSL_CB_HANDSHAKE_START) <= 0; + *o = (unsigned long long)((SSL_CB_HANDSHAKE_START) | 0); /* check that SSL_CB_HANDSHAKE_START is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_LOOP(unsigned long long *o) +{ + int n = (SSL_CB_LOOP) <= 0; + *o = (unsigned long long)((SSL_CB_LOOP) | 0); /* check that SSL_CB_LOOP is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_READ(unsigned long long *o) +{ + int n = (SSL_CB_READ) <= 0; + *o = (unsigned long long)((SSL_CB_READ) | 0); /* check that SSL_CB_READ is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_READ_ALERT(unsigned long long *o) +{ + int n = (SSL_CB_READ_ALERT) <= 0; + *o = (unsigned long long)((SSL_CB_READ_ALERT) | 0); /* check that SSL_CB_READ_ALERT is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_WRITE(unsigned long long *o) +{ + int n = (SSL_CB_WRITE) <= 0; + *o = (unsigned long long)((SSL_CB_WRITE) | 0); /* check that SSL_CB_WRITE is an integer */ + return n; +} + +static int _cffi_const_SSL_CB_WRITE_ALERT(unsigned long long *o) +{ + int n = (SSL_CB_WRITE_ALERT) <= 0; + *o = (unsigned long long)((SSL_CB_WRITE_ALERT) | 0); /* check that SSL_CB_WRITE_ALERT is an integer */ + return n; +} + +static int _cffi_const_SSL_ERROR_NONE(unsigned long long *o) +{ + int n = (SSL_ERROR_NONE) <= 0; + *o = (unsigned long long)((SSL_ERROR_NONE) | 0); /* check that SSL_ERROR_NONE is an integer */ + return n; +} + +static int _cffi_const_SSL_ERROR_SSL(unsigned long long *o) +{ + int n = (SSL_ERROR_SSL) <= 0; + *o = (unsigned long long)((SSL_ERROR_SSL) | 0); /* check that SSL_ERROR_SSL is an integer */ + return n; +} + +static int _cffi_const_SSL_ERROR_SYSCALL(unsigned long long *o) +{ + int n = (SSL_ERROR_SYSCALL) <= 0; + *o = (unsigned long long)((SSL_ERROR_SYSCALL) | 0); /* check that SSL_ERROR_SYSCALL is an integer */ + return n; +} + +static int _cffi_const_SSL_ERROR_WANT_CONNECT(unsigned long long *o) +{ + int n = (SSL_ERROR_WANT_CONNECT) <= 0; + *o = (unsigned long long)((SSL_ERROR_WANT_CONNECT) | 0); /* check that SSL_ERROR_WANT_CONNECT is an integer */ + return n; +} + +static int _cffi_const_SSL_ERROR_WANT_READ(unsigned long long *o) +{ + int n = (SSL_ERROR_WANT_READ) <= 0; + *o = (unsigned long long)((SSL_ERROR_WANT_READ) | 0); /* check that SSL_ERROR_WANT_READ is an integer */ + return n; +} + +static int _cffi_const_SSL_ERROR_WANT_WRITE(unsigned long long *o) +{ + int n = (SSL_ERROR_WANT_WRITE) <= 0; + *o = (unsigned long long)((SSL_ERROR_WANT_WRITE) | 0); /* check that SSL_ERROR_WANT_WRITE is an integer */ + return n; +} + +static int _cffi_const_SSL_ERROR_WANT_X509_LOOKUP(unsigned long long *o) +{ + int n = (SSL_ERROR_WANT_X509_LOOKUP) <= 0; + *o = (unsigned long long)((SSL_ERROR_WANT_X509_LOOKUP) | 0); /* check that SSL_ERROR_WANT_X509_LOOKUP is an integer */ + return n; +} + +static int _cffi_const_SSL_ERROR_ZERO_RETURN(unsigned long long *o) +{ + int n = (SSL_ERROR_ZERO_RETURN) <= 0; + *o = (unsigned long long)((SSL_ERROR_ZERO_RETURN) | 0); /* check that SSL_ERROR_ZERO_RETURN is an integer */ + return n; +} + +static int _cffi_const_SSL_FILETYPE_ASN1(unsigned long long *o) +{ + int n = (SSL_FILETYPE_ASN1) <= 0; + *o = (unsigned long long)((SSL_FILETYPE_ASN1) | 0); /* check that SSL_FILETYPE_ASN1 is an integer */ + return n; +} + +static int _cffi_const_SSL_FILETYPE_PEM(unsigned long long *o) +{ + int n = (SSL_FILETYPE_PEM) <= 0; + *o = (unsigned long long)((SSL_FILETYPE_PEM) | 0); /* check that SSL_FILETYPE_PEM is an integer */ + return n; +} + +static int _cffi_const_SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER(unsigned long long *o) +{ + int n = (SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER) <= 0; + *o = (unsigned long long)((SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER) | 0); /* check that SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER is an integer */ + return n; +} + +static int _cffi_const_SSL_MODE_AUTO_RETRY(unsigned long long *o) +{ + int n = (SSL_MODE_AUTO_RETRY) <= 0; + *o = (unsigned long long)((SSL_MODE_AUTO_RETRY) | 0); /* check that SSL_MODE_AUTO_RETRY is an integer */ + return n; +} + +static int _cffi_const_SSL_MODE_ENABLE_PARTIAL_WRITE(unsigned long long *o) +{ + int n = (SSL_MODE_ENABLE_PARTIAL_WRITE) <= 0; + *o = (unsigned long long)((SSL_MODE_ENABLE_PARTIAL_WRITE) | 0); /* check that SSL_MODE_ENABLE_PARTIAL_WRITE is an integer */ + return n; +} + +static int _cffi_const_SSL_MODE_RELEASE_BUFFERS(unsigned long long *o) +{ + int n = (SSL_MODE_RELEASE_BUFFERS) <= 0; + *o = (unsigned long long)((SSL_MODE_RELEASE_BUFFERS) | 0); /* check that SSL_MODE_RELEASE_BUFFERS is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_ALL(unsigned long long *o) +{ + int n = (SSL_OP_ALL) <= 0; + *o = (unsigned long long)((SSL_OP_ALL) | 0); /* check that SSL_OP_ALL is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION(unsigned long long *o) +{ + int n = (SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION) <= 0; + *o = (unsigned long long)((SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION) | 0); /* check that SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_CIPHER_SERVER_PREFERENCE(unsigned long long *o) +{ + int n = (SSL_OP_CIPHER_SERVER_PREFERENCE) <= 0; + *o = (unsigned long long)((SSL_OP_CIPHER_SERVER_PREFERENCE) | 0); /* check that SSL_OP_CIPHER_SERVER_PREFERENCE is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_COOKIE_EXCHANGE(unsigned long long *o) +{ + int n = (SSL_OP_COOKIE_EXCHANGE) <= 0; + *o = (unsigned long long)((SSL_OP_COOKIE_EXCHANGE) | 0); /* check that SSL_OP_COOKIE_EXCHANGE is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS(unsigned long long *o) +{ + int n = (SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) <= 0; + *o = (unsigned long long)((SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) | 0); /* check that SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_EPHEMERAL_RSA(unsigned long long *o) +{ + int n = (SSL_OP_EPHEMERAL_RSA) <= 0; + *o = (unsigned long long)((SSL_OP_EPHEMERAL_RSA) | 0); /* check that SSL_OP_EPHEMERAL_RSA is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_LEGACY_SERVER_CONNECT(unsigned long long *o) +{ + int n = (SSL_OP_LEGACY_SERVER_CONNECT) <= 0; + *o = (unsigned long long)((SSL_OP_LEGACY_SERVER_CONNECT) | 0); /* check that SSL_OP_LEGACY_SERVER_CONNECT is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER(unsigned long long *o) +{ + int n = (SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER) <= 0; + *o = (unsigned long long)((SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER) | 0); /* check that SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_MICROSOFT_SESS_ID_BUG(unsigned long long *o) +{ + int n = (SSL_OP_MICROSOFT_SESS_ID_BUG) <= 0; + *o = (unsigned long long)((SSL_OP_MICROSOFT_SESS_ID_BUG) | 0); /* check that SSL_OP_MICROSOFT_SESS_ID_BUG is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_MSIE_SSLV2_RSA_PADDING(unsigned long long *o) +{ + int n = (SSL_OP_MSIE_SSLV2_RSA_PADDING) <= 0; + *o = (unsigned long long)((SSL_OP_MSIE_SSLV2_RSA_PADDING) | 0); /* check that SSL_OP_MSIE_SSLV2_RSA_PADDING is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NETSCAPE_CA_DN_BUG(unsigned long long *o) +{ + int n = (SSL_OP_NETSCAPE_CA_DN_BUG) <= 0; + *o = (unsigned long long)((SSL_OP_NETSCAPE_CA_DN_BUG) | 0); /* check that SSL_OP_NETSCAPE_CA_DN_BUG is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NETSCAPE_CHALLENGE_BUG(unsigned long long *o) +{ + int n = (SSL_OP_NETSCAPE_CHALLENGE_BUG) <= 0; + *o = (unsigned long long)((SSL_OP_NETSCAPE_CHALLENGE_BUG) | 0); /* check that SSL_OP_NETSCAPE_CHALLENGE_BUG is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG(unsigned long long *o) +{ + int n = (SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG) <= 0; + *o = (unsigned long long)((SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG) | 0); /* check that SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG(unsigned long long *o) +{ + int n = (SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG) <= 0; + *o = (unsigned long long)((SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG) | 0); /* check that SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NO_COMPRESSION(unsigned long long *o) +{ + int n = (SSL_OP_NO_COMPRESSION) <= 0; + *o = (unsigned long long)((SSL_OP_NO_COMPRESSION) | 0); /* check that SSL_OP_NO_COMPRESSION is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NO_DTLSv1(unsigned long long *o) +{ + int n = (SSL_OP_NO_DTLSv1) <= 0; + *o = (unsigned long long)((SSL_OP_NO_DTLSv1) | 0); /* check that SSL_OP_NO_DTLSv1 is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NO_DTLSv1_2(unsigned long long *o) +{ + int n = (SSL_OP_NO_DTLSv1_2) <= 0; + *o = (unsigned long long)((SSL_OP_NO_DTLSv1_2) | 0); /* check that SSL_OP_NO_DTLSv1_2 is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NO_QUERY_MTU(unsigned long long *o) +{ + int n = (SSL_OP_NO_QUERY_MTU) <= 0; + *o = (unsigned long long)((SSL_OP_NO_QUERY_MTU) | 0); /* check that SSL_OP_NO_QUERY_MTU is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NO_SSLv2(unsigned long long *o) +{ + int n = (SSL_OP_NO_SSLv2) <= 0; + *o = (unsigned long long)((SSL_OP_NO_SSLv2) | 0); /* check that SSL_OP_NO_SSLv2 is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NO_SSLv3(unsigned long long *o) +{ + int n = (SSL_OP_NO_SSLv3) <= 0; + *o = (unsigned long long)((SSL_OP_NO_SSLv3) | 0); /* check that SSL_OP_NO_SSLv3 is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NO_TICKET(unsigned long long *o) +{ + int n = (SSL_OP_NO_TICKET) <= 0; + *o = (unsigned long long)((SSL_OP_NO_TICKET) | 0); /* check that SSL_OP_NO_TICKET is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NO_TLSv1(unsigned long long *o) +{ + int n = (SSL_OP_NO_TLSv1) <= 0; + *o = (unsigned long long)((SSL_OP_NO_TLSv1) | 0); /* check that SSL_OP_NO_TLSv1 is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NO_TLSv1_1(unsigned long long *o) +{ + int n = (SSL_OP_NO_TLSv1_1) <= 0; + *o = (unsigned long long)((SSL_OP_NO_TLSv1_1) | 0); /* check that SSL_OP_NO_TLSv1_1 is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NO_TLSv1_2(unsigned long long *o) +{ + int n = (SSL_OP_NO_TLSv1_2) <= 0; + *o = (unsigned long long)((SSL_OP_NO_TLSv1_2) | 0); /* check that SSL_OP_NO_TLSv1_2 is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_NO_TLSv1_3(unsigned long long *o) +{ + int n = (SSL_OP_NO_TLSv1_3) <= 0; + *o = (unsigned long long)((SSL_OP_NO_TLSv1_3) | 0); /* check that SSL_OP_NO_TLSv1_3 is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_PKCS1_CHECK_1(unsigned long long *o) +{ + int n = (SSL_OP_PKCS1_CHECK_1) <= 0; + *o = (unsigned long long)((SSL_OP_PKCS1_CHECK_1) | 0); /* check that SSL_OP_PKCS1_CHECK_1 is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_PKCS1_CHECK_2(unsigned long long *o) +{ + int n = (SSL_OP_PKCS1_CHECK_2) <= 0; + *o = (unsigned long long)((SSL_OP_PKCS1_CHECK_2) | 0); /* check that SSL_OP_PKCS1_CHECK_2 is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_SINGLE_DH_USE(unsigned long long *o) +{ + int n = (SSL_OP_SINGLE_DH_USE) <= 0; + *o = (unsigned long long)((SSL_OP_SINGLE_DH_USE) | 0); /* check that SSL_OP_SINGLE_DH_USE is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_SINGLE_ECDH_USE(unsigned long long *o) +{ + int n = (SSL_OP_SINGLE_ECDH_USE) <= 0; + *o = (unsigned long long)((SSL_OP_SINGLE_ECDH_USE) | 0); /* check that SSL_OP_SINGLE_ECDH_USE is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_SSLEAY_080_CLIENT_DH_BUG(unsigned long long *o) +{ + int n = (SSL_OP_SSLEAY_080_CLIENT_DH_BUG) <= 0; + *o = (unsigned long long)((SSL_OP_SSLEAY_080_CLIENT_DH_BUG) | 0); /* check that SSL_OP_SSLEAY_080_CLIENT_DH_BUG is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG(unsigned long long *o) +{ + int n = (SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG) <= 0; + *o = (unsigned long long)((SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG) | 0); /* check that SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_TLS_BLOCK_PADDING_BUG(unsigned long long *o) +{ + int n = (SSL_OP_TLS_BLOCK_PADDING_BUG) <= 0; + *o = (unsigned long long)((SSL_OP_TLS_BLOCK_PADDING_BUG) | 0); /* check that SSL_OP_TLS_BLOCK_PADDING_BUG is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_TLS_D5_BUG(unsigned long long *o) +{ + int n = (SSL_OP_TLS_D5_BUG) <= 0; + *o = (unsigned long long)((SSL_OP_TLS_D5_BUG) | 0); /* check that SSL_OP_TLS_D5_BUG is an integer */ + return n; +} + +static int _cffi_const_SSL_OP_TLS_ROLLBACK_BUG(unsigned long long *o) +{ + int n = (SSL_OP_TLS_ROLLBACK_BUG) <= 0; + *o = (unsigned long long)((SSL_OP_TLS_ROLLBACK_BUG) | 0); /* check that SSL_OP_TLS_ROLLBACK_BUG is an integer */ + return n; +} + +static int _cffi_const_SSL_RECEIVED_SHUTDOWN(unsigned long long *o) +{ + int n = (SSL_RECEIVED_SHUTDOWN) <= 0; + *o = (unsigned long long)((SSL_RECEIVED_SHUTDOWN) | 0); /* check that SSL_RECEIVED_SHUTDOWN is an integer */ + return n; +} + +static int _cffi_const_SSL_SENT_SHUTDOWN(unsigned long long *o) +{ + int n = (SSL_SENT_SHUTDOWN) <= 0; + *o = (unsigned long long)((SSL_SENT_SHUTDOWN) | 0); /* check that SSL_SENT_SHUTDOWN is an integer */ + return n; +} + +static int _cffi_const_SSL_SESS_CACHE_BOTH(unsigned long long *o) +{ + int n = (SSL_SESS_CACHE_BOTH) <= 0; + *o = (unsigned long long)((SSL_SESS_CACHE_BOTH) | 0); /* check that SSL_SESS_CACHE_BOTH is an integer */ + return n; +} + +static int _cffi_const_SSL_SESS_CACHE_CLIENT(unsigned long long *o) +{ + int n = (SSL_SESS_CACHE_CLIENT) <= 0; + *o = (unsigned long long)((SSL_SESS_CACHE_CLIENT) | 0); /* check that SSL_SESS_CACHE_CLIENT is an integer */ + return n; +} + +static int _cffi_const_SSL_SESS_CACHE_NO_AUTO_CLEAR(unsigned long long *o) +{ + int n = (SSL_SESS_CACHE_NO_AUTO_CLEAR) <= 0; + *o = (unsigned long long)((SSL_SESS_CACHE_NO_AUTO_CLEAR) | 0); /* check that SSL_SESS_CACHE_NO_AUTO_CLEAR is an integer */ + return n; +} + +static int _cffi_const_SSL_SESS_CACHE_NO_INTERNAL(unsigned long long *o) +{ + int n = (SSL_SESS_CACHE_NO_INTERNAL) <= 0; + *o = (unsigned long long)((SSL_SESS_CACHE_NO_INTERNAL) | 0); /* check that SSL_SESS_CACHE_NO_INTERNAL is an integer */ + return n; +} + +static int _cffi_const_SSL_SESS_CACHE_NO_INTERNAL_LOOKUP(unsigned long long *o) +{ + int n = (SSL_SESS_CACHE_NO_INTERNAL_LOOKUP) <= 0; + *o = (unsigned long long)((SSL_SESS_CACHE_NO_INTERNAL_LOOKUP) | 0); /* check that SSL_SESS_CACHE_NO_INTERNAL_LOOKUP is an integer */ + return n; +} + +static int _cffi_const_SSL_SESS_CACHE_NO_INTERNAL_STORE(unsigned long long *o) +{ + int n = (SSL_SESS_CACHE_NO_INTERNAL_STORE) <= 0; + *o = (unsigned long long)((SSL_SESS_CACHE_NO_INTERNAL_STORE) | 0); /* check that SSL_SESS_CACHE_NO_INTERNAL_STORE is an integer */ + return n; +} + +static int _cffi_const_SSL_SESS_CACHE_OFF(unsigned long long *o) +{ + int n = (SSL_SESS_CACHE_OFF) <= 0; + *o = (unsigned long long)((SSL_SESS_CACHE_OFF) | 0); /* check that SSL_SESS_CACHE_OFF is an integer */ + return n; +} + +static int _cffi_const_SSL_SESS_CACHE_SERVER(unsigned long long *o) +{ + int n = (SSL_SESS_CACHE_SERVER) <= 0; + *o = (unsigned long long)((SSL_SESS_CACHE_SERVER) | 0); /* check that SSL_SESS_CACHE_SERVER is an integer */ + return n; +} + +static int _cffi_const_SSL_ST_ACCEPT(unsigned long long *o) +{ + int n = (SSL_ST_ACCEPT) <= 0; + *o = (unsigned long long)((SSL_ST_ACCEPT) | 0); /* check that SSL_ST_ACCEPT is an integer */ + return n; +} + +static int _cffi_const_SSL_ST_BEFORE(unsigned long long *o) +{ + int n = (SSL_ST_BEFORE) <= 0; + *o = (unsigned long long)((SSL_ST_BEFORE) | 0); /* check that SSL_ST_BEFORE is an integer */ + return n; +} + +static int _cffi_const_SSL_ST_CONNECT(unsigned long long *o) +{ + int n = (SSL_ST_CONNECT) <= 0; + *o = (unsigned long long)((SSL_ST_CONNECT) | 0); /* check that SSL_ST_CONNECT is an integer */ + return n; +} + +static int _cffi_const_SSL_ST_INIT(unsigned long long *o) +{ + int n = (SSL_ST_INIT) <= 0; + *o = (unsigned long long)((SSL_ST_INIT) | 0); /* check that SSL_ST_INIT is an integer */ + return n; +} + +static int _cffi_const_SSL_ST_MASK(unsigned long long *o) +{ + int n = (SSL_ST_MASK) <= 0; + *o = (unsigned long long)((SSL_ST_MASK) | 0); /* check that SSL_ST_MASK is an integer */ + return n; +} + +static int _cffi_const_SSL_ST_OK(unsigned long long *o) +{ + int n = (SSL_ST_OK) <= 0; + *o = (unsigned long long)((SSL_ST_OK) | 0); /* check that SSL_ST_OK is an integer */ + return n; +} + +static int _cffi_const_SSL_ST_RENEGOTIATE(unsigned long long *o) +{ + int n = (SSL_ST_RENEGOTIATE) <= 0; + *o = (unsigned long long)((SSL_ST_RENEGOTIATE) | 0); /* check that SSL_ST_RENEGOTIATE is an integer */ + return n; +} + +static int _cffi_const_SSL_TLSEXT_ERR_ALERT_FATAL(unsigned long long *o) +{ + int n = (SSL_TLSEXT_ERR_ALERT_FATAL) <= 0; + *o = (unsigned long long)((SSL_TLSEXT_ERR_ALERT_FATAL) | 0); /* check that SSL_TLSEXT_ERR_ALERT_FATAL is an integer */ + return n; +} + +static int _cffi_const_SSL_TLSEXT_ERR_NOACK(unsigned long long *o) +{ + int n = (SSL_TLSEXT_ERR_NOACK) <= 0; + *o = (unsigned long long)((SSL_TLSEXT_ERR_NOACK) | 0); /* check that SSL_TLSEXT_ERR_NOACK is an integer */ + return n; +} + +static int _cffi_const_SSL_TLSEXT_ERR_OK(unsigned long long *o) +{ + int n = (SSL_TLSEXT_ERR_OK) <= 0; + *o = (unsigned long long)((SSL_TLSEXT_ERR_OK) | 0); /* check that SSL_TLSEXT_ERR_OK is an integer */ + return n; +} + +static int _cffi_const_SSL_VERIFY_CLIENT_ONCE(unsigned long long *o) +{ + int n = (SSL_VERIFY_CLIENT_ONCE) <= 0; + *o = (unsigned long long)((SSL_VERIFY_CLIENT_ONCE) | 0); /* check that SSL_VERIFY_CLIENT_ONCE is an integer */ + return n; +} + +static int _cffi_const_SSL_VERIFY_FAIL_IF_NO_PEER_CERT(unsigned long long *o) +{ + int n = (SSL_VERIFY_FAIL_IF_NO_PEER_CERT) <= 0; + *o = (unsigned long long)((SSL_VERIFY_FAIL_IF_NO_PEER_CERT) | 0); /* check that SSL_VERIFY_FAIL_IF_NO_PEER_CERT is an integer */ + return n; +} + +static int _cffi_const_SSL_VERIFY_NONE(unsigned long long *o) +{ + int n = (SSL_VERIFY_NONE) <= 0; + *o = (unsigned long long)((SSL_VERIFY_NONE) | 0); /* check that SSL_VERIFY_NONE is an integer */ + return n; +} + +static int _cffi_const_SSL_VERIFY_PEER(unsigned long long *o) +{ + int n = (SSL_VERIFY_PEER) <= 0; + *o = (unsigned long long)((SSL_VERIFY_PEER) | 0); /* check that SSL_VERIFY_PEER is an integer */ + return n; +} + +static int _cffi_const_SSL_VERIFY_POST_HANDSHAKE(unsigned long long *o) +{ + int n = (SSL_VERIFY_POST_HANDSHAKE) <= 0; + *o = (unsigned long long)((SSL_VERIFY_POST_HANDSHAKE) | 0); /* check that SSL_VERIFY_POST_HANDSHAKE is an integer */ + return n; +} + +static int _cffi_const_TLSEXT_NAMETYPE_host_name(unsigned long long *o) +{ + int n = (TLSEXT_NAMETYPE_host_name) <= 0; + *o = (unsigned long long)((TLSEXT_NAMETYPE_host_name) | 0); /* check that TLSEXT_NAMETYPE_host_name is an integer */ + return n; +} + +static int _cffi_const_TLSEXT_STATUSTYPE_ocsp(unsigned long long *o) +{ + int n = (TLSEXT_STATUSTYPE_ocsp) <= 0; + *o = (unsigned long long)((TLSEXT_STATUSTYPE_ocsp) | 0); /* check that TLSEXT_STATUSTYPE_ocsp is an integer */ + return n; +} + +static int _cffi_const_TLS_ST_BEFORE(unsigned long long *o) +{ + int n = (TLS_ST_BEFORE) <= 0; + *o = (unsigned long long)((TLS_ST_BEFORE) | 0); /* check that TLS_ST_BEFORE is an integer */ + return n; +} + +static int _cffi_const_TLS_ST_OK(unsigned long long *o) +{ + int n = (TLS_ST_OK) <= 0; + *o = (unsigned long long)((TLS_ST_OK) | 0); /* check that TLS_ST_OK is an integer */ + return n; +} + +static int _cffi_const_V_ASN1_GENERALIZEDTIME(unsigned long long *o) +{ + int n = (V_ASN1_GENERALIZEDTIME) <= 0; + *o = (unsigned long long)((V_ASN1_GENERALIZEDTIME) | 0); /* check that V_ASN1_GENERALIZEDTIME is an integer */ + return n; +} + +static int _cffi_const_X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT(unsigned long long *o) +{ + int n = (X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT) <= 0; + *o = (unsigned long long)((X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT) | 0); /* check that X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT is an integer */ + return n; +} + +static int _cffi_const_X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS(unsigned long long *o) +{ + int n = (X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS) <= 0; + *o = (unsigned long long)((X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS) | 0); /* check that X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS is an integer */ + return n; +} + +static int _cffi_const_X509_CHECK_FLAG_NEVER_CHECK_SUBJECT(unsigned long long *o) +{ + int n = (X509_CHECK_FLAG_NEVER_CHECK_SUBJECT) <= 0; + *o = (unsigned long long)((X509_CHECK_FLAG_NEVER_CHECK_SUBJECT) | 0); /* check that X509_CHECK_FLAG_NEVER_CHECK_SUBJECT is an integer */ + return n; +} + +static int _cffi_const_X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS(unsigned long long *o) +{ + int n = (X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS) <= 0; + *o = (unsigned long long)((X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS) | 0); /* check that X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS is an integer */ + return n; +} + +static int _cffi_const_X509_CHECK_FLAG_NO_WILDCARDS(unsigned long long *o) +{ + int n = (X509_CHECK_FLAG_NO_WILDCARDS) <= 0; + *o = (unsigned long long)((X509_CHECK_FLAG_NO_WILDCARDS) | 0); /* check that X509_CHECK_FLAG_NO_WILDCARDS is an integer */ + return n; +} + +static int _cffi_const_X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS(unsigned long long *o) +{ + int n = (X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS) <= 0; + *o = (unsigned long long)((X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS) | 0); /* check that X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS is an integer */ + return n; +} + +static int _cffi_const_X509_LU_CRL(unsigned long long *o) +{ + int n = (X509_LU_CRL) <= 0; + *o = (unsigned long long)((X509_LU_CRL) | 0); /* check that X509_LU_CRL is an integer */ + return n; +} + +static int _cffi_const_X509_LU_X509(unsigned long long *o) +{ + int n = (X509_LU_X509) <= 0; + *o = (unsigned long long)((X509_LU_X509) | 0); /* check that X509_LU_X509 is an integer */ + return n; +} + +static int _cffi_const_X509_R_CERT_ALREADY_IN_HASH_TABLE(unsigned long long *o) +{ + int n = (X509_R_CERT_ALREADY_IN_HASH_TABLE) <= 0; + *o = (unsigned long long)((X509_R_CERT_ALREADY_IN_HASH_TABLE) | 0); /* check that X509_R_CERT_ALREADY_IN_HASH_TABLE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH(unsigned long long *o) +{ + int n = (X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH) <= 0; + *o = (unsigned long long)((X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH) | 0); /* check that X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_AKID_SKID_MISMATCH(unsigned long long *o) +{ + int n = (X509_V_ERR_AKID_SKID_MISMATCH) <= 0; + *o = (unsigned long long)((X509_V_ERR_AKID_SKID_MISMATCH) | 0); /* check that X509_V_ERR_AKID_SKID_MISMATCH is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_APPLICATION_VERIFICATION(unsigned long long *o) +{ + int n = (X509_V_ERR_APPLICATION_VERIFICATION) <= 0; + *o = (unsigned long long)((X509_V_ERR_APPLICATION_VERIFICATION) | 0); /* check that X509_V_ERR_APPLICATION_VERIFICATION is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_CERT_CHAIN_TOO_LONG(unsigned long long *o) +{ + int n = (X509_V_ERR_CERT_CHAIN_TOO_LONG) <= 0; + *o = (unsigned long long)((X509_V_ERR_CERT_CHAIN_TOO_LONG) | 0); /* check that X509_V_ERR_CERT_CHAIN_TOO_LONG is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_CERT_HAS_EXPIRED(unsigned long long *o) +{ + int n = (X509_V_ERR_CERT_HAS_EXPIRED) <= 0; + *o = (unsigned long long)((X509_V_ERR_CERT_HAS_EXPIRED) | 0); /* check that X509_V_ERR_CERT_HAS_EXPIRED is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_CERT_NOT_YET_VALID(unsigned long long *o) +{ + int n = (X509_V_ERR_CERT_NOT_YET_VALID) <= 0; + *o = (unsigned long long)((X509_V_ERR_CERT_NOT_YET_VALID) | 0); /* check that X509_V_ERR_CERT_NOT_YET_VALID is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_CERT_REJECTED(unsigned long long *o) +{ + int n = (X509_V_ERR_CERT_REJECTED) <= 0; + *o = (unsigned long long)((X509_V_ERR_CERT_REJECTED) | 0); /* check that X509_V_ERR_CERT_REJECTED is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_CERT_REVOKED(unsigned long long *o) +{ + int n = (X509_V_ERR_CERT_REVOKED) <= 0; + *o = (unsigned long long)((X509_V_ERR_CERT_REVOKED) | 0); /* check that X509_V_ERR_CERT_REVOKED is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_CERT_SIGNATURE_FAILURE(unsigned long long *o) +{ + int n = (X509_V_ERR_CERT_SIGNATURE_FAILURE) <= 0; + *o = (unsigned long long)((X509_V_ERR_CERT_SIGNATURE_FAILURE) | 0); /* check that X509_V_ERR_CERT_SIGNATURE_FAILURE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_CERT_UNTRUSTED(unsigned long long *o) +{ + int n = (X509_V_ERR_CERT_UNTRUSTED) <= 0; + *o = (unsigned long long)((X509_V_ERR_CERT_UNTRUSTED) | 0); /* check that X509_V_ERR_CERT_UNTRUSTED is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_CRL_HAS_EXPIRED(unsigned long long *o) +{ + int n = (X509_V_ERR_CRL_HAS_EXPIRED) <= 0; + *o = (unsigned long long)((X509_V_ERR_CRL_HAS_EXPIRED) | 0); /* check that X509_V_ERR_CRL_HAS_EXPIRED is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_CRL_NOT_YET_VALID(unsigned long long *o) +{ + int n = (X509_V_ERR_CRL_NOT_YET_VALID) <= 0; + *o = (unsigned long long)((X509_V_ERR_CRL_NOT_YET_VALID) | 0); /* check that X509_V_ERR_CRL_NOT_YET_VALID is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_CRL_PATH_VALIDATION_ERROR(unsigned long long *o) +{ + int n = (X509_V_ERR_CRL_PATH_VALIDATION_ERROR) <= 0; + *o = (unsigned long long)((X509_V_ERR_CRL_PATH_VALIDATION_ERROR) | 0); /* check that X509_V_ERR_CRL_PATH_VALIDATION_ERROR is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_CRL_SIGNATURE_FAILURE(unsigned long long *o) +{ + int n = (X509_V_ERR_CRL_SIGNATURE_FAILURE) <= 0; + *o = (unsigned long long)((X509_V_ERR_CRL_SIGNATURE_FAILURE) | 0); /* check that X509_V_ERR_CRL_SIGNATURE_FAILURE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT(unsigned long long *o) +{ + int n = (X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT) <= 0; + *o = (unsigned long long)((X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT) | 0); /* check that X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_DIFFERENT_CRL_SCOPE(unsigned long long *o) +{ + int n = (X509_V_ERR_DIFFERENT_CRL_SCOPE) <= 0; + *o = (unsigned long long)((X509_V_ERR_DIFFERENT_CRL_SCOPE) | 0); /* check that X509_V_ERR_DIFFERENT_CRL_SCOPE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_EMAIL_MISMATCH(unsigned long long *o) +{ + int n = (X509_V_ERR_EMAIL_MISMATCH) <= 0; + *o = (unsigned long long)((X509_V_ERR_EMAIL_MISMATCH) | 0); /* check that X509_V_ERR_EMAIL_MISMATCH is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD(unsigned long long *o) +{ + int n = (X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD) <= 0; + *o = (unsigned long long)((X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD) | 0); /* check that X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD(unsigned long long *o) +{ + int n = (X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD) <= 0; + *o = (unsigned long long)((X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD) | 0); /* check that X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD(unsigned long long *o) +{ + int n = (X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD) <= 0; + *o = (unsigned long long)((X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD) | 0); /* check that X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD(unsigned long long *o) +{ + int n = (X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD) <= 0; + *o = (unsigned long long)((X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD) | 0); /* check that X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_EXCLUDED_VIOLATION(unsigned long long *o) +{ + int n = (X509_V_ERR_EXCLUDED_VIOLATION) <= 0; + *o = (unsigned long long)((X509_V_ERR_EXCLUDED_VIOLATION) | 0); /* check that X509_V_ERR_EXCLUDED_VIOLATION is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_HOSTNAME_MISMATCH(unsigned long long *o) +{ + int n = (X509_V_ERR_HOSTNAME_MISMATCH) <= 0; + *o = (unsigned long long)((X509_V_ERR_HOSTNAME_MISMATCH) | 0); /* check that X509_V_ERR_HOSTNAME_MISMATCH is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_INVALID_CA(unsigned long long *o) +{ + int n = (X509_V_ERR_INVALID_CA) <= 0; + *o = (unsigned long long)((X509_V_ERR_INVALID_CA) | 0); /* check that X509_V_ERR_INVALID_CA is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_INVALID_EXTENSION(unsigned long long *o) +{ + int n = (X509_V_ERR_INVALID_EXTENSION) <= 0; + *o = (unsigned long long)((X509_V_ERR_INVALID_EXTENSION) | 0); /* check that X509_V_ERR_INVALID_EXTENSION is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_INVALID_NON_CA(unsigned long long *o) +{ + int n = (X509_V_ERR_INVALID_NON_CA) <= 0; + *o = (unsigned long long)((X509_V_ERR_INVALID_NON_CA) | 0); /* check that X509_V_ERR_INVALID_NON_CA is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_INVALID_POLICY_EXTENSION(unsigned long long *o) +{ + int n = (X509_V_ERR_INVALID_POLICY_EXTENSION) <= 0; + *o = (unsigned long long)((X509_V_ERR_INVALID_POLICY_EXTENSION) | 0); /* check that X509_V_ERR_INVALID_POLICY_EXTENSION is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_INVALID_PURPOSE(unsigned long long *o) +{ + int n = (X509_V_ERR_INVALID_PURPOSE) <= 0; + *o = (unsigned long long)((X509_V_ERR_INVALID_PURPOSE) | 0); /* check that X509_V_ERR_INVALID_PURPOSE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_IP_ADDRESS_MISMATCH(unsigned long long *o) +{ + int n = (X509_V_ERR_IP_ADDRESS_MISMATCH) <= 0; + *o = (unsigned long long)((X509_V_ERR_IP_ADDRESS_MISMATCH) | 0); /* check that X509_V_ERR_IP_ADDRESS_MISMATCH is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_KEYUSAGE_NO_CERTSIGN(unsigned long long *o) +{ + int n = (X509_V_ERR_KEYUSAGE_NO_CERTSIGN) <= 0; + *o = (unsigned long long)((X509_V_ERR_KEYUSAGE_NO_CERTSIGN) | 0); /* check that X509_V_ERR_KEYUSAGE_NO_CERTSIGN is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_KEYUSAGE_NO_CRL_SIGN(unsigned long long *o) +{ + int n = (X509_V_ERR_KEYUSAGE_NO_CRL_SIGN) <= 0; + *o = (unsigned long long)((X509_V_ERR_KEYUSAGE_NO_CRL_SIGN) | 0); /* check that X509_V_ERR_KEYUSAGE_NO_CRL_SIGN is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE(unsigned long long *o) +{ + int n = (X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE) <= 0; + *o = (unsigned long long)((X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE) | 0); /* check that X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_NO_EXPLICIT_POLICY(unsigned long long *o) +{ + int n = (X509_V_ERR_NO_EXPLICIT_POLICY) <= 0; + *o = (unsigned long long)((X509_V_ERR_NO_EXPLICIT_POLICY) | 0); /* check that X509_V_ERR_NO_EXPLICIT_POLICY is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_OUT_OF_MEM(unsigned long long *o) +{ + int n = (X509_V_ERR_OUT_OF_MEM) <= 0; + *o = (unsigned long long)((X509_V_ERR_OUT_OF_MEM) | 0); /* check that X509_V_ERR_OUT_OF_MEM is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_PATH_LENGTH_EXCEEDED(unsigned long long *o) +{ + int n = (X509_V_ERR_PATH_LENGTH_EXCEEDED) <= 0; + *o = (unsigned long long)((X509_V_ERR_PATH_LENGTH_EXCEEDED) | 0); /* check that X509_V_ERR_PATH_LENGTH_EXCEEDED is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_PERMITTED_VIOLATION(unsigned long long *o) +{ + int n = (X509_V_ERR_PERMITTED_VIOLATION) <= 0; + *o = (unsigned long long)((X509_V_ERR_PERMITTED_VIOLATION) | 0); /* check that X509_V_ERR_PERMITTED_VIOLATION is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED(unsigned long long *o) +{ + int n = (X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED) <= 0; + *o = (unsigned long long)((X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED) | 0); /* check that X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED(unsigned long long *o) +{ + int n = (X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED) <= 0; + *o = (unsigned long long)((X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED) | 0); /* check that X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN(unsigned long long *o) +{ + int n = (X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN) <= 0; + *o = (unsigned long long)((X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN) | 0); /* check that X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_SUBJECT_ISSUER_MISMATCH(unsigned long long *o) +{ + int n = (X509_V_ERR_SUBJECT_ISSUER_MISMATCH) <= 0; + *o = (unsigned long long)((X509_V_ERR_SUBJECT_ISSUER_MISMATCH) | 0); /* check that X509_V_ERR_SUBJECT_ISSUER_MISMATCH is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_SUBTREE_MINMAX(unsigned long long *o) +{ + int n = (X509_V_ERR_SUBTREE_MINMAX) <= 0; + *o = (unsigned long long)((X509_V_ERR_SUBTREE_MINMAX) | 0); /* check that X509_V_ERR_SUBTREE_MINMAX is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256(unsigned long long *o) +{ + int n = (X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256) <= 0; + *o = (unsigned long long)((X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256) | 0); /* check that X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_SUITE_B_INVALID_ALGORITHM(unsigned long long *o) +{ + int n = (X509_V_ERR_SUITE_B_INVALID_ALGORITHM) <= 0; + *o = (unsigned long long)((X509_V_ERR_SUITE_B_INVALID_ALGORITHM) | 0); /* check that X509_V_ERR_SUITE_B_INVALID_ALGORITHM is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_SUITE_B_INVALID_CURVE(unsigned long long *o) +{ + int n = (X509_V_ERR_SUITE_B_INVALID_CURVE) <= 0; + *o = (unsigned long long)((X509_V_ERR_SUITE_B_INVALID_CURVE) | 0); /* check that X509_V_ERR_SUITE_B_INVALID_CURVE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM(unsigned long long *o) +{ + int n = (X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM) <= 0; + *o = (unsigned long long)((X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM) | 0); /* check that X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_SUITE_B_INVALID_VERSION(unsigned long long *o) +{ + int n = (X509_V_ERR_SUITE_B_INVALID_VERSION) <= 0; + *o = (unsigned long long)((X509_V_ERR_SUITE_B_INVALID_VERSION) | 0); /* check that X509_V_ERR_SUITE_B_INVALID_VERSION is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED(unsigned long long *o) +{ + int n = (X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED) <= 0; + *o = (unsigned long long)((X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED) | 0); /* check that X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY(unsigned long long *o) +{ + int n = (X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY) | 0); /* check that X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE(unsigned long long *o) +{ + int n = (X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE) | 0); /* check that X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE(unsigned long long *o) +{ + int n = (X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE) | 0); /* check that X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNABLE_TO_GET_CRL(unsigned long long *o) +{ + int n = (X509_V_ERR_UNABLE_TO_GET_CRL) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNABLE_TO_GET_CRL) | 0); /* check that X509_V_ERR_UNABLE_TO_GET_CRL is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER(unsigned long long *o) +{ + int n = (X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER) | 0); /* check that X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT(unsigned long long *o) +{ + int n = (X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT) | 0); /* check that X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY(unsigned long long *o) +{ + int n = (X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY) | 0); /* check that X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE(unsigned long long *o) +{ + int n = (X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE) | 0); /* check that X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION(unsigned long long *o) +{ + int n = (X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION) | 0); /* check that X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION(unsigned long long *o) +{ + int n = (X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION) | 0); /* check that X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNNESTED_RESOURCE(unsigned long long *o) +{ + int n = (X509_V_ERR_UNNESTED_RESOURCE) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNNESTED_RESOURCE) | 0); /* check that X509_V_ERR_UNNESTED_RESOURCE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX(unsigned long long *o) +{ + int n = (X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX) | 0); /* check that X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE(unsigned long long *o) +{ + int n = (X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE) | 0); /* check that X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE(unsigned long long *o) +{ + int n = (X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE) | 0); /* check that X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE is an integer */ + return n; +} + +static int _cffi_const_X509_V_ERR_UNSUPPORTED_NAME_SYNTAX(unsigned long long *o) +{ + int n = (X509_V_ERR_UNSUPPORTED_NAME_SYNTAX) <= 0; + *o = (unsigned long long)((X509_V_ERR_UNSUPPORTED_NAME_SYNTAX) | 0); /* check that X509_V_ERR_UNSUPPORTED_NAME_SYNTAX is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_ALLOW_PROXY_CERTS(unsigned long long *o) +{ + int n = (X509_V_FLAG_ALLOW_PROXY_CERTS) <= 0; + *o = (unsigned long long)((X509_V_FLAG_ALLOW_PROXY_CERTS) | 0); /* check that X509_V_FLAG_ALLOW_PROXY_CERTS is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_CB_ISSUER_CHECK(unsigned long long *o) +{ + int n = (X509_V_FLAG_CB_ISSUER_CHECK) <= 0; + *o = (unsigned long long)((X509_V_FLAG_CB_ISSUER_CHECK) | 0); /* check that X509_V_FLAG_CB_ISSUER_CHECK is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_CHECK_SS_SIGNATURE(unsigned long long *o) +{ + int n = (X509_V_FLAG_CHECK_SS_SIGNATURE) <= 0; + *o = (unsigned long long)((X509_V_FLAG_CHECK_SS_SIGNATURE) | 0); /* check that X509_V_FLAG_CHECK_SS_SIGNATURE is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_CRL_CHECK(unsigned long long *o) +{ + int n = (X509_V_FLAG_CRL_CHECK) <= 0; + *o = (unsigned long long)((X509_V_FLAG_CRL_CHECK) | 0); /* check that X509_V_FLAG_CRL_CHECK is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_CRL_CHECK_ALL(unsigned long long *o) +{ + int n = (X509_V_FLAG_CRL_CHECK_ALL) <= 0; + *o = (unsigned long long)((X509_V_FLAG_CRL_CHECK_ALL) | 0); /* check that X509_V_FLAG_CRL_CHECK_ALL is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_EXPLICIT_POLICY(unsigned long long *o) +{ + int n = (X509_V_FLAG_EXPLICIT_POLICY) <= 0; + *o = (unsigned long long)((X509_V_FLAG_EXPLICIT_POLICY) | 0); /* check that X509_V_FLAG_EXPLICIT_POLICY is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_EXTENDED_CRL_SUPPORT(unsigned long long *o) +{ + int n = (X509_V_FLAG_EXTENDED_CRL_SUPPORT) <= 0; + *o = (unsigned long long)((X509_V_FLAG_EXTENDED_CRL_SUPPORT) | 0); /* check that X509_V_FLAG_EXTENDED_CRL_SUPPORT is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_IGNORE_CRITICAL(unsigned long long *o) +{ + int n = (X509_V_FLAG_IGNORE_CRITICAL) <= 0; + *o = (unsigned long long)((X509_V_FLAG_IGNORE_CRITICAL) | 0); /* check that X509_V_FLAG_IGNORE_CRITICAL is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_INHIBIT_ANY(unsigned long long *o) +{ + int n = (X509_V_FLAG_INHIBIT_ANY) <= 0; + *o = (unsigned long long)((X509_V_FLAG_INHIBIT_ANY) | 0); /* check that X509_V_FLAG_INHIBIT_ANY is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_INHIBIT_MAP(unsigned long long *o) +{ + int n = (X509_V_FLAG_INHIBIT_MAP) <= 0; + *o = (unsigned long long)((X509_V_FLAG_INHIBIT_MAP) | 0); /* check that X509_V_FLAG_INHIBIT_MAP is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_NOTIFY_POLICY(unsigned long long *o) +{ + int n = (X509_V_FLAG_NOTIFY_POLICY) <= 0; + *o = (unsigned long long)((X509_V_FLAG_NOTIFY_POLICY) | 0); /* check that X509_V_FLAG_NOTIFY_POLICY is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_PARTIAL_CHAIN(unsigned long long *o) +{ + int n = (X509_V_FLAG_PARTIAL_CHAIN) <= 0; + *o = (unsigned long long)((X509_V_FLAG_PARTIAL_CHAIN) | 0); /* check that X509_V_FLAG_PARTIAL_CHAIN is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_POLICY_CHECK(unsigned long long *o) +{ + int n = (X509_V_FLAG_POLICY_CHECK) <= 0; + *o = (unsigned long long)((X509_V_FLAG_POLICY_CHECK) | 0); /* check that X509_V_FLAG_POLICY_CHECK is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_SUITEB_128_LOS(unsigned long long *o) +{ + int n = (X509_V_FLAG_SUITEB_128_LOS) <= 0; + *o = (unsigned long long)((X509_V_FLAG_SUITEB_128_LOS) | 0); /* check that X509_V_FLAG_SUITEB_128_LOS is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_SUITEB_128_LOS_ONLY(unsigned long long *o) +{ + int n = (X509_V_FLAG_SUITEB_128_LOS_ONLY) <= 0; + *o = (unsigned long long)((X509_V_FLAG_SUITEB_128_LOS_ONLY) | 0); /* check that X509_V_FLAG_SUITEB_128_LOS_ONLY is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_SUITEB_192_LOS(unsigned long long *o) +{ + int n = (X509_V_FLAG_SUITEB_192_LOS) <= 0; + *o = (unsigned long long)((X509_V_FLAG_SUITEB_192_LOS) | 0); /* check that X509_V_FLAG_SUITEB_192_LOS is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_TRUSTED_FIRST(unsigned long long *o) +{ + int n = (X509_V_FLAG_TRUSTED_FIRST) <= 0; + *o = (unsigned long long)((X509_V_FLAG_TRUSTED_FIRST) | 0); /* check that X509_V_FLAG_TRUSTED_FIRST is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_USE_CHECK_TIME(unsigned long long *o) +{ + int n = (X509_V_FLAG_USE_CHECK_TIME) <= 0; + *o = (unsigned long long)((X509_V_FLAG_USE_CHECK_TIME) | 0); /* check that X509_V_FLAG_USE_CHECK_TIME is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_USE_DELTAS(unsigned long long *o) +{ + int n = (X509_V_FLAG_USE_DELTAS) <= 0; + *o = (unsigned long long)((X509_V_FLAG_USE_DELTAS) | 0); /* check that X509_V_FLAG_USE_DELTAS is an integer */ + return n; +} + +static int _cffi_const_X509_V_FLAG_X509_STRICT(unsigned long long *o) +{ + int n = (X509_V_FLAG_X509_STRICT) <= 0; + *o = (unsigned long long)((X509_V_FLAG_X509_STRICT) | 0); /* check that X509_V_FLAG_X509_STRICT is an integer */ + return n; +} + +static int _cffi_const_X509_V_OK(unsigned long long *o) +{ + int n = (X509_V_OK) <= 0; + *o = (unsigned long long)((X509_V_OK) | 0); /* check that X509_V_OK is an integer */ + return n; +} + +static void _cffi_d_ACCESS_DESCRIPTION_free(ACCESS_DESCRIPTION * x0) +{ + ACCESS_DESCRIPTION_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ACCESS_DESCRIPTION_free(PyObject *self, PyObject *arg0) +{ + ACCESS_DESCRIPTION * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1056), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ACCESS_DESCRIPTION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1056), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ACCESS_DESCRIPTION_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ACCESS_DESCRIPTION_free _cffi_d_ACCESS_DESCRIPTION_free +#endif + +static ACCESS_DESCRIPTION * _cffi_d_ACCESS_DESCRIPTION_new(void) +{ + return ACCESS_DESCRIPTION_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ACCESS_DESCRIPTION_new(PyObject *self, PyObject *noarg) +{ + ACCESS_DESCRIPTION * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ACCESS_DESCRIPTION_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1056)); +} +#else +# define _cffi_f_ACCESS_DESCRIPTION_new _cffi_d_ACCESS_DESCRIPTION_new +#endif + +static int _cffi_d_AES_unwrap_key(AES_KEY * x0, unsigned char const * x1, unsigned char * x2, unsigned char const * x3, unsigned int x4) +{ + return AES_unwrap_key(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_AES_unwrap_key(PyObject *self, PyObject *args) +{ + AES_KEY * x0; + unsigned char const * x1; + unsigned char * x2; + unsigned char const * x3; + unsigned int x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "AES_unwrap_key", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(750), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (AES_KEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(750), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(752), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, unsigned int); + if (x4 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = AES_unwrap_key(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_AES_unwrap_key _cffi_d_AES_unwrap_key +#endif + +static int _cffi_d_AES_wrap_key(AES_KEY * x0, unsigned char const * x1, unsigned char * x2, unsigned char const * x3, unsigned int x4) +{ + return AES_wrap_key(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_AES_wrap_key(PyObject *self, PyObject *args) +{ + AES_KEY * x0; + unsigned char const * x1; + unsigned char * x2; + unsigned char const * x3; + unsigned int x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "AES_wrap_key", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(750), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (AES_KEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(750), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(752), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, unsigned int); + if (x4 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = AES_wrap_key(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_AES_wrap_key _cffi_d_AES_wrap_key +#endif + +static void _cffi_d_ASN1_BIT_STRING_free(ASN1_OCTET_STRING * x0) +{ + ASN1_BIT_STRING_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_BIT_STRING_free(PyObject *self, PyObject *arg0) +{ + ASN1_OCTET_STRING * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ASN1_BIT_STRING_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ASN1_BIT_STRING_free _cffi_d_ASN1_BIT_STRING_free +#endif + +static int _cffi_d_ASN1_BIT_STRING_get_bit(ASN1_OCTET_STRING * x0, int x1) +{ + return ASN1_BIT_STRING_get_bit(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_BIT_STRING_get_bit(PyObject *self, PyObject *args) +{ + ASN1_OCTET_STRING * x0; + int x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "ASN1_BIT_STRING_get_bit", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_BIT_STRING_get_bit(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ASN1_BIT_STRING_get_bit _cffi_d_ASN1_BIT_STRING_get_bit +#endif + +static ASN1_OCTET_STRING * _cffi_d_ASN1_BIT_STRING_new(void) +{ + return ASN1_BIT_STRING_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_BIT_STRING_new(PyObject *self, PyObject *noarg) +{ + ASN1_OCTET_STRING * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_BIT_STRING_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_ASN1_BIT_STRING_new _cffi_d_ASN1_BIT_STRING_new +#endif + +static int _cffi_d_ASN1_BIT_STRING_set_bit(ASN1_OCTET_STRING * x0, int x1, int x2) +{ + return ASN1_BIT_STRING_set_bit(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_BIT_STRING_set_bit(PyObject *self, PyObject *args) +{ + ASN1_OCTET_STRING * x0; + int x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "ASN1_BIT_STRING_set_bit", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_BIT_STRING_set_bit(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ASN1_BIT_STRING_set_bit _cffi_d_ASN1_BIT_STRING_set_bit +#endif + +static void _cffi_d_ASN1_ENUMERATED_free(ASN1_ENUMERATED * x0) +{ + ASN1_ENUMERATED_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_ENUMERATED_free(PyObject *self, PyObject *arg0) +{ + ASN1_ENUMERATED * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(757), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_ENUMERATED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(757), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ASN1_ENUMERATED_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ASN1_ENUMERATED_free _cffi_d_ASN1_ENUMERATED_free +#endif + +static long _cffi_d_ASN1_ENUMERATED_get(ASN1_ENUMERATED * x0) +{ + return ASN1_ENUMERATED_get(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_ENUMERATED_get(PyObject *self, PyObject *arg0) +{ + ASN1_ENUMERATED * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(757), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_ENUMERATED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(757), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_ENUMERATED_get(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_ASN1_ENUMERATED_get _cffi_d_ASN1_ENUMERATED_get +#endif + +static ASN1_ENUMERATED * _cffi_d_ASN1_ENUMERATED_new(void) +{ + return ASN1_ENUMERATED_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_ENUMERATED_new(PyObject *self, PyObject *noarg) +{ + ASN1_ENUMERATED * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_ENUMERATED_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(757)); +} +#else +# define _cffi_f_ASN1_ENUMERATED_new _cffi_d_ASN1_ENUMERATED_new +#endif + +static int _cffi_d_ASN1_ENUMERATED_set(ASN1_ENUMERATED * x0, long x1) +{ + return ASN1_ENUMERATED_set(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_ENUMERATED_set(PyObject *self, PyObject *args) +{ + ASN1_ENUMERATED * x0; + long x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "ASN1_ENUMERATED_set", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(757), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_ENUMERATED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(757), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_ENUMERATED_set(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ASN1_ENUMERATED_set _cffi_d_ASN1_ENUMERATED_set +#endif + +static void _cffi_d_ASN1_GENERALIZEDTIME_free(ASN1_GENERALIZEDTIME * x0) +{ + ASN1_GENERALIZEDTIME_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_GENERALIZEDTIME_free(PyObject *self, PyObject *arg0) +{ + ASN1_GENERALIZEDTIME * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(9), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_GENERALIZEDTIME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(9), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ASN1_GENERALIZEDTIME_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ASN1_GENERALIZEDTIME_free _cffi_d_ASN1_GENERALIZEDTIME_free +#endif + +static ASN1_GENERALIZEDTIME * _cffi_d_ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME * x0, time_t x1) +{ + return ASN1_GENERALIZEDTIME_set(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_GENERALIZEDTIME_set(PyObject *self, PyObject *args) +{ + ASN1_GENERALIZEDTIME * x0; + time_t x1; + Py_ssize_t datasize; + ASN1_GENERALIZEDTIME * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "ASN1_GENERALIZEDTIME_set", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(9), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_GENERALIZEDTIME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(9), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, time_t); + if (x1 == (time_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_GENERALIZEDTIME_set(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(9)); +} +#else +# define _cffi_f_ASN1_GENERALIZEDTIME_set _cffi_d_ASN1_GENERALIZEDTIME_set +#endif + +static ASN1_OCTET_STRING * _cffi_d_ASN1_IA5STRING_new(void) +{ + return ASN1_IA5STRING_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_IA5STRING_new(PyObject *self, PyObject *noarg) +{ + ASN1_OCTET_STRING * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_IA5STRING_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_ASN1_IA5STRING_new _cffi_d_ASN1_IA5STRING_new +#endif + +static void _cffi_d_ASN1_INTEGER_free(ASN1_INTEGER * x0) +{ + ASN1_INTEGER_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_INTEGER_free(PyObject *self, PyObject *arg0) +{ + ASN1_INTEGER * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(21), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(21), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ASN1_INTEGER_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ASN1_INTEGER_free _cffi_d_ASN1_INTEGER_free +#endif + +static int _cffi_d_ASN1_INTEGER_set(ASN1_INTEGER * x0, long x1) +{ + return ASN1_INTEGER_set(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_INTEGER_set(PyObject *self, PyObject *args) +{ + ASN1_INTEGER * x0; + long x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "ASN1_INTEGER_set", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(21), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(21), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_INTEGER_set(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ASN1_INTEGER_set _cffi_d_ASN1_INTEGER_set +#endif + +static BIGNUM * _cffi_d_ASN1_INTEGER_to_BN(ASN1_INTEGER * x0, BIGNUM * x1) +{ + return ASN1_INTEGER_to_BN(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_INTEGER_to_BN(PyObject *self, PyObject *args) +{ + ASN1_INTEGER * x0; + BIGNUM * x1; + Py_ssize_t datasize; + BIGNUM * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "ASN1_INTEGER_to_BN", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(21), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(21), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(20), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_INTEGER_to_BN(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(20)); +} +#else +# define _cffi_f_ASN1_INTEGER_to_BN _cffi_d_ASN1_INTEGER_to_BN +#endif + +static ASN1_NULL * _cffi_d_ASN1_NULL_new(void) +{ + return ASN1_NULL_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_NULL_new(PyObject *self, PyObject *noarg) +{ + ASN1_NULL * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_NULL_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3013)); +} +#else +# define _cffi_f_ASN1_NULL_new _cffi_d_ASN1_NULL_new +#endif + +static void _cffi_d_ASN1_OBJECT_free(ASN1_OBJECT * x0) +{ + ASN1_OBJECT_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_OBJECT_free(PyObject *self, PyObject *arg0) +{ + ASN1_OBJECT * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(607), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OBJECT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(607), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ASN1_OBJECT_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ASN1_OBJECT_free _cffi_d_ASN1_OBJECT_free +#endif + +static void _cffi_d_ASN1_OCTET_STRING_free(ASN1_OCTET_STRING * x0) +{ + ASN1_OCTET_STRING_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_OCTET_STRING_free(PyObject *self, PyObject *arg0) +{ + ASN1_OCTET_STRING * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ASN1_OCTET_STRING_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ASN1_OCTET_STRING_free _cffi_d_ASN1_OCTET_STRING_free +#endif + +static ASN1_OCTET_STRING * _cffi_d_ASN1_OCTET_STRING_new(void) +{ + return ASN1_OCTET_STRING_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_OCTET_STRING_new(PyObject *self, PyObject *noarg) +{ + ASN1_OCTET_STRING * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_OCTET_STRING_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_ASN1_OCTET_STRING_new _cffi_d_ASN1_OCTET_STRING_new +#endif + +static int _cffi_d_ASN1_OCTET_STRING_set(ASN1_OCTET_STRING * x0, unsigned char const * x1, int x2) +{ + return ASN1_OCTET_STRING_set(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_OCTET_STRING_set(PyObject *self, PyObject *args) +{ + ASN1_OCTET_STRING * x0; + unsigned char const * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "ASN1_OCTET_STRING_set", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_OCTET_STRING_set(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ASN1_OCTET_STRING_set _cffi_d_ASN1_OCTET_STRING_set +#endif + +static unsigned char * _cffi_d_ASN1_STRING_data(ASN1_OCTET_STRING * x0) +{ + return ASN1_STRING_data(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_STRING_data(PyObject *self, PyObject *arg0) +{ + ASN1_OCTET_STRING * x0; + Py_ssize_t datasize; + unsigned char * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_STRING_data(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(752)); +} +#else +# define _cffi_f_ASN1_STRING_data _cffi_d_ASN1_STRING_data +#endif + +static int _cffi_d_ASN1_STRING_length(ASN1_OCTET_STRING * x0) +{ + return ASN1_STRING_length(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_STRING_length(PyObject *self, PyObject *arg0) +{ + ASN1_OCTET_STRING * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_STRING_length(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ASN1_STRING_length _cffi_d_ASN1_STRING_length +#endif + +static int _cffi_d_ASN1_STRING_set(ASN1_OCTET_STRING * x0, void const * x1, int x2) +{ + return ASN1_STRING_set(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_STRING_set(PyObject *self, PyObject *args) +{ + ASN1_OCTET_STRING * x0; + void const * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "ASN1_STRING_set", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(126), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_STRING_set(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ASN1_STRING_set _cffi_d_ASN1_STRING_set +#endif + +static int _cffi_d_ASN1_STRING_set_default_mask_asc(char * x0) +{ + return ASN1_STRING_set_default_mask_asc(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_STRING_set_default_mask_asc(PyObject *self, PyObject *arg0) +{ + char * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(409), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_STRING_set_default_mask_asc(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ASN1_STRING_set_default_mask_asc _cffi_d_ASN1_STRING_set_default_mask_asc +#endif + +static int _cffi_d_ASN1_STRING_to_UTF8(unsigned char * * x0, ASN1_OCTET_STRING * x1) +{ + return ASN1_STRING_to_UTF8(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_STRING_to_UTF8(PyObject *self, PyObject *args) +{ + unsigned char * * x0; + ASN1_OCTET_STRING * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "ASN1_STRING_to_UTF8", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(802), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(13), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_STRING_to_UTF8(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ASN1_STRING_to_UTF8 _cffi_d_ASN1_STRING_to_UTF8 +#endif + +static int _cffi_d_ASN1_STRING_type(ASN1_OCTET_STRING * x0) +{ + return ASN1_STRING_type(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_STRING_type(PyObject *self, PyObject *arg0) +{ + ASN1_OCTET_STRING * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_STRING_type(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ASN1_STRING_type _cffi_d_ASN1_STRING_type +#endif + +static void _cffi_d_ASN1_TIME_free(ASN1_OCTET_STRING * x0) +{ + ASN1_TIME_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_TIME_free(PyObject *self, PyObject *arg0) +{ + ASN1_OCTET_STRING * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ASN1_TIME_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ASN1_TIME_free _cffi_d_ASN1_TIME_free +#endif + +static ASN1_OCTET_STRING * _cffi_d_ASN1_TIME_new(void) +{ + return ASN1_TIME_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_TIME_new(PyObject *self, PyObject *noarg) +{ + ASN1_OCTET_STRING * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_TIME_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_ASN1_TIME_new _cffi_d_ASN1_TIME_new +#endif + +static int _cffi_d_ASN1_TIME_set_string(ASN1_OCTET_STRING * x0, char const * x1) +{ + return ASN1_TIME_set_string(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_TIME_set_string(PyObject *self, PyObject *args) +{ + ASN1_OCTET_STRING * x0; + char const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "ASN1_TIME_set_string", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_TIME_set_string(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ASN1_TIME_set_string _cffi_d_ASN1_TIME_set_string +#endif + +static ASN1_GENERALIZEDTIME * _cffi_d_ASN1_TIME_to_generalizedtime(ASN1_OCTET_STRING * x0, ASN1_GENERALIZEDTIME * * x1) +{ + return ASN1_TIME_to_generalizedtime(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_TIME_to_generalizedtime(PyObject *self, PyObject *args) +{ + ASN1_OCTET_STRING * x0; + ASN1_GENERALIZEDTIME * * x1; + Py_ssize_t datasize; + ASN1_GENERALIZEDTIME * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "ASN1_TIME_to_generalizedtime", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(14), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_GENERALIZEDTIME * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(14), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_TIME_to_generalizedtime(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(9)); +} +#else +# define _cffi_f_ASN1_TIME_to_generalizedtime _cffi_d_ASN1_TIME_to_generalizedtime +#endif + +static void _cffi_d_ASN1_UTF8STRING_free(ASN1_OCTET_STRING * x0) +{ + ASN1_UTF8STRING_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_UTF8STRING_free(PyObject *self, PyObject *arg0) +{ + ASN1_OCTET_STRING * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ASN1_UTF8STRING_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ASN1_UTF8STRING_free _cffi_d_ASN1_UTF8STRING_free +#endif + +static ASN1_OCTET_STRING * _cffi_d_ASN1_UTF8STRING_new(void) +{ + return ASN1_UTF8STRING_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ASN1_UTF8STRING_new(PyObject *self, PyObject *noarg) +{ + ASN1_OCTET_STRING * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ASN1_UTF8STRING_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_ASN1_UTF8STRING_new _cffi_d_ASN1_UTF8STRING_new +#endif + +static void _cffi_d_AUTHORITY_KEYID_free(AUTHORITY_KEYID * x0) +{ + AUTHORITY_KEYID_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_AUTHORITY_KEYID_free(PyObject *self, PyObject *arg0) +{ + AUTHORITY_KEYID * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2557), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (AUTHORITY_KEYID *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2557), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { AUTHORITY_KEYID_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_AUTHORITY_KEYID_free _cffi_d_AUTHORITY_KEYID_free +#endif + +static AUTHORITY_KEYID * _cffi_d_AUTHORITY_KEYID_new(void) +{ + return AUTHORITY_KEYID_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_AUTHORITY_KEYID_new(PyObject *self, PyObject *noarg) +{ + AUTHORITY_KEYID * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = AUTHORITY_KEYID_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2557)); +} +#else +# define _cffi_f_AUTHORITY_KEYID_new _cffi_d_AUTHORITY_KEYID_new +#endif + +static void _cffi_d_BASIC_CONSTRAINTS_free(BASIC_CONSTRAINTS * x0) +{ + BASIC_CONSTRAINTS_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BASIC_CONSTRAINTS_free(PyObject *self, PyObject *arg0) +{ + BASIC_CONSTRAINTS * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2560), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BASIC_CONSTRAINTS *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2560), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { BASIC_CONSTRAINTS_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_BASIC_CONSTRAINTS_free _cffi_d_BASIC_CONSTRAINTS_free +#endif + +static BASIC_CONSTRAINTS * _cffi_d_BASIC_CONSTRAINTS_new(void) +{ + return BASIC_CONSTRAINTS_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BASIC_CONSTRAINTS_new(PyObject *self, PyObject *noarg) +{ + BASIC_CONSTRAINTS * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BASIC_CONSTRAINTS_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2560)); +} +#else +# define _cffi_f_BASIC_CONSTRAINTS_new _cffi_d_BASIC_CONSTRAINTS_new +#endif + +static void _cffi_d_BIO_clear_retry_flags(BIO * x0) +{ + BIO_clear_retry_flags(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_clear_retry_flags(PyObject *self, PyObject *arg0) +{ + BIO * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { BIO_clear_retry_flags(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_BIO_clear_retry_flags _cffi_d_BIO_clear_retry_flags +#endif + +static size_t _cffi_d_BIO_ctrl_pending(BIO * x0) +{ + return BIO_ctrl_pending(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_ctrl_pending(PyObject *self, PyObject *arg0) +{ + BIO * x0; + Py_ssize_t datasize; + size_t result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_ctrl_pending(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, size_t); +} +#else +# define _cffi_f_BIO_ctrl_pending _cffi_d_BIO_ctrl_pending +#endif + +static int _cffi_d_BIO_free(BIO * x0) +{ + return BIO_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_free(PyObject *self, PyObject *arg0) +{ + BIO * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BIO_free _cffi_d_BIO_free +#endif + +static void _cffi_d_BIO_free_all(BIO * x0) +{ + BIO_free_all(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_free_all(PyObject *self, PyObject *arg0) +{ + BIO * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { BIO_free_all(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_BIO_free_all _cffi_d_BIO_free_all +#endif + +static long _cffi_d_BIO_get_mem_data(BIO * x0, char * * x1) +{ + return BIO_get_mem_data(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_get_mem_data(PyObject *self, PyObject *args) +{ + BIO * x0; + char * * x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BIO_get_mem_data", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2290), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2290), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_get_mem_data(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_BIO_get_mem_data _cffi_d_BIO_get_mem_data +#endif + +static int _cffi_d_BIO_gets(BIO * x0, char * x1, int x2) +{ + return BIO_gets(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_gets(PyObject *self, PyObject *args) +{ + BIO * x0; + char * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "BIO_gets", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(409), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_gets(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BIO_gets _cffi_d_BIO_gets +#endif + +static BIO * _cffi_d_BIO_new(BIO_METHOD * x0) +{ + return BIO_new(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_new(PyObject *self, PyObject *arg0) +{ + BIO_METHOD * x0; + Py_ssize_t datasize; + BIO * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(115), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO_METHOD *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(115), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_new(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(186)); +} +#else +# define _cffi_f_BIO_new _cffi_d_BIO_new +#endif + +static BIO * _cffi_d_BIO_new_dgram(int x0, int x1) +{ + return BIO_new_dgram(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_new_dgram(PyObject *self, PyObject *args) +{ + int x0; + int x1; + BIO * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BIO_new_dgram", 2, 2, &arg0, &arg1)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_new_dgram(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(186)); +} +#else +# define _cffi_f_BIO_new_dgram _cffi_d_BIO_new_dgram +#endif + +static BIO * _cffi_d_BIO_new_file(char const * x0, char const * x1) +{ + return BIO_new_file(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_new_file(PyObject *self, PyObject *args) +{ + char const * x0; + char const * x1; + Py_ssize_t datasize; + BIO * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BIO_new_file", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_new_file(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(186)); +} +#else +# define _cffi_f_BIO_new_file _cffi_d_BIO_new_file +#endif + +static BIO * _cffi_d_BIO_new_mem_buf(void const * x0, int x1) +{ + return BIO_new_mem_buf(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_new_mem_buf(PyObject *self, PyObject *args) +{ + void const * x0; + int x1; + Py_ssize_t datasize; + BIO * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BIO_new_mem_buf", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (void const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(126), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_new_mem_buf(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(186)); +} +#else +# define _cffi_f_BIO_new_mem_buf _cffi_d_BIO_new_mem_buf +#endif + +static int _cffi_d_BIO_read(BIO * x0, void * x1, int x2) +{ + return BIO_read(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_read(PyObject *self, PyObject *args) +{ + BIO * x0; + void * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "BIO_read", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_read(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BIO_read _cffi_d_BIO_read +#endif + +static int _cffi_d_BIO_reset(BIO * x0) +{ + return BIO_reset(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_reset(PyObject *self, PyObject *arg0) +{ + BIO * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_reset(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BIO_reset _cffi_d_BIO_reset +#endif + +static BIO_METHOD * _cffi_d_BIO_s_datagram(void) +{ + return BIO_s_datagram(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_s_datagram(PyObject *self, PyObject *noarg) +{ + BIO_METHOD * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_s_datagram(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(115)); +} +#else +# define _cffi_f_BIO_s_datagram _cffi_d_BIO_s_datagram +#endif + +static BIO_METHOD * _cffi_d_BIO_s_mem(void) +{ + return BIO_s_mem(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_s_mem(PyObject *self, PyObject *noarg) +{ + BIO_METHOD * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_s_mem(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(115)); +} +#else +# define _cffi_f_BIO_s_mem _cffi_d_BIO_s_mem +#endif + +static long _cffi_d_BIO_set_mem_eof_return(BIO * x0, int x1) +{ + return BIO_set_mem_eof_return(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_set_mem_eof_return(PyObject *self, PyObject *args) +{ + BIO * x0; + int x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BIO_set_mem_eof_return", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_set_mem_eof_return(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_BIO_set_mem_eof_return _cffi_d_BIO_set_mem_eof_return +#endif + +static void _cffi_d_BIO_set_retry_read(BIO * x0) +{ + BIO_set_retry_read(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_set_retry_read(PyObject *self, PyObject *arg0) +{ + BIO * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { BIO_set_retry_read(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_BIO_set_retry_read _cffi_d_BIO_set_retry_read +#endif + +static int _cffi_d_BIO_should_io_special(BIO * x0) +{ + return BIO_should_io_special(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_should_io_special(PyObject *self, PyObject *arg0) +{ + BIO * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_should_io_special(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BIO_should_io_special _cffi_d_BIO_should_io_special +#endif + +static int _cffi_d_BIO_should_read(BIO * x0) +{ + return BIO_should_read(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_should_read(PyObject *self, PyObject *arg0) +{ + BIO * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_should_read(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BIO_should_read _cffi_d_BIO_should_read +#endif + +static int _cffi_d_BIO_should_retry(BIO * x0) +{ + return BIO_should_retry(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_should_retry(PyObject *self, PyObject *arg0) +{ + BIO * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_should_retry(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BIO_should_retry _cffi_d_BIO_should_retry +#endif + +static int _cffi_d_BIO_should_write(BIO * x0) +{ + return BIO_should_write(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_should_write(PyObject *self, PyObject *arg0) +{ + BIO * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_should_write(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BIO_should_write _cffi_d_BIO_should_write +#endif + +static int _cffi_d_BIO_up_ref(BIO * x0) +{ + return BIO_up_ref(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_up_ref(PyObject *self, PyObject *arg0) +{ + BIO * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_up_ref(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BIO_up_ref _cffi_d_BIO_up_ref +#endif + +static int _cffi_d_BIO_write(BIO * x0, void const * x1, int x2) +{ + return BIO_write(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BIO_write(PyObject *self, PyObject *args) +{ + BIO * x0; + void const * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "BIO_write", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(126), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BIO_write(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BIO_write _cffi_d_BIO_write +#endif + +static void _cffi_d_BN_CTX_end(BN_CTX * x0) +{ + BN_CTX_end(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_CTX_end(PyObject *self, PyObject *arg0) +{ + BN_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(94), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { BN_CTX_end(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_BN_CTX_end _cffi_d_BN_CTX_end +#endif + +static void _cffi_d_BN_CTX_free(BN_CTX * x0) +{ + BN_CTX_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_CTX_free(PyObject *self, PyObject *arg0) +{ + BN_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(94), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { BN_CTX_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_BN_CTX_free _cffi_d_BN_CTX_free +#endif + +static BIGNUM * _cffi_d_BN_CTX_get(BN_CTX * x0) +{ + return BN_CTX_get(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_CTX_get(PyObject *self, PyObject *arg0) +{ + BN_CTX * x0; + Py_ssize_t datasize; + BIGNUM * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(94), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_CTX_get(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(20)); +} +#else +# define _cffi_f_BN_CTX_get _cffi_d_BN_CTX_get +#endif + +static BN_CTX * _cffi_d_BN_CTX_new(void) +{ + return BN_CTX_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_CTX_new(PyObject *self, PyObject *noarg) +{ + BN_CTX * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_CTX_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(94)); +} +#else +# define _cffi_f_BN_CTX_new _cffi_d_BN_CTX_new +#endif + +static void _cffi_d_BN_CTX_start(BN_CTX * x0) +{ + BN_CTX_start(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_CTX_start(PyObject *self, PyObject *arg0) +{ + BN_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(94), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { BN_CTX_start(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_BN_CTX_start _cffi_d_BN_CTX_start +#endif + +static void _cffi_d_BN_MONT_CTX_free(BN_MONT_CTX * x0) +{ + BN_MONT_CTX_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_MONT_CTX_free(PyObject *self, PyObject *arg0) +{ + BN_MONT_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(830), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BN_MONT_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(830), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { BN_MONT_CTX_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_BN_MONT_CTX_free _cffi_d_BN_MONT_CTX_free +#endif + +static BN_MONT_CTX * _cffi_d_BN_MONT_CTX_new(void) +{ + return BN_MONT_CTX_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_MONT_CTX_new(PyObject *self, PyObject *noarg) +{ + BN_MONT_CTX * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_MONT_CTX_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(830)); +} +#else +# define _cffi_f_BN_MONT_CTX_new _cffi_d_BN_MONT_CTX_new +#endif + +static int _cffi_d_BN_MONT_CTX_set(BN_MONT_CTX * x0, BIGNUM const * x1, BN_CTX * x2) +{ + return BN_MONT_CTX_set(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_MONT_CTX_set(PyObject *self, PyObject *args) +{ + BN_MONT_CTX * x0; + BIGNUM const * x1; + BN_CTX * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "BN_MONT_CTX_set", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(830), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BN_MONT_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(830), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(94), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_MONT_CTX_set(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_MONT_CTX_set _cffi_d_BN_MONT_CTX_set +#endif + +static int _cffi_d_BN_add(BIGNUM * x0, BIGNUM const * x1, BIGNUM const * x2) +{ + return BN_add(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_add(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + BIGNUM const * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "BN_add", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_add(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_add _cffi_d_BN_add +#endif + +static BIGNUM * _cffi_d_BN_bin2bn(unsigned char const * x0, int x1, BIGNUM * x2) +{ + return BN_bin2bn(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_bin2bn(PyObject *self, PyObject *args) +{ + unsigned char const * x0; + int x1; + BIGNUM * x2; + Py_ssize_t datasize; + BIGNUM * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "BN_bin2bn", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(103), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_bin2bn(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(20)); +} +#else +# define _cffi_f_BN_bin2bn _cffi_d_BN_bin2bn +#endif + +static int _cffi_d_BN_bn2bin(BIGNUM const * x0, unsigned char * x1) +{ + return BN_bn2bin(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_bn2bin(PyObject *self, PyObject *args) +{ + BIGNUM const * x0; + unsigned char * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BN_bn2bin", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(92), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_bn2bin(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_bn2bin _cffi_d_BN_bn2bin +#endif + +static char * _cffi_d_BN_bn2hex(BIGNUM const * x0) +{ + return BN_bn2hex(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_bn2hex(PyObject *self, PyObject *arg0) +{ + BIGNUM const * x0; + Py_ssize_t datasize; + char * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(92), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_bn2hex(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(409)); +} +#else +# define _cffi_f_BN_bn2hex _cffi_d_BN_bn2hex +#endif + +static void _cffi_d_BN_clear_free(BIGNUM * x0) +{ + BN_clear_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_clear_free(PyObject *self, PyObject *arg0) +{ + BIGNUM * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { BN_clear_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_BN_clear_free _cffi_d_BN_clear_free +#endif + +static int _cffi_d_BN_cmp(BIGNUM const * x0, BIGNUM const * x1) +{ + return BN_cmp(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_cmp(PyObject *self, PyObject *args) +{ + BIGNUM const * x0; + BIGNUM const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BN_cmp", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(92), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_cmp(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_cmp _cffi_d_BN_cmp +#endif + +static BIGNUM * _cffi_d_BN_dup(BIGNUM const * x0) +{ + return BN_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_dup(PyObject *self, PyObject *arg0) +{ + BIGNUM const * x0; + Py_ssize_t datasize; + BIGNUM * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(92), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(20)); +} +#else +# define _cffi_f_BN_dup _cffi_d_BN_dup +#endif + +static void _cffi_d_BN_free(BIGNUM * x0) +{ + BN_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_free(PyObject *self, PyObject *arg0) +{ + BIGNUM * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { BN_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_BN_free _cffi_d_BN_free +#endif + +static int _cffi_d_BN_generate_prime_ex(BIGNUM * x0, int x1, int x2, BIGNUM const * x3, BIGNUM const * x4, BN_GENCB * x5) +{ + return BN_generate_prime_ex(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_generate_prime_ex(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + int x1; + int x2; + BIGNUM const * x3; + BIGNUM const * x4; + BN_GENCB * x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "BN_generate_prime_ex", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(92), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(92), arg4) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(848), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (BN_GENCB *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(848), arg5) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_generate_prime_ex(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_generate_prime_ex _cffi_d_BN_generate_prime_ex +#endif + +static int _cffi_d_BN_hex2bn(BIGNUM * * x0, char const * x1) +{ + return BN_hex2bn(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_hex2bn(PyObject *self, PyObject *args) +{ + BIGNUM * * x0; + char const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BN_hex2bn", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(805), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM * *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(805), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_hex2bn(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_hex2bn _cffi_d_BN_hex2bn +#endif + +static int _cffi_d_BN_is_negative(BIGNUM const * x0) +{ + return BN_is_negative(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_is_negative(PyObject *self, PyObject *arg0) +{ + BIGNUM const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(92), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_is_negative(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_is_negative _cffi_d_BN_is_negative +#endif + +static int _cffi_d_BN_is_prime_ex(BIGNUM const * x0, int x1, BN_CTX * x2, BN_GENCB * x3) +{ + return BN_is_prime_ex(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_is_prime_ex(PyObject *self, PyObject *args) +{ + BIGNUM const * x0; + int x1; + BN_CTX * x2; + BN_GENCB * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "BN_is_prime_ex", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(92), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(94), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(848), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BN_GENCB *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(848), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_is_prime_ex(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_is_prime_ex _cffi_d_BN_is_prime_ex +#endif + +static int _cffi_d_BN_mod(BIGNUM * x0, BIGNUM const * x1, BIGNUM const * x2, BN_CTX * x3) +{ + return BN_mod(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_mod(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + BIGNUM const * x2; + BN_CTX * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "BN_mod", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(94), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_mod(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_mod _cffi_d_BN_mod +#endif + +static int _cffi_d_BN_mod_add(BIGNUM * x0, BIGNUM const * x1, BIGNUM const * x2, BIGNUM const * x3, BN_CTX * x4) +{ + return BN_mod_add(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_mod_add(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + BIGNUM const * x2; + BIGNUM const * x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "BN_mod_add", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(92), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_mod_add(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_mod_add _cffi_d_BN_mod_add +#endif + +static int _cffi_d_BN_mod_exp(BIGNUM * x0, BIGNUM const * x1, BIGNUM const * x2, BIGNUM const * x3, BN_CTX * x4) +{ + return BN_mod_exp(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_mod_exp(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + BIGNUM const * x2; + BIGNUM const * x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "BN_mod_exp", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(92), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_mod_exp(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_mod_exp _cffi_d_BN_mod_exp +#endif + +static int _cffi_d_BN_mod_exp_mont(BIGNUM * x0, BIGNUM const * x1, BIGNUM const * x2, BIGNUM const * x3, BN_CTX * x4, BN_MONT_CTX * x5) +{ + return BN_mod_exp_mont(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_mod_exp_mont(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + BIGNUM const * x2; + BIGNUM const * x3; + BN_CTX * x4; + BN_MONT_CTX * x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "BN_mod_exp_mont", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(92), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(830), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (BN_MONT_CTX *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(830), arg5) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_mod_exp_mont(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_mod_exp_mont _cffi_d_BN_mod_exp_mont +#endif + +static int _cffi_d_BN_mod_exp_mont_consttime(BIGNUM * x0, BIGNUM const * x1, BIGNUM const * x2, BIGNUM const * x3, BN_CTX * x4, BN_MONT_CTX * x5) +{ + return BN_mod_exp_mont_consttime(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_mod_exp_mont_consttime(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + BIGNUM const * x2; + BIGNUM const * x3; + BN_CTX * x4; + BN_MONT_CTX * x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "BN_mod_exp_mont_consttime", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(92), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(830), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (BN_MONT_CTX *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(830), arg5) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_mod_exp_mont_consttime(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_mod_exp_mont_consttime _cffi_d_BN_mod_exp_mont_consttime +#endif + +static BIGNUM * _cffi_d_BN_mod_inverse(BIGNUM * x0, BIGNUM const * x1, BIGNUM const * x2, BN_CTX * x3) +{ + return BN_mod_inverse(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_mod_inverse(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + BIGNUM const * x2; + BN_CTX * x3; + Py_ssize_t datasize; + BIGNUM * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "BN_mod_inverse", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(94), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_mod_inverse(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(20)); +} +#else +# define _cffi_f_BN_mod_inverse _cffi_d_BN_mod_inverse +#endif + +static int _cffi_d_BN_mod_mul(BIGNUM * x0, BIGNUM const * x1, BIGNUM const * x2, BIGNUM const * x3, BN_CTX * x4) +{ + return BN_mod_mul(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_mod_mul(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + BIGNUM const * x2; + BIGNUM const * x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "BN_mod_mul", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(92), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_mod_mul(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_mod_mul _cffi_d_BN_mod_mul +#endif + +static int _cffi_d_BN_mod_sub(BIGNUM * x0, BIGNUM const * x1, BIGNUM const * x2, BIGNUM const * x3, BN_CTX * x4) +{ + return BN_mod_sub(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_mod_sub(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + BIGNUM const * x2; + BIGNUM const * x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "BN_mod_sub", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(92), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_mod_sub(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_mod_sub _cffi_d_BN_mod_sub +#endif + +static BIGNUM * _cffi_d_BN_new(void) +{ + return BN_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_new(PyObject *self, PyObject *noarg) +{ + BIGNUM * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(20)); +} +#else +# define _cffi_f_BN_new _cffi_d_BN_new +#endif + +static int _cffi_d_BN_nnmod(BIGNUM * x0, BIGNUM const * x1, BIGNUM const * x2, BN_CTX * x3) +{ + return BN_nnmod(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_nnmod(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + BIGNUM const * x2; + BN_CTX * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "BN_nnmod", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(94), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_nnmod(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_nnmod _cffi_d_BN_nnmod +#endif + +static int _cffi_d_BN_num_bits(BIGNUM const * x0) +{ + return BN_num_bits(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_num_bits(PyObject *self, PyObject *arg0) +{ + BIGNUM const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(92), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_num_bits(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_num_bits _cffi_d_BN_num_bits +#endif + +static int _cffi_d_BN_num_bytes(BIGNUM const * x0) +{ + return BN_num_bytes(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_num_bytes(PyObject *self, PyObject *arg0) +{ + BIGNUM const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(92), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_num_bytes(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_num_bytes _cffi_d_BN_num_bytes +#endif + +static int _cffi_d_BN_prime_checks_for_size(int x0) +{ + return BN_prime_checks_for_size(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_prime_checks_for_size(PyObject *self, PyObject *arg0) +{ + int x0; + int result; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_prime_checks_for_size(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_prime_checks_for_size _cffi_d_BN_prime_checks_for_size +#endif + +static int _cffi_d_BN_rand_range(BIGNUM * x0, BIGNUM const * x1) +{ + return BN_rand_range(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_rand_range(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BN_rand_range", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_rand_range(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_rand_range _cffi_d_BN_rand_range +#endif + +static void _cffi_d_BN_set_flags(BIGNUM * x0, int x1) +{ + BN_set_flags(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_set_flags(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + int x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BN_set_flags", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { BN_set_flags(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_BN_set_flags _cffi_d_BN_set_flags +#endif + +static int _cffi_d_BN_set_word(BIGNUM * x0, BN_ULONG x1) +{ + return BN_set_word(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_set_word(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BN_ULONG x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BN_set_word", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, BN_ULONG); + if (x1 == (BN_ULONG)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_set_word(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_set_word _cffi_d_BN_set_word +#endif + +static int _cffi_d_BN_sub(BIGNUM * x0, BIGNUM const * x1, BIGNUM const * x2) +{ + return BN_sub(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_sub(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + BIGNUM const * x1; + BIGNUM const * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "BN_sub", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_sub(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_BN_sub _cffi_d_BN_sub +#endif + +static ASN1_INTEGER * _cffi_d_BN_to_ASN1_INTEGER(BIGNUM * x0, ASN1_INTEGER * x1) +{ + return BN_to_ASN1_INTEGER(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_to_ASN1_INTEGER(PyObject *self, PyObject *args) +{ + BIGNUM * x0; + ASN1_INTEGER * x1; + Py_ssize_t datasize; + ASN1_INTEGER * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "BN_to_ASN1_INTEGER", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(20), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(21), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(21), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_to_ASN1_INTEGER(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(21)); +} +#else +# define _cffi_f_BN_to_ASN1_INTEGER _cffi_d_BN_to_ASN1_INTEGER +#endif + +static BIGNUM const * _cffi_d_BN_value_one(void) +{ + return BN_value_one(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_BN_value_one(PyObject *self, PyObject *noarg) +{ + BIGNUM const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = BN_value_one(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(92)); +} +#else +# define _cffi_f_BN_value_one _cffi_d_BN_value_one +#endif + +static void _cffi_d_CERTIFICATEPOLICIES_free(Cryptography_STACK_OF_POLICYINFO * x0) +{ + CERTIFICATEPOLICIES_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_CERTIFICATEPOLICIES_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_POLICYINFO * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(449), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_POLICYINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(449), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { CERTIFICATEPOLICIES_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_CERTIFICATEPOLICIES_free _cffi_d_CERTIFICATEPOLICIES_free +#endif + +static int _cffi_d_CMAC_CTX_copy(CMAC_CTX * x0, CMAC_CTX const * x1) +{ + return CMAC_CTX_copy(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_CMAC_CTX_copy(PyObject *self, PyObject *args) +{ + CMAC_CTX * x0; + CMAC_CTX const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "CMAC_CTX_copy", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1031), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (CMAC_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1031), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1032), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (CMAC_CTX const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1032), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = CMAC_CTX_copy(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_CMAC_CTX_copy _cffi_d_CMAC_CTX_copy +#endif + +static void _cffi_d_CMAC_CTX_free(CMAC_CTX * x0) +{ + CMAC_CTX_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_CMAC_CTX_free(PyObject *self, PyObject *arg0) +{ + CMAC_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1031), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (CMAC_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1031), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { CMAC_CTX_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_CMAC_CTX_free _cffi_d_CMAC_CTX_free +#endif + +static CMAC_CTX * _cffi_d_CMAC_CTX_new(void) +{ + return CMAC_CTX_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_CMAC_CTX_new(PyObject *self, PyObject *noarg) +{ + CMAC_CTX * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = CMAC_CTX_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1031)); +} +#else +# define _cffi_f_CMAC_CTX_new _cffi_d_CMAC_CTX_new +#endif + +static int _cffi_d_CMAC_Final(CMAC_CTX * x0, unsigned char * x1, size_t * x2) +{ + return CMAC_Final(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_CMAC_Final(PyObject *self, PyObject *args) +{ + CMAC_CTX * x0; + unsigned char * x1; + size_t * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "CMAC_Final", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1031), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (CMAC_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1031), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (size_t *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1037), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = CMAC_Final(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_CMAC_Final _cffi_d_CMAC_Final +#endif + +static int _cffi_d_CMAC_Init(CMAC_CTX * x0, void const * x1, size_t x2, EVP_CIPHER const * x3, ENGINE * x4) +{ + return CMAC_Init(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_CMAC_Init(PyObject *self, PyObject *args) +{ + CMAC_CTX * x0; + void const * x1; + size_t x2; + EVP_CIPHER const * x3; + ENGINE * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "CMAC_Init", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1031), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (CMAC_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1031), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(126), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(885), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (EVP_CIPHER const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(885), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(282), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = CMAC_Init(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_CMAC_Init _cffi_d_CMAC_Init +#endif + +static int _cffi_d_CMAC_Update(CMAC_CTX * x0, void const * x1, size_t x2) +{ + return CMAC_Update(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_CMAC_Update(PyObject *self, PyObject *args) +{ + CMAC_CTX * x0; + void const * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "CMAC_Update", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1031), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (CMAC_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1031), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(126), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = CMAC_Update(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_CMAC_Update _cffi_d_CMAC_Update +#endif + +static void _cffi_d_CRL_DIST_POINTS_free(Cryptography_STACK_OF_DIST_POINT * x0) +{ + CRL_DIST_POINTS_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_CRL_DIST_POINTS_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_DIST_POINT * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(204), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_DIST_POINT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(204), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { CRL_DIST_POINTS_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_CRL_DIST_POINTS_free _cffi_d_CRL_DIST_POINTS_free +#endif + +static int _cffi_d_Cryptography_CRYPTO_set_mem_functions(void *(* x0)(size_t, char const *, int), void *(* x1)(void *, size_t, char const *, int), void(* x2)(void *, char const *, int)) +{ + return Cryptography_CRYPTO_set_mem_functions(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_CRYPTO_set_mem_functions(PyObject *self, PyObject *args) +{ + void *(* x0)(size_t, char const *, int); + void *(* x1)(void *, size_t, char const *, int); + void(* x2)(void *, char const *, int); + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "Cryptography_CRYPTO_set_mem_functions", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + x0 = (void *(*)(size_t, char const *, int))_cffi_to_c_pointer(arg0, _cffi_type(2269)); + if (x0 == (void *(*)(size_t, char const *, int))NULL && PyErr_Occurred()) + return NULL; + + x1 = (void *(*)(void *, size_t, char const *, int))_cffi_to_c_pointer(arg1, _cffi_type(2270)); + if (x1 == (void *(*)(void *, size_t, char const *, int))NULL && PyErr_Occurred()) + return NULL; + + x2 = (void(*)(void *, char const *, int))_cffi_to_c_pointer(arg2, _cffi_type(2271)); + if (x2 == (void(*)(void *, char const *, int))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_CRYPTO_set_mem_functions(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_Cryptography_CRYPTO_set_mem_functions _cffi_d_Cryptography_CRYPTO_set_mem_functions +#endif + +static int _cffi_d_Cryptography_DH_check(DH const * x0, int * x1) +{ + return Cryptography_DH_check(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_DH_check(PyObject *self, PyObject *args) +{ + DH const * x0; + int * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "Cryptography_DH_check", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1165), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DH const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1165), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (int *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1169), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_DH_check(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_Cryptography_DH_check _cffi_d_Cryptography_DH_check +#endif + +static long _cffi_d_Cryptography_DTLSv1_get_timeout(SSL * x0, time_t * x1, long * x2) +{ + return Cryptography_DTLSv1_get_timeout(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_DTLSv1_get_timeout(PyObject *self, PyObject *args) +{ + SSL * x0; + time_t * x1; + long * x2; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "Cryptography_DTLSv1_get_timeout", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2313), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (time_t *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2313), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2314), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (long *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2314), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_DTLSv1_get_timeout(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_Cryptography_DTLSv1_get_timeout _cffi_d_Cryptography_DTLSv1_get_timeout +#endif + +static void _cffi_d_Cryptography_EVP_MD_CTX_free(EVP_MD_CTX * x0) +{ + Cryptography_EVP_MD_CTX_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_EVP_MD_CTX_free(PyObject *self, PyObject *arg0) +{ + EVP_MD_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { Cryptography_EVP_MD_CTX_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_Cryptography_EVP_MD_CTX_free _cffi_d_Cryptography_EVP_MD_CTX_free +#endif + +static EVP_MD_CTX * _cffi_d_Cryptography_EVP_MD_CTX_new(void) +{ + return Cryptography_EVP_MD_CTX_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_EVP_MD_CTX_new(PyObject *self, PyObject *noarg) +{ + EVP_MD_CTX * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_EVP_MD_CTX_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1351)); +} +#else +# define _cffi_f_Cryptography_EVP_MD_CTX_new _cffi_d_Cryptography_EVP_MD_CTX_new +#endif + +static int _cffi_d_Cryptography_EVP_PKEY_id(EVP_PKEY const * x0) +{ + return Cryptography_EVP_PKEY_id(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_EVP_PKEY_id(PyObject *self, PyObject *arg0) +{ + EVP_PKEY const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1445), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1445), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_EVP_PKEY_id(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_Cryptography_EVP_PKEY_id _cffi_d_Cryptography_EVP_PKEY_id +#endif + +static X509_REVOKED * _cffi_d_Cryptography_X509_REVOKED_dup(X509_REVOKED * x0) +{ + return Cryptography_X509_REVOKED_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_X509_REVOKED_dup(PyObject *self, PyObject *arg0) +{ + X509_REVOKED * x0; + Py_ssize_t datasize; + X509_REVOKED * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(619), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(619), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_X509_REVOKED_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(619)); +} +#else +# define _cffi_f_Cryptography_X509_REVOKED_dup _cffi_d_Cryptography_X509_REVOKED_dup +#endif + +static int _cffi_d_Cryptography_add_osrandom_engine(void) +{ + return Cryptography_add_osrandom_engine(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_add_osrandom_engine(PyObject *self, PyObject *noarg) +{ + int result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_add_osrandom_engine(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_Cryptography_add_osrandom_engine _cffi_d_Cryptography_add_osrandom_engine +#endif + +static DH * _cffi_d_Cryptography_d2i_DHxparams_bio(BIO * x0, DH * * x1) +{ + return Cryptography_d2i_DHxparams_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_d2i_DHxparams_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + DH * * x1; + Py_ssize_t datasize; + DH * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "Cryptography_d2i_DHxparams_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(187), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DH * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(187), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_d2i_DHxparams_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(196)); +} +#else +# define _cffi_f_Cryptography_d2i_DHxparams_bio _cffi_d_Cryptography_d2i_DHxparams_bio +#endif + +static void _cffi_d_Cryptography_free_wrapper(void * x0, char const * x1, int x2) +{ + Cryptography_free_wrapper(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_free_wrapper(PyObject *self, PyObject *args) +{ + void * x0; + char const * x1; + int x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "Cryptography_free_wrapper", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (void *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(193), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { Cryptography_free_wrapper(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_Cryptography_free_wrapper _cffi_d_Cryptography_free_wrapper +#endif + +static int _cffi_d_Cryptography_i2d_DHxparams_bio(BIO * x0, DH * x1) +{ + return Cryptography_i2d_DHxparams_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_i2d_DHxparams_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + DH * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "Cryptography_i2d_DHxparams_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DH *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(196), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_i2d_DHxparams_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_Cryptography_i2d_DHxparams_bio _cffi_d_Cryptography_i2d_DHxparams_bio +#endif + +static void * _cffi_d_Cryptography_malloc_wrapper(size_t x0, char const * x1, int x2) +{ + return Cryptography_malloc_wrapper(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_malloc_wrapper(PyObject *self, PyObject *args) +{ + size_t x0; + char const * x1; + int x2; + Py_ssize_t datasize; + void * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "Cryptography_malloc_wrapper", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + x0 = _cffi_to_c_int(arg0, size_t); + if (x0 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_malloc_wrapper(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(193)); +} +#else +# define _cffi_f_Cryptography_malloc_wrapper _cffi_d_Cryptography_malloc_wrapper +#endif + +static int _cffi_d_Cryptography_pem_password_cb(char * x0, int x1, int x2, void * x3) +{ + return Cryptography_pem_password_cb(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_pem_password_cb(PyObject *self, PyObject *args) +{ + char * x0; + int x1; + int x2; + void * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "Cryptography_pem_password_cb", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(409), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_pem_password_cb(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_Cryptography_pem_password_cb _cffi_d_Cryptography_pem_password_cb +#endif + +static void * _cffi_d_Cryptography_realloc_wrapper(void * x0, size_t x1, char const * x2, int x3) +{ + return Cryptography_realloc_wrapper(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_realloc_wrapper(PyObject *self, PyObject *args) +{ + void * x0; + size_t x1; + char const * x2; + int x3; + Py_ssize_t datasize; + void * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "Cryptography_realloc_wrapper", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (void *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(193), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, size_t); + if (x1 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (char const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(46), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_realloc_wrapper(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(193)); +} +#else +# define _cffi_f_Cryptography_realloc_wrapper _cffi_d_Cryptography_realloc_wrapper +#endif + +static int _cffi_d_DH_compute_key(unsigned char * x0, BIGNUM const * x1, DH * x2) +{ + return DH_compute_key(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DH_compute_key(PyObject *self, PyObject *args) +{ + unsigned char * x0; + BIGNUM const * x1; + DH * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "DH_compute_key", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(752), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (DH *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(196), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DH_compute_key(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DH_compute_key _cffi_d_DH_compute_key +#endif + +static void _cffi_d_DH_free(DH * x0) +{ + DH_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DH_free(PyObject *self, PyObject *arg0) +{ + DH * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DH *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(196), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { DH_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_DH_free _cffi_d_DH_free +#endif + +static int _cffi_d_DH_generate_key(DH * x0) +{ + return DH_generate_key(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DH_generate_key(PyObject *self, PyObject *arg0) +{ + DH * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DH *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(196), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DH_generate_key(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DH_generate_key _cffi_d_DH_generate_key +#endif + +static int _cffi_d_DH_generate_parameters_ex(DH * x0, int x1, int x2, BN_GENCB * x3) +{ + return DH_generate_parameters_ex(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DH_generate_parameters_ex(PyObject *self, PyObject *args) +{ + DH * x0; + int x1; + int x2; + BN_GENCB * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "DH_generate_parameters_ex", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DH *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(196), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(848), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BN_GENCB *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(848), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DH_generate_parameters_ex(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DH_generate_parameters_ex _cffi_d_DH_generate_parameters_ex +#endif + +static void _cffi_d_DH_get0_key(DH const * x0, BIGNUM const * * x1, BIGNUM const * * x2) +{ + DH_get0_key(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DH_get0_key(PyObject *self, PyObject *args) +{ + DH const * x0; + BIGNUM const * * x1; + BIGNUM const * * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "DH_get0_key", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1165), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DH const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1165), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2631), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2631), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { DH_get0_key(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_DH_get0_key _cffi_d_DH_get0_key +#endif + +static void _cffi_d_DH_get0_pqg(DH const * x0, BIGNUM const * * x1, BIGNUM const * * x2, BIGNUM const * * x3) +{ + DH_get0_pqg(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DH_get0_pqg(PyObject *self, PyObject *args) +{ + DH const * x0; + BIGNUM const * * x1; + BIGNUM const * * x2; + BIGNUM const * * x3; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "DH_get0_pqg", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1165), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DH const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1165), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2631), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2631), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(2631), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { DH_get0_pqg(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_DH_get0_pqg _cffi_d_DH_get0_pqg +#endif + +static DH * _cffi_d_DH_new(void) +{ + return DH_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DH_new(PyObject *self, PyObject *noarg) +{ + DH * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DH_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(196)); +} +#else +# define _cffi_f_DH_new _cffi_d_DH_new +#endif + +static int _cffi_d_DH_set0_key(DH * x0, BIGNUM * x1, BIGNUM * x2) +{ + return DH_set0_key(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DH_set0_key(PyObject *self, PyObject *args) +{ + DH * x0; + BIGNUM * x1; + BIGNUM * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "DH_set0_key", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DH *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(196), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(20), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DH_set0_key(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DH_set0_key _cffi_d_DH_set0_key +#endif + +static int _cffi_d_DH_set0_pqg(DH * x0, BIGNUM * x1, BIGNUM * x2, BIGNUM * x3) +{ + return DH_set0_pqg(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DH_set0_pqg(PyObject *self, PyObject *args) +{ + DH * x0; + BIGNUM * x1; + BIGNUM * x2; + BIGNUM * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "DH_set0_pqg", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DH *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(196), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(20), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(20), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DH_set0_pqg(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DH_set0_pqg _cffi_d_DH_set0_pqg +#endif + +static int _cffi_d_DH_size(DH const * x0) +{ + return DH_size(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DH_size(PyObject *self, PyObject *arg0) +{ + DH const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1165), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DH const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1165), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DH_size(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DH_size _cffi_d_DH_size +#endif + +static DH * _cffi_d_DHparams_dup(DH * x0) +{ + return DHparams_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DHparams_dup(PyObject *self, PyObject *arg0) +{ + DH * x0; + Py_ssize_t datasize; + DH * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DH *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(196), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DHparams_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(196)); +} +#else +# define _cffi_f_DHparams_dup _cffi_d_DHparams_dup +#endif + +static void _cffi_d_DIST_POINT_NAME_free(DIST_POINT_NAME * x0) +{ + DIST_POINT_NAME_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DIST_POINT_NAME_free(PyObject *self, PyObject *arg0) +{ + DIST_POINT_NAME * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2644), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DIST_POINT_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2644), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { DIST_POINT_NAME_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_DIST_POINT_NAME_free _cffi_d_DIST_POINT_NAME_free +#endif + +static DIST_POINT_NAME * _cffi_d_DIST_POINT_NAME_new(void) +{ + return DIST_POINT_NAME_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DIST_POINT_NAME_new(PyObject *self, PyObject *noarg) +{ + DIST_POINT_NAME * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DIST_POINT_NAME_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2644)); +} +#else +# define _cffi_f_DIST_POINT_NAME_new _cffi_d_DIST_POINT_NAME_new +#endif + +static void _cffi_d_DIST_POINT_free(DIST_POINT * x0) +{ + DIST_POINT_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DIST_POINT_free(PyObject *self, PyObject *arg0) +{ + DIST_POINT * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1077), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DIST_POINT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1077), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { DIST_POINT_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_DIST_POINT_free _cffi_d_DIST_POINT_free +#endif + +static DIST_POINT * _cffi_d_DIST_POINT_new(void) +{ + return DIST_POINT_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DIST_POINT_new(PyObject *self, PyObject *noarg) +{ + DIST_POINT * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DIST_POINT_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1077)); +} +#else +# define _cffi_f_DIST_POINT_new _cffi_d_DIST_POINT_new +#endif + +static void _cffi_d_DSA_free(DSA * x0) +{ + DSA_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSA_free(PyObject *self, PyObject *arg0) +{ + DSA * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(212), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(212), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { DSA_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_DSA_free _cffi_d_DSA_free +#endif + +static int _cffi_d_DSA_generate_key(DSA * x0) +{ + return DSA_generate_key(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSA_generate_key(PyObject *self, PyObject *arg0) +{ + DSA * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(212), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(212), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DSA_generate_key(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DSA_generate_key _cffi_d_DSA_generate_key +#endif + +static int _cffi_d_DSA_generate_parameters_ex(DSA * x0, int x1, unsigned char * x2, int x3, int * x4, unsigned long * x5, BN_GENCB * x6) +{ + return DSA_generate_parameters_ex(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSA_generate_parameters_ex(PyObject *self, PyObject *args) +{ + DSA * x0; + int x1; + unsigned char * x2; + int x3; + int * x4; + unsigned long * x5; + BN_GENCB * x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "DSA_generate_parameters_ex", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(212), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(212), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(752), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (int *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(1169), arg4) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1191), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (unsigned long *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(1191), arg5) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(848), arg6, (char **)&x6); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x6 = (BN_GENCB *)alloca((size_t)datasize); + memset((void *)x6, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x6, _cffi_type(848), arg6) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DSA_generate_parameters_ex(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DSA_generate_parameters_ex _cffi_d_DSA_generate_parameters_ex +#endif + +static void _cffi_d_DSA_get0_key(DSA const * x0, BIGNUM const * * x1, BIGNUM const * * x2) +{ + DSA_get0_key(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSA_get0_key(PyObject *self, PyObject *args) +{ + DSA const * x0; + BIGNUM const * * x1; + BIGNUM const * * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "DSA_get0_key", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1195), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DSA const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1195), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2631), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2631), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { DSA_get0_key(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_DSA_get0_key _cffi_d_DSA_get0_key +#endif + +static void _cffi_d_DSA_get0_pqg(DSA const * x0, BIGNUM const * * x1, BIGNUM const * * x2, BIGNUM const * * x3) +{ + DSA_get0_pqg(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSA_get0_pqg(PyObject *self, PyObject *args) +{ + DSA const * x0; + BIGNUM const * * x1; + BIGNUM const * * x2; + BIGNUM const * * x3; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "DSA_get0_pqg", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1195), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DSA const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1195), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2631), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2631), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(2631), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { DSA_get0_pqg(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_DSA_get0_pqg _cffi_d_DSA_get0_pqg +#endif + +static DSA * _cffi_d_DSA_new(void) +{ + return DSA_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSA_new(PyObject *self, PyObject *noarg) +{ + DSA * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DSA_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(212)); +} +#else +# define _cffi_f_DSA_new _cffi_d_DSA_new +#endif + +static int _cffi_d_DSA_set0_key(DSA * x0, BIGNUM * x1, BIGNUM * x2) +{ + return DSA_set0_key(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSA_set0_key(PyObject *self, PyObject *args) +{ + DSA * x0; + BIGNUM * x1; + BIGNUM * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "DSA_set0_key", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(212), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(212), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(20), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DSA_set0_key(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DSA_set0_key _cffi_d_DSA_set0_key +#endif + +static int _cffi_d_DSA_set0_pqg(DSA * x0, BIGNUM * x1, BIGNUM * x2, BIGNUM * x3) +{ + return DSA_set0_pqg(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSA_set0_pqg(PyObject *self, PyObject *args) +{ + DSA * x0; + BIGNUM * x1; + BIGNUM * x2; + BIGNUM * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "DSA_set0_pqg", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(212), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(212), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(20), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(20), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DSA_set0_pqg(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DSA_set0_pqg _cffi_d_DSA_set0_pqg +#endif + +static int _cffi_d_DSA_sign(int x0, unsigned char const * x1, int x2, unsigned char * x3, unsigned int * x4, DSA * x5) +{ + return DSA_sign(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSA_sign(PyObject *self, PyObject *args) +{ + int x0; + unsigned char const * x1; + int x2; + unsigned char * x3; + unsigned int * x4; + DSA * x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "DSA_sign", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(752), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1390), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (unsigned int *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(1390), arg4) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(212), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (DSA *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(212), arg5) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DSA_sign(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DSA_sign _cffi_d_DSA_sign +#endif + +static int _cffi_d_DSA_size(DSA const * x0) +{ + return DSA_size(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSA_size(PyObject *self, PyObject *arg0) +{ + DSA const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1195), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DSA const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1195), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DSA_size(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DSA_size _cffi_d_DSA_size +#endif + +static int _cffi_d_DSA_verify(int x0, unsigned char const * x1, int x2, unsigned char const * x3, int x4, DSA * x5) +{ + return DSA_verify(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSA_verify(PyObject *self, PyObject *args) +{ + int x0; + unsigned char const * x1; + int x2; + unsigned char const * x3; + int x4; + DSA * x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "DSA_verify", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(212), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (DSA *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(212), arg5) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DSA_verify(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_DSA_verify _cffi_d_DSA_verify +#endif + +static DSA * _cffi_d_DSAparams_dup(DSA * x0) +{ + return DSAparams_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DSAparams_dup(PyObject *self, PyObject *arg0) +{ + DSA * x0; + Py_ssize_t datasize; + DSA * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(212), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (DSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(212), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DSAparams_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(212)); +} +#else +# define _cffi_f_DSAparams_dup _cffi_d_DSAparams_dup +#endif + +static SSL_METHOD const * _cffi_d_DTLS_client_method(void) +{ + return DTLS_client_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DTLS_client_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DTLS_client_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_DTLS_client_method _cffi_d_DTLS_client_method +#endif + +static long _cffi_d_DTLS_get_link_min_mtu(SSL * x0) +{ + return DTLS_get_link_min_mtu(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DTLS_get_link_min_mtu(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DTLS_get_link_min_mtu(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_DTLS_get_link_min_mtu _cffi_d_DTLS_get_link_min_mtu +#endif + +static SSL_METHOD const * _cffi_d_DTLS_method(void) +{ + return DTLS_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DTLS_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DTLS_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_DTLS_method _cffi_d_DTLS_method +#endif + +static SSL_METHOD const * _cffi_d_DTLS_server_method(void) +{ + return DTLS_server_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DTLS_server_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DTLS_server_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_DTLS_server_method _cffi_d_DTLS_server_method +#endif + +static long _cffi_d_DTLS_set_link_mtu(SSL * x0, long x1) +{ + return DTLS_set_link_mtu(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DTLS_set_link_mtu(PyObject *self, PyObject *args) +{ + SSL * x0; + long x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "DTLS_set_link_mtu", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DTLS_set_link_mtu(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_DTLS_set_link_mtu _cffi_d_DTLS_set_link_mtu +#endif + +static SSL_METHOD const * _cffi_d_DTLSv1_client_method(void) +{ + return DTLSv1_client_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DTLSv1_client_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DTLSv1_client_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_DTLSv1_client_method _cffi_d_DTLSv1_client_method +#endif + +static long _cffi_d_DTLSv1_handle_timeout(SSL * x0) +{ + return DTLSv1_handle_timeout(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DTLSv1_handle_timeout(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DTLSv1_handle_timeout(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_DTLSv1_handle_timeout _cffi_d_DTLSv1_handle_timeout +#endif + +static SSL_METHOD const * _cffi_d_DTLSv1_method(void) +{ + return DTLSv1_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DTLSv1_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DTLSv1_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_DTLSv1_method _cffi_d_DTLSv1_method +#endif + +static SSL_METHOD const * _cffi_d_DTLSv1_server_method(void) +{ + return DTLSv1_server_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_DTLSv1_server_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = DTLSv1_server_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_DTLSv1_server_method _cffi_d_DTLSv1_server_method +#endif + +static int _cffi_d_ECDH_compute_key(void * x0, size_t x1, EC_POINT const * x2, EC_KEY * x3, void *(* x4)(void const *, size_t, void *, size_t *)) +{ + return ECDH_compute_key(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ECDH_compute_key(PyObject *self, PyObject *args) +{ + void * x0; + size_t x1; + EC_POINT const * x2; + EC_KEY * x3; + void *(* x4)(void const *, size_t, void *, size_t *); + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "ECDH_compute_key", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (void *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(193), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, size_t); + if (x1 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(244), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(893), arg3) < 0) + return NULL; + } + + x4 = (void *(*)(void const *, size_t, void *, size_t *))_cffi_to_c_pointer(arg4, _cffi_type(2278)); + if (x4 == (void *(*)(void const *, size_t, void *, size_t *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ECDH_compute_key(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ECDH_compute_key _cffi_d_ECDH_compute_key +#endif + +static int _cffi_d_ECDSA_sign(int x0, unsigned char const * x1, int x2, unsigned char * x3, unsigned int * x4, EC_KEY * x5) +{ + return ECDSA_sign(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ECDSA_sign(PyObject *self, PyObject *args) +{ + int x0; + unsigned char const * x1; + int x2; + unsigned char * x3; + unsigned int * x4; + EC_KEY * x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "ECDSA_sign", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(752), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1390), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (unsigned int *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(1390), arg4) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(893), arg5) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ECDSA_sign(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ECDSA_sign _cffi_d_ECDSA_sign +#endif + +static int _cffi_d_ECDSA_size(EC_KEY const * x0) +{ + return ECDSA_size(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ECDSA_size(PyObject *self, PyObject *arg0) +{ + EC_KEY const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(110), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_KEY const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(110), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ECDSA_size(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ECDSA_size _cffi_d_ECDSA_size +#endif + +static int _cffi_d_ECDSA_verify(int x0, unsigned char const * x1, int x2, unsigned char const * x3, int x4, EC_KEY * x5) +{ + return ECDSA_verify(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ECDSA_verify(PyObject *self, PyObject *args) +{ + int x0; + unsigned char const * x1; + int x2; + unsigned char const * x3; + int x4; + EC_KEY * x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "ECDSA_verify", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(893), arg5) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ECDSA_verify(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ECDSA_verify _cffi_d_ECDSA_verify +#endif + +static void _cffi_d_EC_GROUP_free(EC_GROUP * x0) +{ + EC_GROUP_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_GROUP_free(PyObject *self, PyObject *arg0) +{ + EC_GROUP * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2661), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2661), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { EC_GROUP_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_EC_GROUP_free _cffi_d_EC_GROUP_free +#endif + +static EC_POINT const * _cffi_d_EC_GROUP_get0_generator(EC_GROUP const * x0) +{ + return EC_GROUP_get0_generator(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_GROUP_get0_generator(PyObject *self, PyObject *arg0) +{ + EC_GROUP const * x0; + Py_ssize_t datasize; + EC_POINT const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_GROUP_get0_generator(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(244)); +} +#else +# define _cffi_f_EC_GROUP_get0_generator _cffi_d_EC_GROUP_get0_generator +#endif + +static int _cffi_d_EC_GROUP_get_asn1_flag(EC_GROUP const * x0) +{ + return EC_GROUP_get_asn1_flag(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_GROUP_get_asn1_flag(PyObject *self, PyObject *arg0) +{ + EC_GROUP const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_GROUP_get_asn1_flag(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_GROUP_get_asn1_flag _cffi_d_EC_GROUP_get_asn1_flag +#endif + +static int _cffi_d_EC_GROUP_get_curve_name(EC_GROUP const * x0) +{ + return EC_GROUP_get_curve_name(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_GROUP_get_curve_name(PyObject *self, PyObject *arg0) +{ + EC_GROUP const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_GROUP_get_curve_name(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_GROUP_get_curve_name _cffi_d_EC_GROUP_get_curve_name +#endif + +static int _cffi_d_EC_GROUP_get_degree(EC_GROUP const * x0) +{ + return EC_GROUP_get_degree(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_GROUP_get_degree(PyObject *self, PyObject *arg0) +{ + EC_GROUP const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_GROUP_get_degree(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_GROUP_get_degree _cffi_d_EC_GROUP_get_degree +#endif + +static int _cffi_d_EC_GROUP_get_order(EC_GROUP const * x0, BIGNUM * x1, BN_CTX * x2) +{ + return EC_GROUP_get_order(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_GROUP_get_order(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + BIGNUM * x1; + BN_CTX * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EC_GROUP_get_order", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(20), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(94), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_GROUP_get_order(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_GROUP_get_order _cffi_d_EC_GROUP_get_order +#endif + +static EC_METHOD const * _cffi_d_EC_GROUP_method_of(EC_GROUP const * x0) +{ + return EC_GROUP_method_of(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_GROUP_method_of(PyObject *self, PyObject *arg0) +{ + EC_GROUP const * x0; + Py_ssize_t datasize; + EC_METHOD const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_GROUP_method_of(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1298)); +} +#else +# define _cffi_f_EC_GROUP_method_of _cffi_d_EC_GROUP_method_of +#endif + +static EC_GROUP * _cffi_d_EC_GROUP_new_by_curve_name(int x0) +{ + return EC_GROUP_new_by_curve_name(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_GROUP_new_by_curve_name(PyObject *self, PyObject *arg0) +{ + int x0; + EC_GROUP * result; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_GROUP_new_by_curve_name(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2661)); +} +#else +# define _cffi_f_EC_GROUP_new_by_curve_name _cffi_d_EC_GROUP_new_by_curve_name +#endif + +static void _cffi_d_EC_KEY_free(EC_KEY * x0) +{ + EC_KEY_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_free(PyObject *self, PyObject *arg0) +{ + EC_KEY * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(893), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { EC_KEY_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_EC_KEY_free _cffi_d_EC_KEY_free +#endif + +static int _cffi_d_EC_KEY_generate_key(EC_KEY * x0) +{ + return EC_KEY_generate_key(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_generate_key(PyObject *self, PyObject *arg0) +{ + EC_KEY * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(893), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_KEY_generate_key(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_KEY_generate_key _cffi_d_EC_KEY_generate_key +#endif + +static EC_GROUP const * _cffi_d_EC_KEY_get0_group(EC_KEY const * x0) +{ + return EC_KEY_get0_group(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_get0_group(PyObject *self, PyObject *arg0) +{ + EC_KEY const * x0; + Py_ssize_t datasize; + EC_GROUP const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(110), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_KEY const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(110), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_KEY_get0_group(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(238)); +} +#else +# define _cffi_f_EC_KEY_get0_group _cffi_d_EC_KEY_get0_group +#endif + +static BIGNUM const * _cffi_d_EC_KEY_get0_private_key(EC_KEY const * x0) +{ + return EC_KEY_get0_private_key(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_get0_private_key(PyObject *self, PyObject *arg0) +{ + EC_KEY const * x0; + Py_ssize_t datasize; + BIGNUM const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(110), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_KEY const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(110), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_KEY_get0_private_key(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(92)); +} +#else +# define _cffi_f_EC_KEY_get0_private_key _cffi_d_EC_KEY_get0_private_key +#endif + +static EC_POINT const * _cffi_d_EC_KEY_get0_public_key(EC_KEY const * x0) +{ + return EC_KEY_get0_public_key(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_get0_public_key(PyObject *self, PyObject *arg0) +{ + EC_KEY const * x0; + Py_ssize_t datasize; + EC_POINT const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(110), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_KEY const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(110), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_KEY_get0_public_key(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(244)); +} +#else +# define _cffi_f_EC_KEY_get0_public_key _cffi_d_EC_KEY_get0_public_key +#endif + +static EC_KEY * _cffi_d_EC_KEY_new(void) +{ + return EC_KEY_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_new(PyObject *self, PyObject *noarg) +{ + EC_KEY * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_KEY_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(893)); +} +#else +# define _cffi_f_EC_KEY_new _cffi_d_EC_KEY_new +#endif + +static EC_KEY * _cffi_d_EC_KEY_new_by_curve_name(int x0) +{ + return EC_KEY_new_by_curve_name(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_new_by_curve_name(PyObject *self, PyObject *arg0) +{ + int x0; + EC_KEY * result; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_KEY_new_by_curve_name(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(893)); +} +#else +# define _cffi_f_EC_KEY_new_by_curve_name _cffi_d_EC_KEY_new_by_curve_name +#endif + +static void _cffi_d_EC_KEY_set_asn1_flag(EC_KEY * x0, int x1) +{ + EC_KEY_set_asn1_flag(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_set_asn1_flag(PyObject *self, PyObject *args) +{ + EC_KEY * x0; + int x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EC_KEY_set_asn1_flag", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(893), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { EC_KEY_set_asn1_flag(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_EC_KEY_set_asn1_flag _cffi_d_EC_KEY_set_asn1_flag +#endif + +static int _cffi_d_EC_KEY_set_group(EC_KEY * x0, EC_GROUP const * x1) +{ + return EC_KEY_set_group(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_set_group(PyObject *self, PyObject *args) +{ + EC_KEY * x0; + EC_GROUP const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EC_KEY_set_group", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(893), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(238), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_KEY_set_group(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_KEY_set_group _cffi_d_EC_KEY_set_group +#endif + +static int _cffi_d_EC_KEY_set_private_key(EC_KEY * x0, BIGNUM const * x1) +{ + return EC_KEY_set_private_key(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_set_private_key(PyObject *self, PyObject *args) +{ + EC_KEY * x0; + BIGNUM const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EC_KEY_set_private_key", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(893), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(92), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_KEY_set_private_key(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_KEY_set_private_key _cffi_d_EC_KEY_set_private_key +#endif + +static int _cffi_d_EC_KEY_set_public_key(EC_KEY * x0, EC_POINT const * x1) +{ + return EC_KEY_set_public_key(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_set_public_key(PyObject *self, PyObject *args) +{ + EC_KEY * x0; + EC_POINT const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EC_KEY_set_public_key", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(893), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(244), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_KEY_set_public_key(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_KEY_set_public_key _cffi_d_EC_KEY_set_public_key +#endif + +static int _cffi_d_EC_KEY_set_public_key_affine_coordinates(EC_KEY * x0, BIGNUM * x1, BIGNUM * x2) +{ + return EC_KEY_set_public_key_affine_coordinates(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_KEY_set_public_key_affine_coordinates(PyObject *self, PyObject *args) +{ + EC_KEY * x0; + BIGNUM * x1; + BIGNUM * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EC_KEY_set_public_key_affine_coordinates", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(893), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(20), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_KEY_set_public_key_affine_coordinates(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_KEY_set_public_key_affine_coordinates _cffi_d_EC_KEY_set_public_key_affine_coordinates +#endif + +static int _cffi_d_EC_METHOD_get_field_type(EC_METHOD const * x0) +{ + return EC_METHOD_get_field_type(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_METHOD_get_field_type(PyObject *self, PyObject *arg0) +{ + EC_METHOD const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1298), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_METHOD const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1298), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_METHOD_get_field_type(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_METHOD_get_field_type _cffi_d_EC_METHOD_get_field_type +#endif + +static int _cffi_d_EC_POINT_add(EC_GROUP const * x0, EC_POINT * x1, EC_POINT const * x2, EC_POINT const * x3, BN_CTX * x4) +{ + return EC_POINT_add(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_add(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT * x1; + EC_POINT const * x2; + EC_POINT const * x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EC_POINT_add", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1207), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1207), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(244), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(244), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_add(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_add _cffi_d_EC_POINT_add +#endif + +static void _cffi_d_EC_POINT_clear_free(EC_POINT * x0) +{ + EC_POINT_clear_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_clear_free(PyObject *self, PyObject *arg0) +{ + EC_POINT * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1207), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_POINT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1207), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { EC_POINT_clear_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_EC_POINT_clear_free _cffi_d_EC_POINT_clear_free +#endif + +static int _cffi_d_EC_POINT_cmp(EC_GROUP const * x0, EC_POINT const * x1, EC_POINT const * x2, BN_CTX * x3) +{ + return EC_POINT_cmp(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_cmp(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT const * x1; + EC_POINT const * x2; + BN_CTX * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "EC_POINT_cmp", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(244), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(244), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(94), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_cmp(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_cmp _cffi_d_EC_POINT_cmp +#endif + +static int _cffi_d_EC_POINT_dbl(EC_GROUP const * x0, EC_POINT * x1, EC_POINT const * x2, BN_CTX * x3) +{ + return EC_POINT_dbl(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_dbl(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT * x1; + EC_POINT const * x2; + BN_CTX * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "EC_POINT_dbl", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1207), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1207), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(244), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(94), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_dbl(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_dbl _cffi_d_EC_POINT_dbl +#endif + +static EC_POINT * _cffi_d_EC_POINT_dup(EC_POINT const * x0, EC_GROUP const * x1) +{ + return EC_POINT_dup(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_dup(PyObject *self, PyObject *args) +{ + EC_POINT const * x0; + EC_GROUP const * x1; + Py_ssize_t datasize; + EC_POINT * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EC_POINT_dup", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(244), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(238), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_dup(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1207)); +} +#else +# define _cffi_f_EC_POINT_dup _cffi_d_EC_POINT_dup +#endif + +static void _cffi_d_EC_POINT_free(EC_POINT * x0) +{ + EC_POINT_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_free(PyObject *self, PyObject *arg0) +{ + EC_POINT * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1207), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_POINT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1207), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { EC_POINT_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_EC_POINT_free _cffi_d_EC_POINT_free +#endif + +static int _cffi_d_EC_POINT_get_affine_coordinates_GF2m(EC_GROUP const * x0, EC_POINT const * x1, BIGNUM * x2, BIGNUM * x3, BN_CTX * x4) +{ + return EC_POINT_get_affine_coordinates_GF2m(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_get_affine_coordinates_GF2m(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT const * x1; + BIGNUM * x2; + BIGNUM * x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EC_POINT_get_affine_coordinates_GF2m", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(244), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(20), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_get_affine_coordinates_GF2m(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_get_affine_coordinates_GF2m _cffi_d_EC_POINT_get_affine_coordinates_GF2m +#endif + +static int _cffi_d_EC_POINT_get_affine_coordinates_GFp(EC_GROUP const * x0, EC_POINT const * x1, BIGNUM * x2, BIGNUM * x3, BN_CTX * x4) +{ + return EC_POINT_get_affine_coordinates_GFp(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_get_affine_coordinates_GFp(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT const * x1; + BIGNUM * x2; + BIGNUM * x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EC_POINT_get_affine_coordinates_GFp", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(244), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(20), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_get_affine_coordinates_GFp(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_get_affine_coordinates_GFp _cffi_d_EC_POINT_get_affine_coordinates_GFp +#endif + +static int _cffi_d_EC_POINT_invert(EC_GROUP const * x0, EC_POINT * x1, BN_CTX * x2) +{ + return EC_POINT_invert(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_invert(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT * x1; + BN_CTX * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EC_POINT_invert", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1207), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1207), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(94), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_invert(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_invert _cffi_d_EC_POINT_invert +#endif + +static int _cffi_d_EC_POINT_is_at_infinity(EC_GROUP const * x0, EC_POINT const * x1) +{ + return EC_POINT_is_at_infinity(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_is_at_infinity(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EC_POINT_is_at_infinity", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(244), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_is_at_infinity(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_is_at_infinity _cffi_d_EC_POINT_is_at_infinity +#endif + +static int _cffi_d_EC_POINT_is_on_curve(EC_GROUP const * x0, EC_POINT const * x1, BN_CTX * x2) +{ + return EC_POINT_is_on_curve(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_is_on_curve(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT const * x1; + BN_CTX * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EC_POINT_is_on_curve", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(244), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(94), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_is_on_curve(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_is_on_curve _cffi_d_EC_POINT_is_on_curve +#endif + +static int _cffi_d_EC_POINT_mul(EC_GROUP const * x0, EC_POINT * x1, BIGNUM const * x2, EC_POINT const * x3, BIGNUM const * x4, BN_CTX * x5) +{ + return EC_POINT_mul(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_mul(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT * x1; + BIGNUM const * x2; + EC_POINT const * x3; + BIGNUM const * x4; + BN_CTX * x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "EC_POINT_mul", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1207), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1207), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(244), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(92), arg4) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(94), arg5) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_mul(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_mul _cffi_d_EC_POINT_mul +#endif + +static EC_POINT * _cffi_d_EC_POINT_new(EC_GROUP const * x0) +{ + return EC_POINT_new(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_new(PyObject *self, PyObject *arg0) +{ + EC_GROUP const * x0; + Py_ssize_t datasize; + EC_POINT * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_new(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1207)); +} +#else +# define _cffi_f_EC_POINT_new _cffi_d_EC_POINT_new +#endif + +static int _cffi_d_EC_POINT_oct2point(EC_GROUP const * x0, EC_POINT * x1, unsigned char const * x2, size_t x3, BN_CTX * x4) +{ + return EC_POINT_oct2point(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_oct2point(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT * x1; + unsigned char const * x2; + size_t x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EC_POINT_oct2point", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1207), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1207), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(103), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, size_t); + if (x3 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_oct2point(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_oct2point _cffi_d_EC_POINT_oct2point +#endif + +static size_t _cffi_d_EC_POINT_point2oct(EC_GROUP const * x0, EC_POINT const * x1, point_conversion_form_t x2, unsigned char * x3, size_t x4, BN_CTX * x5) +{ + return EC_POINT_point2oct(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_point2oct(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT const * x1; + point_conversion_form_t x2; + unsigned char * x3; + size_t x4; + BN_CTX * x5; + Py_ssize_t datasize; + size_t result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "EC_POINT_point2oct", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(244), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(244), arg1) < 0) + return NULL; + } + + if (_cffi_to_c((char *)&x2, _cffi_type(2375), arg2) < 0) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(752), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, size_t); + if (x4 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(94), arg5) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_point2oct(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, size_t); +} +#else +# define _cffi_f_EC_POINT_point2oct _cffi_d_EC_POINT_point2oct +#endif + +static int _cffi_d_EC_POINT_set_affine_coordinates_GF2m(EC_GROUP const * x0, EC_POINT * x1, BIGNUM const * x2, BIGNUM const * x3, BN_CTX * x4) +{ + return EC_POINT_set_affine_coordinates_GF2m(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_set_affine_coordinates_GF2m(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT * x1; + BIGNUM const * x2; + BIGNUM const * x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EC_POINT_set_affine_coordinates_GF2m", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1207), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1207), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(92), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_set_affine_coordinates_GF2m(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_set_affine_coordinates_GF2m _cffi_d_EC_POINT_set_affine_coordinates_GF2m +#endif + +static int _cffi_d_EC_POINT_set_affine_coordinates_GFp(EC_GROUP const * x0, EC_POINT * x1, BIGNUM const * x2, BIGNUM const * x3, BN_CTX * x4) +{ + return EC_POINT_set_affine_coordinates_GFp(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_set_affine_coordinates_GFp(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT * x1; + BIGNUM const * x2; + BIGNUM const * x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EC_POINT_set_affine_coordinates_GFp", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1207), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1207), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(92), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_set_affine_coordinates_GFp(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_set_affine_coordinates_GFp _cffi_d_EC_POINT_set_affine_coordinates_GFp +#endif + +static int _cffi_d_EC_POINT_set_compressed_coordinates_GF2m(EC_GROUP const * x0, EC_POINT * x1, BIGNUM const * x2, int x3, BN_CTX * x4) +{ + return EC_POINT_set_compressed_coordinates_GF2m(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_set_compressed_coordinates_GF2m(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT * x1; + BIGNUM const * x2; + int x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EC_POINT_set_compressed_coordinates_GF2m", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1207), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1207), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_set_compressed_coordinates_GF2m(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_set_compressed_coordinates_GF2m _cffi_d_EC_POINT_set_compressed_coordinates_GF2m +#endif + +static int _cffi_d_EC_POINT_set_compressed_coordinates_GFp(EC_GROUP const * x0, EC_POINT * x1, BIGNUM const * x2, int x3, BN_CTX * x4) +{ + return EC_POINT_set_compressed_coordinates_GFp(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_POINT_set_compressed_coordinates_GFp(PyObject *self, PyObject *args) +{ + EC_GROUP const * x0; + EC_POINT * x1; + BIGNUM const * x2; + int x3; + BN_CTX * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EC_POINT_set_compressed_coordinates_GFp", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(238), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_GROUP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(238), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1207), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_POINT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1207), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(92), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(92), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(94), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_POINT_set_compressed_coordinates_GFp(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EC_POINT_set_compressed_coordinates_GFp _cffi_d_EC_POINT_set_compressed_coordinates_GFp +#endif + +static char const * _cffi_d_EC_curve_nid2nist(int x0) +{ + return EC_curve_nid2nist(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_curve_nid2nist(PyObject *self, PyObject *arg0) +{ + int x0; + char const * result; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_curve_nid2nist(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_EC_curve_nid2nist _cffi_d_EC_curve_nid2nist +#endif + +static size_t _cffi_d_EC_get_builtin_curves(EC_builtin_curve * x0, size_t x1) +{ + return EC_get_builtin_curves(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EC_get_builtin_curves(PyObject *self, PyObject *args) +{ + EC_builtin_curve * x0; + size_t x1; + Py_ssize_t datasize; + size_t result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EC_get_builtin_curves", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2381), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EC_builtin_curve *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2381), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, size_t); + if (x1 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EC_get_builtin_curves(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, size_t); +} +#else +# define _cffi_f_EC_get_builtin_curves _cffi_d_EC_get_builtin_curves +#endif + +static ENGINE * _cffi_d_ENGINE_by_id(char const * x0) +{ + return ENGINE_by_id(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_by_id(PyObject *self, PyObject *arg0) +{ + char const * x0; + Py_ssize_t datasize; + ENGINE * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ENGINE_by_id(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(282)); +} +#else +# define _cffi_f_ENGINE_by_id _cffi_d_ENGINE_by_id +#endif + +static int _cffi_d_ENGINE_ctrl_cmd(ENGINE * x0, char const * x1, long x2, void * x3, void(* x4)(void), int x5) +{ + return ENGINE_ctrl_cmd(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_ctrl_cmd(PyObject *self, PyObject *args) +{ + ENGINE * x0; + char const * x1; + long x2; + void * x3; + void(* x4)(void); + int x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "ENGINE_ctrl_cmd", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(282), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, long); + if (x2 == (long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + x4 = (void(*)(void))_cffi_to_c_pointer(arg4, _cffi_type(1314)); + if (x4 == (void(*)(void))NULL && PyErr_Occurred()) + return NULL; + + x5 = _cffi_to_c_int(arg5, int); + if (x5 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ENGINE_ctrl_cmd(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ENGINE_ctrl_cmd _cffi_d_ENGINE_ctrl_cmd +#endif + +static int _cffi_d_ENGINE_ctrl_cmd_string(ENGINE * x0, char const * x1, char const * x2, int x3) +{ + return ENGINE_ctrl_cmd_string(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_ctrl_cmd_string(PyObject *self, PyObject *args) +{ + ENGINE * x0; + char const * x1; + char const * x2; + int x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "ENGINE_ctrl_cmd_string", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(282), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (char const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(46), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ENGINE_ctrl_cmd_string(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ENGINE_ctrl_cmd_string _cffi_d_ENGINE_ctrl_cmd_string +#endif + +static int _cffi_d_ENGINE_finish(ENGINE * x0) +{ + return ENGINE_finish(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_finish(PyObject *self, PyObject *arg0) +{ + ENGINE * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(282), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ENGINE_finish(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ENGINE_finish _cffi_d_ENGINE_finish +#endif + +static int _cffi_d_ENGINE_free(ENGINE * x0) +{ + return ENGINE_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_free(PyObject *self, PyObject *arg0) +{ + ENGINE * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(282), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ENGINE_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ENGINE_free _cffi_d_ENGINE_free +#endif + +static ENGINE * _cffi_d_ENGINE_get_default_RAND(void) +{ + return ENGINE_get_default_RAND(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_get_default_RAND(PyObject *self, PyObject *noarg) +{ + ENGINE * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ENGINE_get_default_RAND(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(282)); +} +#else +# define _cffi_f_ENGINE_get_default_RAND _cffi_d_ENGINE_get_default_RAND +#endif + +static char const * _cffi_d_ENGINE_get_name(ENGINE const * x0) +{ + return ENGINE_get_name(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_get_name(PyObject *self, PyObject *arg0) +{ + ENGINE const * x0; + Py_ssize_t datasize; + char const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(723), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ENGINE const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(723), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ENGINE_get_name(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_ENGINE_get_name _cffi_d_ENGINE_get_name +#endif + +static int _cffi_d_ENGINE_init(ENGINE * x0) +{ + return ENGINE_init(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_init(PyObject *self, PyObject *arg0) +{ + ENGINE * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(282), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ENGINE_init(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ENGINE_init _cffi_d_ENGINE_init +#endif + +static void _cffi_d_ENGINE_load_builtin_engines(void) +{ + ENGINE_load_builtin_engines(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_load_builtin_engines(PyObject *self, PyObject *noarg) +{ + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ENGINE_load_builtin_engines(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ENGINE_load_builtin_engines _cffi_d_ENGINE_load_builtin_engines +#endif + +static EVP_PKEY * _cffi_d_ENGINE_load_private_key(ENGINE * x0, char const * x1, UI_METHOD * x2, void * x3) +{ + return ENGINE_load_private_key(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_load_private_key(PyObject *self, PyObject *args) +{ + ENGINE * x0; + char const * x1; + UI_METHOD * x2; + void * x3; + Py_ssize_t datasize; + EVP_PKEY * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "ENGINE_load_private_key", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(282), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(284), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (UI_METHOD *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(284), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ENGINE_load_private_key(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_ENGINE_load_private_key _cffi_d_ENGINE_load_private_key +#endif + +static EVP_PKEY * _cffi_d_ENGINE_load_public_key(ENGINE * x0, char const * x1, UI_METHOD * x2, void * x3) +{ + return ENGINE_load_public_key(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_load_public_key(PyObject *self, PyObject *args) +{ + ENGINE * x0; + char const * x1; + UI_METHOD * x2; + void * x3; + Py_ssize_t datasize; + EVP_PKEY * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "ENGINE_load_public_key", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(282), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(284), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (UI_METHOD *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(284), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ENGINE_load_public_key(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_ENGINE_load_public_key _cffi_d_ENGINE_load_public_key +#endif + +static int _cffi_d_ENGINE_set_default_RAND(ENGINE * x0) +{ + return ENGINE_set_default_RAND(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_set_default_RAND(PyObject *self, PyObject *arg0) +{ + ENGINE * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(282), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ENGINE_set_default_RAND(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ENGINE_set_default_RAND _cffi_d_ENGINE_set_default_RAND +#endif + +static void _cffi_d_ENGINE_unregister_RAND(ENGINE * x0) +{ + ENGINE_unregister_RAND(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ENGINE_unregister_RAND(PyObject *self, PyObject *arg0) +{ + ENGINE * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(282), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ENGINE_unregister_RAND(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ENGINE_unregister_RAND _cffi_d_ENGINE_unregister_RAND +#endif + +static int _cffi_d_ERR_GET_FUNC(unsigned long x0) +{ + return ERR_GET_FUNC(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_GET_FUNC(PyObject *self, PyObject *arg0) +{ + unsigned long x0; + int result; + + x0 = _cffi_to_c_int(arg0, unsigned long); + if (x0 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ERR_GET_FUNC(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ERR_GET_FUNC _cffi_d_ERR_GET_FUNC +#endif + +static int _cffi_d_ERR_GET_LIB(unsigned long x0) +{ + return ERR_GET_LIB(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_GET_LIB(PyObject *self, PyObject *arg0) +{ + unsigned long x0; + int result; + + x0 = _cffi_to_c_int(arg0, unsigned long); + if (x0 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ERR_GET_LIB(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ERR_GET_LIB _cffi_d_ERR_GET_LIB +#endif + +static int _cffi_d_ERR_GET_REASON(unsigned long x0) +{ + return ERR_GET_REASON(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_GET_REASON(PyObject *self, PyObject *arg0) +{ + unsigned long x0; + int result; + + x0 = _cffi_to_c_int(arg0, unsigned long); + if (x0 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ERR_GET_REASON(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_ERR_GET_REASON _cffi_d_ERR_GET_REASON +#endif + +static void _cffi_d_ERR_clear_error(void) +{ + ERR_clear_error(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_clear_error(PyObject *self, PyObject *noarg) +{ + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ERR_clear_error(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ERR_clear_error _cffi_d_ERR_clear_error +#endif + +static void _cffi_d_ERR_error_string_n(unsigned long x0, char * x1, size_t x2) +{ + ERR_error_string_n(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_error_string_n(PyObject *self, PyObject *args) +{ + unsigned long x0; + char * x1; + size_t x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "ERR_error_string_n", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + x0 = _cffi_to_c_int(arg0, unsigned long); + if (x0 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(409), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ERR_error_string_n(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ERR_error_string_n _cffi_d_ERR_error_string_n +#endif + +static char const * _cffi_d_ERR_func_error_string(unsigned long x0) +{ + return ERR_func_error_string(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_func_error_string(PyObject *self, PyObject *arg0) +{ + unsigned long x0; + char const * result; + + x0 = _cffi_to_c_int(arg0, unsigned long); + if (x0 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ERR_func_error_string(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_ERR_func_error_string _cffi_d_ERR_func_error_string +#endif + +static unsigned long _cffi_d_ERR_get_error(void) +{ + return ERR_get_error(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_get_error(PyObject *self, PyObject *noarg) +{ + unsigned long result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ERR_get_error(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_ERR_get_error _cffi_d_ERR_get_error +#endif + +static char const * _cffi_d_ERR_lib_error_string(unsigned long x0) +{ + return ERR_lib_error_string(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_lib_error_string(PyObject *self, PyObject *arg0) +{ + unsigned long x0; + char const * result; + + x0 = _cffi_to_c_int(arg0, unsigned long); + if (x0 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ERR_lib_error_string(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_ERR_lib_error_string _cffi_d_ERR_lib_error_string +#endif + +static void _cffi_d_ERR_load_RAND_strings(void) +{ + ERR_load_RAND_strings(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_load_RAND_strings(PyObject *self, PyObject *noarg) +{ + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ERR_load_RAND_strings(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ERR_load_RAND_strings _cffi_d_ERR_load_RAND_strings +#endif + +static unsigned long _cffi_d_ERR_peek_error(void) +{ + return ERR_peek_error(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_peek_error(PyObject *self, PyObject *noarg) +{ + unsigned long result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ERR_peek_error(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_ERR_peek_error _cffi_d_ERR_peek_error +#endif + +static void _cffi_d_ERR_put_error(int x0, int x1, int x2, char const * x3, int x4) +{ + ERR_put_error(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_put_error(PyObject *self, PyObject *args) +{ + int x0; + int x1; + int x2; + char const * x3; + int x4; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "ERR_put_error", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(46), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ERR_put_error(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ERR_put_error _cffi_d_ERR_put_error +#endif + +static char const * _cffi_d_ERR_reason_error_string(unsigned long x0) +{ + return ERR_reason_error_string(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ERR_reason_error_string(PyObject *self, PyObject *arg0) +{ + unsigned long x0; + char const * result; + + x0 = _cffi_to_c_int(arg0, unsigned long); + if (x0 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ERR_reason_error_string(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_ERR_reason_error_string _cffi_d_ERR_reason_error_string +#endif + +static EVP_CIPHER const * _cffi_d_EVP_CIPHER_CTX_cipher(EVP_CIPHER_CTX const * x0) +{ + return EVP_CIPHER_CTX_cipher(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_CIPHER_CTX_cipher(PyObject *self, PyObject *arg0) +{ + EVP_CIPHER_CTX const * x0; + Py_ssize_t datasize; + EVP_CIPHER const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(259), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_CIPHER_CTX const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(259), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_CIPHER_CTX_cipher(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(885)); +} +#else +# define _cffi_f_EVP_CIPHER_CTX_cipher _cffi_d_EVP_CIPHER_CTX_cipher +#endif + +static int _cffi_d_EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX * x0) +{ + return EVP_CIPHER_CTX_cleanup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_CIPHER_CTX_cleanup(PyObject *self, PyObject *arg0) +{ + EVP_CIPHER_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1318), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_CIPHER_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1318), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_CIPHER_CTX_cleanup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_CIPHER_CTX_cleanup _cffi_d_EVP_CIPHER_CTX_cleanup +#endif + +static int _cffi_d_EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX * x0, int x1, int x2, void * x3) +{ + return EVP_CIPHER_CTX_ctrl(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_CIPHER_CTX_ctrl(PyObject *self, PyObject *args) +{ + EVP_CIPHER_CTX * x0; + int x1; + int x2; + void * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "EVP_CIPHER_CTX_ctrl", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1318), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_CIPHER_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1318), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_CIPHER_CTX_ctrl(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_CIPHER_CTX_ctrl _cffi_d_EVP_CIPHER_CTX_ctrl +#endif + +static void _cffi_d_EVP_CIPHER_CTX_free(EVP_CIPHER_CTX * x0) +{ + EVP_CIPHER_CTX_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_CIPHER_CTX_free(PyObject *self, PyObject *arg0) +{ + EVP_CIPHER_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1318), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_CIPHER_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1318), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { EVP_CIPHER_CTX_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_EVP_CIPHER_CTX_free _cffi_d_EVP_CIPHER_CTX_free +#endif + +static EVP_CIPHER_CTX * _cffi_d_EVP_CIPHER_CTX_new(void) +{ + return EVP_CIPHER_CTX_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_CIPHER_CTX_new(PyObject *self, PyObject *noarg) +{ + EVP_CIPHER_CTX * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_CIPHER_CTX_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1318)); +} +#else +# define _cffi_f_EVP_CIPHER_CTX_new _cffi_d_EVP_CIPHER_CTX_new +#endif + +static int _cffi_d_EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX * x0, int x1) +{ + return EVP_CIPHER_CTX_set_key_length(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_CIPHER_CTX_set_key_length(PyObject *self, PyObject *args) +{ + EVP_CIPHER_CTX * x0; + int x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_CIPHER_CTX_set_key_length", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1318), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_CIPHER_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1318), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_CIPHER_CTX_set_key_length(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_CIPHER_CTX_set_key_length _cffi_d_EVP_CIPHER_CTX_set_key_length +#endif + +static int _cffi_d_EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX * x0, int x1) +{ + return EVP_CIPHER_CTX_set_padding(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_CIPHER_CTX_set_padding(PyObject *self, PyObject *args) +{ + EVP_CIPHER_CTX * x0; + int x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_CIPHER_CTX_set_padding", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1318), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_CIPHER_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1318), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_CIPHER_CTX_set_padding(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_CIPHER_CTX_set_padding _cffi_d_EVP_CIPHER_CTX_set_padding +#endif + +static int _cffi_d_EVP_CipherFinal_ex(EVP_CIPHER_CTX * x0, unsigned char * x1, int * x2) +{ + return EVP_CipherFinal_ex(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_CipherFinal_ex(PyObject *self, PyObject *args) +{ + EVP_CIPHER_CTX * x0; + unsigned char * x1; + int * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_CipherFinal_ex", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1318), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_CIPHER_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1318), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (int *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1169), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_CipherFinal_ex(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_CipherFinal_ex _cffi_d_EVP_CipherFinal_ex +#endif + +static int _cffi_d_EVP_CipherInit_ex(EVP_CIPHER_CTX * x0, EVP_CIPHER const * x1, ENGINE * x2, unsigned char const * x3, unsigned char const * x4, int x5) +{ + return EVP_CipherInit_ex(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_CipherInit_ex(PyObject *self, PyObject *args) +{ + EVP_CIPHER_CTX * x0; + EVP_CIPHER const * x1; + ENGINE * x2; + unsigned char const * x3; + unsigned char const * x4; + int x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "EVP_CipherInit_ex", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1318), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_CIPHER_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1318), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(885), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_CIPHER const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(885), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(282), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(103), arg4) < 0) + return NULL; + } + + x5 = _cffi_to_c_int(arg5, int); + if (x5 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_CipherInit_ex(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_CipherInit_ex _cffi_d_EVP_CipherInit_ex +#endif + +static int _cffi_d_EVP_CipherUpdate(EVP_CIPHER_CTX * x0, unsigned char * x1, int * x2, unsigned char const * x3, int x4) +{ + return EVP_CipherUpdate(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_CipherUpdate(PyObject *self, PyObject *args) +{ + EVP_CIPHER_CTX * x0; + unsigned char * x1; + int * x2; + unsigned char const * x3; + int x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EVP_CipherUpdate", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1318), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_CIPHER_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1318), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (int *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1169), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_CipherUpdate(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_CipherUpdate _cffi_d_EVP_CipherUpdate +#endif + +static int _cffi_d_EVP_DigestFinalXOF(EVP_MD_CTX * x0, unsigned char * x1, size_t x2) +{ + return EVP_DigestFinalXOF(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_DigestFinalXOF(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + unsigned char * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_DigestFinalXOF", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_DigestFinalXOF(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_DigestFinalXOF _cffi_d_EVP_DigestFinalXOF +#endif + +static int _cffi_d_EVP_DigestFinal_ex(EVP_MD_CTX * x0, unsigned char * x1, unsigned int * x2) +{ + return EVP_DigestFinal_ex(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_DigestFinal_ex(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + unsigned char * x1; + unsigned int * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_DigestFinal_ex", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1390), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned int *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1390), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_DigestFinal_ex(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_DigestFinal_ex _cffi_d_EVP_DigestFinal_ex +#endif + +static int _cffi_d_EVP_DigestInit_ex(EVP_MD_CTX * x0, EVP_MD const * x1, ENGINE * x2) +{ + return EVP_DigestInit_ex(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_DigestInit_ex(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + EVP_MD const * x1; + ENGINE * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_DigestInit_ex", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(354), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(282), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_DigestInit_ex(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_DigestInit_ex _cffi_d_EVP_DigestInit_ex +#endif + +static int _cffi_d_EVP_DigestSign(EVP_MD_CTX * x0, unsigned char * x1, size_t * x2, unsigned char const * x3, size_t x4) +{ + return EVP_DigestSign(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_DigestSign(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + unsigned char * x1; + size_t * x2; + unsigned char const * x3; + size_t x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EVP_DigestSign", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (size_t *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1037), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, size_t); + if (x4 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_DigestSign(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_DigestSign _cffi_d_EVP_DigestSign +#endif + +static int _cffi_d_EVP_DigestSignFinal(EVP_MD_CTX * x0, unsigned char * x1, size_t * x2) +{ + return EVP_DigestSignFinal(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_DigestSignFinal(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + unsigned char * x1; + size_t * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_DigestSignFinal", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (size_t *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1037), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_DigestSignFinal(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_DigestSignFinal _cffi_d_EVP_DigestSignFinal +#endif + +static int _cffi_d_EVP_DigestSignInit(EVP_MD_CTX * x0, EVP_PKEY_CTX * * x1, EVP_MD const * x2, ENGINE * x3, EVP_PKEY * x4) +{ + return EVP_DigestSignInit(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_DigestSignInit(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + EVP_PKEY_CTX * * x1; + EVP_MD const * x2; + ENGINE * x3; + EVP_PKEY * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EVP_DigestSignInit", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1365), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY_CTX * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1365), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(354), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(282), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(199), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_DigestSignInit(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_DigestSignInit _cffi_d_EVP_DigestSignInit +#endif + +static int _cffi_d_EVP_DigestSignUpdate(EVP_MD_CTX * x0, void const * x1, size_t x2) +{ + return EVP_DigestSignUpdate(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_DigestSignUpdate(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + void const * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_DigestSignUpdate", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(126), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_DigestSignUpdate(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_DigestSignUpdate _cffi_d_EVP_DigestSignUpdate +#endif + +static int _cffi_d_EVP_DigestUpdate(EVP_MD_CTX * x0, void const * x1, size_t x2) +{ + return EVP_DigestUpdate(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_DigestUpdate(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + void const * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_DigestUpdate", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(126), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_DigestUpdate(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_DigestUpdate _cffi_d_EVP_DigestUpdate +#endif + +static int _cffi_d_EVP_DigestVerify(EVP_MD_CTX * x0, unsigned char const * x1, size_t x2, unsigned char const * x3, size_t x4) +{ + return EVP_DigestVerify(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_DigestVerify(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + unsigned char const * x1; + size_t x2; + unsigned char const * x3; + size_t x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EVP_DigestVerify", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, size_t); + if (x4 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_DigestVerify(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_DigestVerify _cffi_d_EVP_DigestVerify +#endif + +static int _cffi_d_EVP_DigestVerifyInit(EVP_MD_CTX * x0, EVP_PKEY_CTX * * x1, EVP_MD const * x2, ENGINE * x3, EVP_PKEY * x4) +{ + return EVP_DigestVerifyInit(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_DigestVerifyInit(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + EVP_PKEY_CTX * * x1; + EVP_MD const * x2; + ENGINE * x3; + EVP_PKEY * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EVP_DigestVerifyInit", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1365), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY_CTX * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1365), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(354), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(282), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(199), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_DigestVerifyInit(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_DigestVerifyInit _cffi_d_EVP_DigestVerifyInit +#endif + +static int _cffi_d_EVP_MD_CTX_copy_ex(EVP_MD_CTX * x0, EVP_MD_CTX const * x1) +{ + return EVP_MD_CTX_copy_ex(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_MD_CTX_copy_ex(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + EVP_MD_CTX const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_MD_CTX_copy_ex", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1361), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_MD_CTX const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1361), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_MD_CTX_copy_ex(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_MD_CTX_copy_ex _cffi_d_EVP_MD_CTX_copy_ex +#endif + +static void _cffi_d_EVP_MD_CTX_free(EVP_MD_CTX * x0) +{ + EVP_MD_CTX_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_MD_CTX_free(PyObject *self, PyObject *arg0) +{ + EVP_MD_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { EVP_MD_CTX_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_EVP_MD_CTX_free _cffi_d_EVP_MD_CTX_free +#endif + +static EVP_MD_CTX * _cffi_d_EVP_MD_CTX_new(void) +{ + return EVP_MD_CTX_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_MD_CTX_new(PyObject *self, PyObject *noarg) +{ + EVP_MD_CTX * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_MD_CTX_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1351)); +} +#else +# define _cffi_f_EVP_MD_CTX_new _cffi_d_EVP_MD_CTX_new +#endif + +static int _cffi_d_EVP_PBE_scrypt(char const * x0, size_t x1, unsigned char const * x2, size_t x3, uint64_t x4, uint64_t x5, uint64_t x6, uint64_t x7, unsigned char * x8, size_t x9) +{ + return EVP_PBE_scrypt(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PBE_scrypt(PyObject *self, PyObject *args) +{ + char const * x0; + size_t x1; + unsigned char const * x2; + size_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + unsigned char * x8; + size_t x9; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + PyObject *arg7; + PyObject *arg8; + PyObject *arg9; + + if (!PyArg_UnpackTuple(args, "EVP_PBE_scrypt", 10, 10, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6, &arg7, &arg8, &arg9)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, size_t); + if (x1 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(103), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, size_t); + if (x3 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + x4 = _cffi_to_c_int(arg4, uint64_t); + if (x4 == (uint64_t)-1 && PyErr_Occurred()) + return NULL; + + x5 = _cffi_to_c_int(arg5, uint64_t); + if (x5 == (uint64_t)-1 && PyErr_Occurred()) + return NULL; + + x6 = _cffi_to_c_int(arg6, uint64_t); + if (x6 == (uint64_t)-1 && PyErr_Occurred()) + return NULL; + + x7 = _cffi_to_c_int(arg7, uint64_t); + if (x7 == (uint64_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg8, (char **)&x8); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x8 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x8, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x8, _cffi_type(752), arg8) < 0) + return NULL; + } + + x9 = _cffi_to_c_int(arg9, size_t); + if (x9 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PBE_scrypt(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PBE_scrypt _cffi_d_EVP_PBE_scrypt +#endif + +static EVP_PKEY_CTX * _cffi_d_EVP_PKEY_CTX_dup(EVP_PKEY_CTX * x0) +{ + return EVP_PKEY_CTX_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_CTX_dup(PyObject *self, PyObject *arg0) +{ + EVP_PKEY_CTX * x0; + Py_ssize_t datasize; + EVP_PKEY_CTX * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_CTX_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(309)); +} +#else +# define _cffi_f_EVP_PKEY_CTX_dup _cffi_d_EVP_PKEY_CTX_dup +#endif + +static void _cffi_d_EVP_PKEY_CTX_free(EVP_PKEY_CTX * x0) +{ + EVP_PKEY_CTX_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_CTX_free(PyObject *self, PyObject *arg0) +{ + EVP_PKEY_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { EVP_PKEY_CTX_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_EVP_PKEY_CTX_free _cffi_d_EVP_PKEY_CTX_free +#endif + +static EVP_PKEY_CTX * _cffi_d_EVP_PKEY_CTX_new(EVP_PKEY * x0, ENGINE * x1) +{ + return EVP_PKEY_CTX_new(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_CTX_new(PyObject *self, PyObject *args) +{ + EVP_PKEY * x0; + ENGINE * x1; + Py_ssize_t datasize; + EVP_PKEY_CTX * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_CTX_new", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(282), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_CTX_new(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(309)); +} +#else +# define _cffi_f_EVP_PKEY_CTX_new _cffi_d_EVP_PKEY_CTX_new +#endif + +static EVP_PKEY_CTX * _cffi_d_EVP_PKEY_CTX_new_id(int x0, ENGINE * x1) +{ + return EVP_PKEY_CTX_new_id(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_CTX_new_id(PyObject *self, PyObject *args) +{ + int x0; + ENGINE * x1; + Py_ssize_t datasize; + EVP_PKEY_CTX * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_CTX_new_id", 2, 2, &arg0, &arg1)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(282), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_CTX_new_id(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(309)); +} +#else +# define _cffi_f_EVP_PKEY_CTX_new_id _cffi_d_EVP_PKEY_CTX_new_id +#endif + +static int _cffi_d_EVP_PKEY_CTX_set0_rsa_oaep_label(EVP_PKEY_CTX * x0, unsigned char * x1, int x2) +{ + return EVP_PKEY_CTX_set0_rsa_oaep_label(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_CTX_set0_rsa_oaep_label(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + unsigned char * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_CTX_set0_rsa_oaep_label", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_CTX_set0_rsa_oaep_label(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_CTX_set0_rsa_oaep_label _cffi_d_EVP_PKEY_CTX_set0_rsa_oaep_label +#endif + +static int _cffi_d_EVP_PKEY_CTX_set_rsa_mgf1_md(EVP_PKEY_CTX * x0, EVP_MD * x1) +{ + return EVP_PKEY_CTX_set_rsa_mgf1_md(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_CTX_set_rsa_mgf1_md(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + EVP_MD * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_CTX_set_rsa_mgf1_md", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1461), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_MD *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1461), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_CTX_set_rsa_mgf1_md(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_CTX_set_rsa_mgf1_md _cffi_d_EVP_PKEY_CTX_set_rsa_mgf1_md +#endif + +static int _cffi_d_EVP_PKEY_CTX_set_rsa_oaep_md(EVP_PKEY_CTX * x0, EVP_MD * x1) +{ + return EVP_PKEY_CTX_set_rsa_oaep_md(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_CTX_set_rsa_oaep_md(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + EVP_MD * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_CTX_set_rsa_oaep_md", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1461), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_MD *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1461), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_CTX_set_rsa_oaep_md(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_CTX_set_rsa_oaep_md _cffi_d_EVP_PKEY_CTX_set_rsa_oaep_md +#endif + +static int _cffi_d_EVP_PKEY_CTX_set_rsa_padding(EVP_PKEY_CTX * x0, int x1) +{ + return EVP_PKEY_CTX_set_rsa_padding(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_CTX_set_rsa_padding(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + int x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_CTX_set_rsa_padding", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_CTX_set_rsa_padding(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_CTX_set_rsa_padding _cffi_d_EVP_PKEY_CTX_set_rsa_padding +#endif + +static int _cffi_d_EVP_PKEY_CTX_set_rsa_pss_saltlen(EVP_PKEY_CTX * x0, int x1) +{ + return EVP_PKEY_CTX_set_rsa_pss_saltlen(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_CTX_set_rsa_pss_saltlen(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + int x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_CTX_set_rsa_pss_saltlen", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_CTX_set_rsa_pss_saltlen(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_CTX_set_rsa_pss_saltlen _cffi_d_EVP_PKEY_CTX_set_rsa_pss_saltlen +#endif + +static int _cffi_d_EVP_PKEY_CTX_set_signature_md(EVP_PKEY_CTX * x0, EVP_MD const * x1) +{ + return EVP_PKEY_CTX_set_signature_md(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_CTX_set_signature_md(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + EVP_MD const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_CTX_set_signature_md", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(354), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_CTX_set_signature_md(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_CTX_set_signature_md _cffi_d_EVP_PKEY_CTX_set_signature_md +#endif + +static int _cffi_d_EVP_PKEY_assign_RSA(EVP_PKEY * x0, RSA * x1) +{ + return EVP_PKEY_assign_RSA(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_assign_RSA(PyObject *self, PyObject *args) +{ + EVP_PKEY * x0; + RSA * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_assign_RSA", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (RSA *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(476), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_assign_RSA(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_assign_RSA _cffi_d_EVP_PKEY_assign_RSA +#endif + +static int _cffi_d_EVP_PKEY_bits(EVP_PKEY * x0) +{ + return EVP_PKEY_bits(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_bits(PyObject *self, PyObject *arg0) +{ + EVP_PKEY * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_bits(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_bits _cffi_d_EVP_PKEY_bits +#endif + +static int _cffi_d_EVP_PKEY_cmp(EVP_PKEY const * x0, EVP_PKEY const * x1) +{ + return EVP_PKEY_cmp(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_cmp(PyObject *self, PyObject *args) +{ + EVP_PKEY const * x0; + EVP_PKEY const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_cmp", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1445), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1445), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1445), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1445), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_cmp(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_cmp _cffi_d_EVP_PKEY_cmp +#endif + +static int _cffi_d_EVP_PKEY_decrypt(EVP_PKEY_CTX * x0, unsigned char * x1, size_t * x2, unsigned char const * x3, size_t x4) +{ + return EVP_PKEY_decrypt(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_decrypt(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + unsigned char * x1; + size_t * x2; + unsigned char const * x3; + size_t x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_decrypt", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (size_t *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1037), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, size_t); + if (x4 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_decrypt(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_decrypt _cffi_d_EVP_PKEY_decrypt +#endif + +static int _cffi_d_EVP_PKEY_decrypt_init(EVP_PKEY_CTX * x0) +{ + return EVP_PKEY_decrypt_init(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_decrypt_init(PyObject *self, PyObject *arg0) +{ + EVP_PKEY_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_decrypt_init(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_decrypt_init _cffi_d_EVP_PKEY_decrypt_init +#endif + +static int _cffi_d_EVP_PKEY_derive(EVP_PKEY_CTX * x0, unsigned char * x1, size_t * x2) +{ + return EVP_PKEY_derive(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_derive(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + unsigned char * x1; + size_t * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_derive", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (size_t *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1037), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_derive(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_derive _cffi_d_EVP_PKEY_derive +#endif + +static int _cffi_d_EVP_PKEY_derive_init(EVP_PKEY_CTX * x0) +{ + return EVP_PKEY_derive_init(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_derive_init(PyObject *self, PyObject *arg0) +{ + EVP_PKEY_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_derive_init(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_derive_init _cffi_d_EVP_PKEY_derive_init +#endif + +static int _cffi_d_EVP_PKEY_derive_set_peer(EVP_PKEY_CTX * x0, EVP_PKEY * x1) +{ + return EVP_PKEY_derive_set_peer(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_derive_set_peer(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + EVP_PKEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_derive_set_peer", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_derive_set_peer(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_derive_set_peer _cffi_d_EVP_PKEY_derive_set_peer +#endif + +static int _cffi_d_EVP_PKEY_encrypt(EVP_PKEY_CTX * x0, unsigned char * x1, size_t * x2, unsigned char const * x3, size_t x4) +{ + return EVP_PKEY_encrypt(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_encrypt(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + unsigned char * x1; + size_t * x2; + unsigned char const * x3; + size_t x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_encrypt", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (size_t *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1037), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, size_t); + if (x4 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_encrypt(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_encrypt _cffi_d_EVP_PKEY_encrypt +#endif + +static int _cffi_d_EVP_PKEY_encrypt_init(EVP_PKEY_CTX * x0) +{ + return EVP_PKEY_encrypt_init(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_encrypt_init(PyObject *self, PyObject *arg0) +{ + EVP_PKEY_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_encrypt_init(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_encrypt_init _cffi_d_EVP_PKEY_encrypt_init +#endif + +static void _cffi_d_EVP_PKEY_free(EVP_PKEY * x0) +{ + EVP_PKEY_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_free(PyObject *self, PyObject *arg0) +{ + EVP_PKEY * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { EVP_PKEY_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_EVP_PKEY_free _cffi_d_EVP_PKEY_free +#endif + +static DH * _cffi_d_EVP_PKEY_get1_DH(EVP_PKEY * x0) +{ + return EVP_PKEY_get1_DH(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_get1_DH(PyObject *self, PyObject *arg0) +{ + EVP_PKEY * x0; + Py_ssize_t datasize; + DH * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_get1_DH(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(196)); +} +#else +# define _cffi_f_EVP_PKEY_get1_DH _cffi_d_EVP_PKEY_get1_DH +#endif + +static DSA * _cffi_d_EVP_PKEY_get1_DSA(EVP_PKEY * x0) +{ + return EVP_PKEY_get1_DSA(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_get1_DSA(PyObject *self, PyObject *arg0) +{ + EVP_PKEY * x0; + Py_ssize_t datasize; + DSA * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_get1_DSA(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(212)); +} +#else +# define _cffi_f_EVP_PKEY_get1_DSA _cffi_d_EVP_PKEY_get1_DSA +#endif + +static EC_KEY * _cffi_d_EVP_PKEY_get1_EC_KEY(EVP_PKEY * x0) +{ + return EVP_PKEY_get1_EC_KEY(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_get1_EC_KEY(PyObject *self, PyObject *arg0) +{ + EVP_PKEY * x0; + Py_ssize_t datasize; + EC_KEY * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_get1_EC_KEY(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(893)); +} +#else +# define _cffi_f_EVP_PKEY_get1_EC_KEY _cffi_d_EVP_PKEY_get1_EC_KEY +#endif + +static RSA * _cffi_d_EVP_PKEY_get1_RSA(EVP_PKEY * x0) +{ + return EVP_PKEY_get1_RSA(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_get1_RSA(PyObject *self, PyObject *arg0) +{ + EVP_PKEY * x0; + Py_ssize_t datasize; + RSA * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_get1_RSA(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(476)); +} +#else +# define _cffi_f_EVP_PKEY_get1_RSA _cffi_d_EVP_PKEY_get1_RSA +#endif + +static size_t _cffi_d_EVP_PKEY_get1_tls_encodedpoint(EVP_PKEY * x0, unsigned char * * x1) +{ + return EVP_PKEY_get1_tls_encodedpoint(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_get1_tls_encodedpoint(PyObject *self, PyObject *args) +{ + EVP_PKEY * x0; + unsigned char * * x1; + Py_ssize_t datasize; + size_t result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_get1_tls_encodedpoint", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(802), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_get1_tls_encodedpoint(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, size_t); +} +#else +# define _cffi_f_EVP_PKEY_get1_tls_encodedpoint _cffi_d_EVP_PKEY_get1_tls_encodedpoint +#endif + +static int _cffi_d_EVP_PKEY_get_raw_private_key(EVP_PKEY const * x0, unsigned char * x1, size_t * x2) +{ + return EVP_PKEY_get_raw_private_key(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_get_raw_private_key(PyObject *self, PyObject *args) +{ + EVP_PKEY const * x0; + unsigned char * x1; + size_t * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_get_raw_private_key", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1445), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1445), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (size_t *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1037), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_get_raw_private_key(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_get_raw_private_key _cffi_d_EVP_PKEY_get_raw_private_key +#endif + +static int _cffi_d_EVP_PKEY_get_raw_public_key(EVP_PKEY const * x0, unsigned char * x1, size_t * x2) +{ + return EVP_PKEY_get_raw_public_key(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_get_raw_public_key(PyObject *self, PyObject *args) +{ + EVP_PKEY const * x0; + unsigned char * x1; + size_t * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_get_raw_public_key", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1445), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1445), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (size_t *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1037), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_get_raw_public_key(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_get_raw_public_key _cffi_d_EVP_PKEY_get_raw_public_key +#endif + +static int _cffi_d_EVP_PKEY_id(EVP_PKEY const * x0) +{ + return EVP_PKEY_id(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_id(PyObject *self, PyObject *arg0) +{ + EVP_PKEY const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1445), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1445), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_id(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_id _cffi_d_EVP_PKEY_id +#endif + +static int _cffi_d_EVP_PKEY_keygen(EVP_PKEY_CTX * x0, EVP_PKEY * * x1) +{ + return EVP_PKEY_keygen(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_keygen(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + EVP_PKEY * * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_keygen", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(273), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(273), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_keygen(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_keygen _cffi_d_EVP_PKEY_keygen +#endif + +static int _cffi_d_EVP_PKEY_keygen_init(EVP_PKEY_CTX * x0) +{ + return EVP_PKEY_keygen_init(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_keygen_init(PyObject *self, PyObject *arg0) +{ + EVP_PKEY_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_keygen_init(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_keygen_init _cffi_d_EVP_PKEY_keygen_init +#endif + +static EVP_PKEY * _cffi_d_EVP_PKEY_new(void) +{ + return EVP_PKEY_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_new(PyObject *self, PyObject *noarg) +{ + EVP_PKEY * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_EVP_PKEY_new _cffi_d_EVP_PKEY_new +#endif + +static EVP_PKEY * _cffi_d_EVP_PKEY_new_raw_private_key(int x0, ENGINE * x1, unsigned char const * x2, size_t x3) +{ + return EVP_PKEY_new_raw_private_key(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_new_raw_private_key(PyObject *self, PyObject *args) +{ + int x0; + ENGINE * x1; + unsigned char const * x2; + size_t x3; + Py_ssize_t datasize; + EVP_PKEY * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_new_raw_private_key", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(282), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(103), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, size_t); + if (x3 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_new_raw_private_key(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_EVP_PKEY_new_raw_private_key _cffi_d_EVP_PKEY_new_raw_private_key +#endif + +static EVP_PKEY * _cffi_d_EVP_PKEY_new_raw_public_key(int x0, ENGINE * x1, unsigned char const * x2, size_t x3) +{ + return EVP_PKEY_new_raw_public_key(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_new_raw_public_key(PyObject *self, PyObject *args) +{ + int x0; + ENGINE * x1; + unsigned char const * x2; + size_t x3; + Py_ssize_t datasize; + EVP_PKEY * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_new_raw_public_key", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(282), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(103), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, size_t); + if (x3 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_new_raw_public_key(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_EVP_PKEY_new_raw_public_key _cffi_d_EVP_PKEY_new_raw_public_key +#endif + +static int _cffi_d_EVP_PKEY_set1_DH(EVP_PKEY * x0, DH * x1) +{ + return EVP_PKEY_set1_DH(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_set1_DH(PyObject *self, PyObject *args) +{ + EVP_PKEY * x0; + DH * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_set1_DH", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DH *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(196), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_set1_DH(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_set1_DH _cffi_d_EVP_PKEY_set1_DH +#endif + +static int _cffi_d_EVP_PKEY_set1_DSA(EVP_PKEY * x0, DSA * x1) +{ + return EVP_PKEY_set1_DSA(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_set1_DSA(PyObject *self, PyObject *args) +{ + EVP_PKEY * x0; + DSA * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_set1_DSA", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(212), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DSA *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(212), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_set1_DSA(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_set1_DSA _cffi_d_EVP_PKEY_set1_DSA +#endif + +static int _cffi_d_EVP_PKEY_set1_EC_KEY(EVP_PKEY * x0, EC_KEY * x1) +{ + return EVP_PKEY_set1_EC_KEY(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_set1_EC_KEY(PyObject *self, PyObject *args) +{ + EVP_PKEY * x0; + EC_KEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_set1_EC_KEY", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(893), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_set1_EC_KEY(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_set1_EC_KEY _cffi_d_EVP_PKEY_set1_EC_KEY +#endif + +static int _cffi_d_EVP_PKEY_set1_RSA(EVP_PKEY * x0, RSA * x1) +{ + return EVP_PKEY_set1_RSA(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_set1_RSA(PyObject *self, PyObject *args) +{ + EVP_PKEY * x0; + RSA * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_set1_RSA", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (RSA *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(476), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_set1_RSA(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_set1_RSA _cffi_d_EVP_PKEY_set1_RSA +#endif + +static int _cffi_d_EVP_PKEY_set1_tls_encodedpoint(EVP_PKEY * x0, unsigned char const * x1, size_t x2) +{ + return EVP_PKEY_set1_tls_encodedpoint(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_set1_tls_encodedpoint(PyObject *self, PyObject *args) +{ + EVP_PKEY * x0; + unsigned char const * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_set1_tls_encodedpoint", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_set1_tls_encodedpoint(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_set1_tls_encodedpoint _cffi_d_EVP_PKEY_set1_tls_encodedpoint +#endif + +static int _cffi_d_EVP_PKEY_set_type(EVP_PKEY * x0, int x1) +{ + return EVP_PKEY_set_type(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_set_type(PyObject *self, PyObject *args) +{ + EVP_PKEY * x0; + int x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_set_type", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_set_type(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_set_type _cffi_d_EVP_PKEY_set_type +#endif + +static int _cffi_d_EVP_PKEY_sign(EVP_PKEY_CTX * x0, unsigned char * x1, size_t * x2, unsigned char const * x3, size_t x4) +{ + return EVP_PKEY_sign(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_sign(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + unsigned char * x1; + size_t * x2; + unsigned char const * x3; + size_t x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_sign", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (size_t *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1037), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, size_t); + if (x4 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_sign(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_sign _cffi_d_EVP_PKEY_sign +#endif + +static int _cffi_d_EVP_PKEY_sign_init(EVP_PKEY_CTX * x0) +{ + return EVP_PKEY_sign_init(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_sign_init(PyObject *self, PyObject *arg0) +{ + EVP_PKEY_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_sign_init(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_sign_init _cffi_d_EVP_PKEY_sign_init +#endif + +static int _cffi_d_EVP_PKEY_size(EVP_PKEY * x0) +{ + return EVP_PKEY_size(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_size(PyObject *self, PyObject *arg0) +{ + EVP_PKEY * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(199), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_size(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_size _cffi_d_EVP_PKEY_size +#endif + +static int _cffi_d_EVP_PKEY_type(int x0) +{ + return EVP_PKEY_type(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_type(PyObject *self, PyObject *arg0) +{ + int x0; + int result; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_type(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_type _cffi_d_EVP_PKEY_type +#endif + +static int _cffi_d_EVP_PKEY_verify(EVP_PKEY_CTX * x0, unsigned char const * x1, size_t x2, unsigned char const * x3, size_t x4) +{ + return EVP_PKEY_verify(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_verify(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + unsigned char const * x1; + size_t x2; + unsigned char const * x3; + size_t x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_verify", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, size_t); + if (x4 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_verify(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_verify _cffi_d_EVP_PKEY_verify +#endif + +static int _cffi_d_EVP_PKEY_verify_init(EVP_PKEY_CTX * x0) +{ + return EVP_PKEY_verify_init(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_verify_init(PyObject *self, PyObject *arg0) +{ + EVP_PKEY_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_verify_init(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_verify_init _cffi_d_EVP_PKEY_verify_init +#endif + +static int _cffi_d_EVP_PKEY_verify_recover(EVP_PKEY_CTX * x0, unsigned char * x1, size_t * x2, unsigned char const * x3, size_t x4) +{ + return EVP_PKEY_verify_recover(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_verify_recover(PyObject *self, PyObject *args) +{ + EVP_PKEY_CTX * x0; + unsigned char * x1; + size_t * x2; + unsigned char const * x3; + size_t x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "EVP_PKEY_verify_recover", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (size_t *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1037), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, size_t); + if (x4 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_verify_recover(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_verify_recover _cffi_d_EVP_PKEY_verify_recover +#endif + +static int _cffi_d_EVP_PKEY_verify_recover_init(EVP_PKEY_CTX * x0) +{ + return EVP_PKEY_verify_recover_init(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_PKEY_verify_recover_init(PyObject *self, PyObject *arg0) +{ + EVP_PKEY_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(309), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_PKEY_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(309), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_PKEY_verify_recover_init(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_PKEY_verify_recover_init _cffi_d_EVP_PKEY_verify_recover_init +#endif + +static int _cffi_d_EVP_SignFinal(EVP_MD_CTX * x0, unsigned char * x1, unsigned int * x2, EVP_PKEY * x3) +{ + return EVP_SignFinal(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_SignFinal(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + unsigned char * x1; + unsigned int * x2; + EVP_PKEY * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "EVP_SignFinal", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1390), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned int *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1390), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(199), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_SignFinal(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_SignFinal _cffi_d_EVP_SignFinal +#endif + +static int _cffi_d_EVP_SignInit(EVP_MD_CTX * x0, EVP_MD const * x1) +{ + return EVP_SignInit(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_SignInit(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + EVP_MD const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_SignInit", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(354), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_SignInit(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_SignInit _cffi_d_EVP_SignInit +#endif + +static int _cffi_d_EVP_SignUpdate(EVP_MD_CTX * x0, void const * x1, size_t x2) +{ + return EVP_SignUpdate(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_SignUpdate(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + void const * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_SignUpdate", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(126), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_SignUpdate(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_SignUpdate _cffi_d_EVP_SignUpdate +#endif + +static int _cffi_d_EVP_VerifyFinal(EVP_MD_CTX * x0, unsigned char const * x1, unsigned int x2, EVP_PKEY * x3) +{ + return EVP_VerifyFinal(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_VerifyFinal(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + unsigned char const * x1; + unsigned int x2; + EVP_PKEY * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "EVP_VerifyFinal", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, unsigned int); + if (x2 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(199), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_VerifyFinal(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_VerifyFinal _cffi_d_EVP_VerifyFinal +#endif + +static int _cffi_d_EVP_VerifyInit(EVP_MD_CTX * x0, EVP_MD const * x1) +{ + return EVP_VerifyInit(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_VerifyInit(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + EVP_MD const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "EVP_VerifyInit", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(354), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_VerifyInit(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_VerifyInit _cffi_d_EVP_VerifyInit +#endif + +static int _cffi_d_EVP_VerifyUpdate(EVP_MD_CTX * x0, void const * x1, size_t x2) +{ + return EVP_VerifyUpdate(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_VerifyUpdate(PyObject *self, PyObject *args) +{ + EVP_MD_CTX * x0; + void const * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "EVP_VerifyUpdate", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1351), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1351), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(126), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_VerifyUpdate(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_EVP_VerifyUpdate _cffi_d_EVP_VerifyUpdate +#endif + +static EVP_CIPHER const * _cffi_d_EVP_get_cipherbyname(char const * x0) +{ + return EVP_get_cipherbyname(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_get_cipherbyname(PyObject *self, PyObject *arg0) +{ + char const * x0; + Py_ssize_t datasize; + EVP_CIPHER const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_get_cipherbyname(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(885)); +} +#else +# define _cffi_f_EVP_get_cipherbyname _cffi_d_EVP_get_cipherbyname +#endif + +static EVP_MD const * _cffi_d_EVP_get_digestbyname(char const * x0) +{ + return EVP_get_digestbyname(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_EVP_get_digestbyname(PyObject *self, PyObject *arg0) +{ + char const * x0; + Py_ssize_t datasize; + EVP_MD const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = EVP_get_digestbyname(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(354)); +} +#else +# define _cffi_f_EVP_get_digestbyname _cffi_d_EVP_get_digestbyname +#endif + +static int _cffi_d_FIPS_mode(void) +{ + return FIPS_mode(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_FIPS_mode(PyObject *self, PyObject *noarg) +{ + int result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = FIPS_mode(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_FIPS_mode _cffi_d_FIPS_mode +#endif + +static int _cffi_d_FIPS_mode_set(int x0) +{ + return FIPS_mode_set(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_FIPS_mode_set(PyObject *self, PyObject *arg0) +{ + int x0; + int result; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = FIPS_mode_set(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_FIPS_mode_set _cffi_d_FIPS_mode_set +#endif + +static void _cffi_d_GENERAL_NAMES_free(GENERAL_NAMES * x0) +{ + GENERAL_NAMES_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_GENERAL_NAMES_free(PyObject *self, PyObject *arg0) +{ + GENERAL_NAMES * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(316), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (GENERAL_NAMES *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(316), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { GENERAL_NAMES_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_GENERAL_NAMES_free _cffi_d_GENERAL_NAMES_free +#endif + +static GENERAL_NAMES * _cffi_d_GENERAL_NAMES_new(void) +{ + return GENERAL_NAMES_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_GENERAL_NAMES_new(PyObject *self, PyObject *noarg) +{ + GENERAL_NAMES * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = GENERAL_NAMES_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(316)); +} +#else +# define _cffi_f_GENERAL_NAMES_new _cffi_d_GENERAL_NAMES_new +#endif + +static void _cffi_d_GENERAL_NAME_free(GENERAL_NAME * x0) +{ + GENERAL_NAME_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_GENERAL_NAME_free(PyObject *self, PyObject *arg0) +{ + GENERAL_NAME * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(928), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (GENERAL_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(928), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { GENERAL_NAME_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_GENERAL_NAME_free _cffi_d_GENERAL_NAME_free +#endif + +static GENERAL_NAME * _cffi_d_GENERAL_NAME_new(void) +{ + return GENERAL_NAME_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_GENERAL_NAME_new(PyObject *self, PyObject *noarg) +{ + GENERAL_NAME * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = GENERAL_NAME_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(928)); +} +#else +# define _cffi_f_GENERAL_NAME_new _cffi_d_GENERAL_NAME_new +#endif + +static int _cffi_d_GENERAL_NAME_print(BIO * x0, GENERAL_NAME * x1) +{ + return GENERAL_NAME_print(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_GENERAL_NAME_print(PyObject *self, PyObject *args) +{ + BIO * x0; + GENERAL_NAME * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "GENERAL_NAME_print", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(928), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (GENERAL_NAME *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(928), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = GENERAL_NAME_print(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_GENERAL_NAME_print _cffi_d_GENERAL_NAME_print +#endif + +static GENERAL_SUBTREE * _cffi_d_GENERAL_SUBTREE_new(void) +{ + return GENERAL_SUBTREE_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_GENERAL_SUBTREE_new(PyObject *self, PyObject *noarg) +{ + GENERAL_SUBTREE * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = GENERAL_SUBTREE_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1084)); +} +#else +# define _cffi_f_GENERAL_SUBTREE_new _cffi_d_GENERAL_SUBTREE_new +#endif + +static int _cffi_d_HMAC_CTX_copy(HMAC_CTX * x0, HMAC_CTX * x1) +{ + return HMAC_CTX_copy(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_HMAC_CTX_copy(PyObject *self, PyObject *args) +{ + HMAC_CTX * x0; + HMAC_CTX * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "HMAC_CTX_copy", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1515), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (HMAC_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1515), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1515), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (HMAC_CTX *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1515), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = HMAC_CTX_copy(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_HMAC_CTX_copy _cffi_d_HMAC_CTX_copy +#endif + +static void _cffi_d_HMAC_CTX_free(HMAC_CTX * x0) +{ + HMAC_CTX_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_HMAC_CTX_free(PyObject *self, PyObject *arg0) +{ + HMAC_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1515), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (HMAC_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1515), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { HMAC_CTX_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_HMAC_CTX_free _cffi_d_HMAC_CTX_free +#endif + +static HMAC_CTX * _cffi_d_HMAC_CTX_new(void) +{ + return HMAC_CTX_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_HMAC_CTX_new(PyObject *self, PyObject *noarg) +{ + HMAC_CTX * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = HMAC_CTX_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1515)); +} +#else +# define _cffi_f_HMAC_CTX_new _cffi_d_HMAC_CTX_new +#endif + +static int _cffi_d_HMAC_Final(HMAC_CTX * x0, unsigned char * x1, unsigned int * x2) +{ + return HMAC_Final(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_HMAC_Final(PyObject *self, PyObject *args) +{ + HMAC_CTX * x0; + unsigned char * x1; + unsigned int * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "HMAC_Final", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1515), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (HMAC_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1515), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1390), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned int *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1390), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = HMAC_Final(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_HMAC_Final _cffi_d_HMAC_Final +#endif + +static int _cffi_d_HMAC_Init_ex(HMAC_CTX * x0, void const * x1, int x2, EVP_MD const * x3, ENGINE * x4) +{ + return HMAC_Init_ex(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_HMAC_Init_ex(PyObject *self, PyObject *args) +{ + HMAC_CTX * x0; + void const * x1; + int x2; + EVP_MD const * x3; + ENGINE * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "HMAC_Init_ex", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1515), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (HMAC_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1515), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(126), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(354), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(282), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (ENGINE *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(282), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = HMAC_Init_ex(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_HMAC_Init_ex _cffi_d_HMAC_Init_ex +#endif + +static int _cffi_d_HMAC_Update(HMAC_CTX * x0, unsigned char const * x1, size_t x2) +{ + return HMAC_Update(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_HMAC_Update(PyObject *self, PyObject *args) +{ + HMAC_CTX * x0; + unsigned char const * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "HMAC_Update", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1515), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (HMAC_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1515), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = HMAC_Update(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_HMAC_Update _cffi_d_HMAC_Update +#endif + +static void _cffi_d_ISSUING_DIST_POINT_free(ISSUING_DIST_POINT * x0) +{ + ISSUING_DIST_POINT_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ISSUING_DIST_POINT_free(PyObject *self, PyObject *arg0) +{ + ISSUING_DIST_POINT * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2702), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ISSUING_DIST_POINT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2702), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { ISSUING_DIST_POINT_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_ISSUING_DIST_POINT_free _cffi_d_ISSUING_DIST_POINT_free +#endif + +static ISSUING_DIST_POINT * _cffi_d_ISSUING_DIST_POINT_new(void) +{ + return ISSUING_DIST_POINT_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_ISSUING_DIST_POINT_new(PyObject *self, PyObject *noarg) +{ + ISSUING_DIST_POINT * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = ISSUING_DIST_POINT_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2702)); +} +#else +# define _cffi_f_ISSUING_DIST_POINT_new _cffi_d_ISSUING_DIST_POINT_new +#endif + +static void _cffi_d_NAME_CONSTRAINTS_free(NAME_CONSTRAINTS * x0) +{ + NAME_CONSTRAINTS_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NAME_CONSTRAINTS_free(PyObject *self, PyObject *arg0) +{ + NAME_CONSTRAINTS * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2705), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (NAME_CONSTRAINTS *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2705), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { NAME_CONSTRAINTS_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_NAME_CONSTRAINTS_free _cffi_d_NAME_CONSTRAINTS_free +#endif + +static NAME_CONSTRAINTS * _cffi_d_NAME_CONSTRAINTS_new(void) +{ + return NAME_CONSTRAINTS_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NAME_CONSTRAINTS_new(PyObject *self, PyObject *noarg) +{ + NAME_CONSTRAINTS * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = NAME_CONSTRAINTS_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2705)); +} +#else +# define _cffi_f_NAME_CONSTRAINTS_new _cffi_d_NAME_CONSTRAINTS_new +#endif + +static NETSCAPE_SPKI * _cffi_d_NETSCAPE_SPKI_b64_decode(char const * x0, int x1) +{ + return NETSCAPE_SPKI_b64_decode(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NETSCAPE_SPKI_b64_decode(PyObject *self, PyObject *args) +{ + char const * x0; + int x1; + Py_ssize_t datasize; + NETSCAPE_SPKI * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "NETSCAPE_SPKI_b64_decode", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = NETSCAPE_SPKI_b64_decode(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(288)); +} +#else +# define _cffi_f_NETSCAPE_SPKI_b64_decode _cffi_d_NETSCAPE_SPKI_b64_decode +#endif + +static char * _cffi_d_NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI * x0) +{ + return NETSCAPE_SPKI_b64_encode(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NETSCAPE_SPKI_b64_encode(PyObject *self, PyObject *arg0) +{ + NETSCAPE_SPKI * x0; + Py_ssize_t datasize; + char * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(288), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (NETSCAPE_SPKI *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(288), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = NETSCAPE_SPKI_b64_encode(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(409)); +} +#else +# define _cffi_f_NETSCAPE_SPKI_b64_encode _cffi_d_NETSCAPE_SPKI_b64_encode +#endif + +static void _cffi_d_NETSCAPE_SPKI_free(NETSCAPE_SPKI * x0) +{ + NETSCAPE_SPKI_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NETSCAPE_SPKI_free(PyObject *self, PyObject *arg0) +{ + NETSCAPE_SPKI * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(288), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (NETSCAPE_SPKI *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(288), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { NETSCAPE_SPKI_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_NETSCAPE_SPKI_free _cffi_d_NETSCAPE_SPKI_free +#endif + +static EVP_PKEY * _cffi_d_NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI * x0) +{ + return NETSCAPE_SPKI_get_pubkey(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NETSCAPE_SPKI_get_pubkey(PyObject *self, PyObject *arg0) +{ + NETSCAPE_SPKI * x0; + Py_ssize_t datasize; + EVP_PKEY * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(288), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (NETSCAPE_SPKI *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(288), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = NETSCAPE_SPKI_get_pubkey(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_NETSCAPE_SPKI_get_pubkey _cffi_d_NETSCAPE_SPKI_get_pubkey +#endif + +static NETSCAPE_SPKI * _cffi_d_NETSCAPE_SPKI_new(void) +{ + return NETSCAPE_SPKI_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NETSCAPE_SPKI_new(PyObject *self, PyObject *noarg) +{ + NETSCAPE_SPKI * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = NETSCAPE_SPKI_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(288)); +} +#else +# define _cffi_f_NETSCAPE_SPKI_new _cffi_d_NETSCAPE_SPKI_new +#endif + +static int _cffi_d_NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI * x0, EVP_PKEY * x1) +{ + return NETSCAPE_SPKI_set_pubkey(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NETSCAPE_SPKI_set_pubkey(PyObject *self, PyObject *args) +{ + NETSCAPE_SPKI * x0; + EVP_PKEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "NETSCAPE_SPKI_set_pubkey", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(288), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (NETSCAPE_SPKI *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(288), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = NETSCAPE_SPKI_set_pubkey(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_NETSCAPE_SPKI_set_pubkey _cffi_d_NETSCAPE_SPKI_set_pubkey +#endif + +static int _cffi_d_NETSCAPE_SPKI_sign(NETSCAPE_SPKI * x0, EVP_PKEY * x1, EVP_MD const * x2) +{ + return NETSCAPE_SPKI_sign(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NETSCAPE_SPKI_sign(PyObject *self, PyObject *args) +{ + NETSCAPE_SPKI * x0; + EVP_PKEY * x1; + EVP_MD const * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "NETSCAPE_SPKI_sign", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(288), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (NETSCAPE_SPKI *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(288), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(354), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = NETSCAPE_SPKI_sign(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_NETSCAPE_SPKI_sign _cffi_d_NETSCAPE_SPKI_sign +#endif + +static int _cffi_d_NETSCAPE_SPKI_verify(NETSCAPE_SPKI * x0, EVP_PKEY * x1) +{ + return NETSCAPE_SPKI_verify(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NETSCAPE_SPKI_verify(PyObject *self, PyObject *args) +{ + NETSCAPE_SPKI * x0; + EVP_PKEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "NETSCAPE_SPKI_verify", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(288), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (NETSCAPE_SPKI *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(288), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = NETSCAPE_SPKI_verify(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_NETSCAPE_SPKI_verify _cffi_d_NETSCAPE_SPKI_verify +#endif + +static void _cffi_d_NOTICEREF_free(NOTICEREF * x0) +{ + NOTICEREF_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NOTICEREF_free(PyObject *self, PyObject *arg0) +{ + NOTICEREF * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2711), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (NOTICEREF *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2711), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { NOTICEREF_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_NOTICEREF_free _cffi_d_NOTICEREF_free +#endif + +static NOTICEREF * _cffi_d_NOTICEREF_new(void) +{ + return NOTICEREF_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_NOTICEREF_new(PyObject *self, PyObject *noarg) +{ + NOTICEREF * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = NOTICEREF_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2711)); +} +#else +# define _cffi_f_NOTICEREF_new _cffi_d_NOTICEREF_new +#endif + +static char const * _cffi_d_OBJ_nid2ln(int x0) +{ + return OBJ_nid2ln(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OBJ_nid2ln(PyObject *self, PyObject *arg0) +{ + int x0; + char const * result; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OBJ_nid2ln(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_OBJ_nid2ln _cffi_d_OBJ_nid2ln +#endif + +static char const * _cffi_d_OBJ_nid2sn(int x0) +{ + return OBJ_nid2sn(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OBJ_nid2sn(PyObject *self, PyObject *arg0) +{ + int x0; + char const * result; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OBJ_nid2sn(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_OBJ_nid2sn _cffi_d_OBJ_nid2sn +#endif + +static int _cffi_d_OBJ_obj2nid(ASN1_OBJECT const * x0) +{ + return OBJ_obj2nid(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OBJ_obj2nid(PyObject *self, PyObject *arg0) +{ + ASN1_OBJECT const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(765), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OBJECT const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(765), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OBJ_obj2nid(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OBJ_obj2nid _cffi_d_OBJ_obj2nid +#endif + +static int _cffi_d_OBJ_obj2txt(char * x0, int x1, ASN1_OBJECT const * x2, int x3) +{ + return OBJ_obj2txt(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OBJ_obj2txt(PyObject *self, PyObject *args) +{ + char * x0; + int x1; + ASN1_OBJECT const * x2; + int x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "OBJ_obj2txt", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(409), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(765), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (ASN1_OBJECT const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(765), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OBJ_obj2txt(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OBJ_obj2txt _cffi_d_OBJ_obj2txt +#endif + +static int _cffi_d_OBJ_sn2nid(char const * x0) +{ + return OBJ_sn2nid(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OBJ_sn2nid(PyObject *self, PyObject *arg0) +{ + char const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OBJ_sn2nid(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OBJ_sn2nid _cffi_d_OBJ_sn2nid +#endif + +static int _cffi_d_OBJ_txt2nid(char const * x0) +{ + return OBJ_txt2nid(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OBJ_txt2nid(PyObject *self, PyObject *arg0) +{ + char const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OBJ_txt2nid(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OBJ_txt2nid _cffi_d_OBJ_txt2nid +#endif + +static ASN1_OBJECT * _cffi_d_OBJ_txt2obj(char const * x0, int x1) +{ + return OBJ_txt2obj(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OBJ_txt2obj(PyObject *self, PyObject *args) +{ + char const * x0; + int x1; + Py_ssize_t datasize; + ASN1_OBJECT * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "OBJ_txt2obj", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OBJ_txt2obj(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(607)); +} +#else +# define _cffi_f_OBJ_txt2obj _cffi_d_OBJ_txt2obj +#endif + +static int _cffi_d_OCSP_BASICRESP_add_ext(OCSP_BASICRESP * x0, X509_EXTENSION * x1, int x2) +{ + return OCSP_BASICRESP_add_ext(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_BASICRESP_add_ext(PyObject *self, PyObject *args) +{ + OCSP_BASICRESP * x0; + X509_EXTENSION * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "OCSP_BASICRESP_add_ext", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(387), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(387), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(40), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_BASICRESP_add_ext(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_BASICRESP_add_ext _cffi_d_OCSP_BASICRESP_add_ext +#endif + +static void _cffi_d_OCSP_BASICRESP_free(OCSP_BASICRESP * x0) +{ + OCSP_BASICRESP_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_BASICRESP_free(PyObject *self, PyObject *arg0) +{ + OCSP_BASICRESP * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(387), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(387), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { OCSP_BASICRESP_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_OCSP_BASICRESP_free _cffi_d_OCSP_BASICRESP_free +#endif + +static X509_EXTENSION * _cffi_d_OCSP_BASICRESP_get_ext(OCSP_BASICRESP * x0, int x1) +{ + return OCSP_BASICRESP_get_ext(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_BASICRESP_get_ext(PyObject *self, PyObject *args) +{ + OCSP_BASICRESP * x0; + int x1; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "OCSP_BASICRESP_get_ext", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(387), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(387), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_BASICRESP_get_ext(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_OCSP_BASICRESP_get_ext _cffi_d_OCSP_BASICRESP_get_ext +#endif + +static int _cffi_d_OCSP_BASICRESP_get_ext_count(OCSP_BASICRESP * x0) +{ + return OCSP_BASICRESP_get_ext_count(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_BASICRESP_get_ext_count(PyObject *self, PyObject *arg0) +{ + OCSP_BASICRESP * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(387), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(387), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_BASICRESP_get_ext_count(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_BASICRESP_get_ext_count _cffi_d_OCSP_BASICRESP_get_ext_count +#endif + +static OCSP_BASICRESP * _cffi_d_OCSP_BASICRESP_new(void) +{ + return OCSP_BASICRESP_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_BASICRESP_new(PyObject *self, PyObject *noarg) +{ + OCSP_BASICRESP * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_BASICRESP_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(387)); +} +#else +# define _cffi_f_OCSP_BASICRESP_new _cffi_d_OCSP_BASICRESP_new +#endif + +static void _cffi_d_OCSP_CERTID_free(OCSP_CERTID * x0) +{ + OCSP_CERTID_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_CERTID_free(PyObject *self, PyObject *arg0) +{ + OCSP_CERTID * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(366), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_CERTID *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(366), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { OCSP_CERTID_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_OCSP_CERTID_free _cffi_d_OCSP_CERTID_free +#endif + +static int _cffi_d_OCSP_REQUEST_add_ext(OCSP_REQUEST * x0, X509_EXTENSION * x1, int x2) +{ + return OCSP_REQUEST_add_ext(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_REQUEST_add_ext(PyObject *self, PyObject *args) +{ + OCSP_REQUEST * x0; + X509_EXTENSION * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "OCSP_REQUEST_add_ext", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(365), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_REQUEST *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(365), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(40), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_REQUEST_add_ext(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_REQUEST_add_ext _cffi_d_OCSP_REQUEST_add_ext +#endif + +static void _cffi_d_OCSP_REQUEST_free(OCSP_REQUEST * x0) +{ + OCSP_REQUEST_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_REQUEST_free(PyObject *self, PyObject *arg0) +{ + OCSP_REQUEST * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(365), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_REQUEST *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(365), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { OCSP_REQUEST_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_OCSP_REQUEST_free _cffi_d_OCSP_REQUEST_free +#endif + +static X509_EXTENSION * _cffi_d_OCSP_REQUEST_get_ext(OCSP_REQUEST * x0, int x1) +{ + return OCSP_REQUEST_get_ext(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_REQUEST_get_ext(PyObject *self, PyObject *args) +{ + OCSP_REQUEST * x0; + int x1; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "OCSP_REQUEST_get_ext", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(365), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_REQUEST *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(365), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_REQUEST_get_ext(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_OCSP_REQUEST_get_ext _cffi_d_OCSP_REQUEST_get_ext +#endif + +static int _cffi_d_OCSP_REQUEST_get_ext_count(OCSP_REQUEST * x0) +{ + return OCSP_REQUEST_get_ext_count(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_REQUEST_get_ext_count(PyObject *self, PyObject *arg0) +{ + OCSP_REQUEST * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(365), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_REQUEST *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(365), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_REQUEST_get_ext_count(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_REQUEST_get_ext_count _cffi_d_OCSP_REQUEST_get_ext_count +#endif + +static OCSP_REQUEST * _cffi_d_OCSP_REQUEST_new(void) +{ + return OCSP_REQUEST_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_REQUEST_new(PyObject *self, PyObject *noarg) +{ + OCSP_REQUEST * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_REQUEST_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(365)); +} +#else +# define _cffi_f_OCSP_REQUEST_new _cffi_d_OCSP_REQUEST_new +#endif + +static void _cffi_d_OCSP_RESPONSE_free(OCSP_RESPONSE * x0) +{ + OCSP_RESPONSE_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_RESPONSE_free(PyObject *self, PyObject *arg0) +{ + OCSP_RESPONSE * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(349), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_RESPONSE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(349), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { OCSP_RESPONSE_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_OCSP_RESPONSE_free _cffi_d_OCSP_RESPONSE_free +#endif + +static OCSP_CERTID const * _cffi_d_OCSP_SINGLERESP_get0_id(OCSP_SINGLERESP const * x0) +{ + return OCSP_SINGLERESP_get0_id(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_SINGLERESP_get0_id(PyObject *self, PyObject *arg0) +{ + OCSP_SINGLERESP const * x0; + Py_ssize_t datasize; + OCSP_CERTID const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(362), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_SINGLERESP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(362), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_SINGLERESP_get0_id(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3079)); +} +#else +# define _cffi_f_OCSP_SINGLERESP_get0_id _cffi_d_OCSP_SINGLERESP_get0_id +#endif + +static X509_EXTENSION * _cffi_d_OCSP_SINGLERESP_get_ext(OCSP_SINGLERESP * x0, int x1) +{ + return OCSP_SINGLERESP_get_ext(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_SINGLERESP_get_ext(PyObject *self, PyObject *args) +{ + OCSP_SINGLERESP * x0; + int x1; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "OCSP_SINGLERESP_get_ext", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(594), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_SINGLERESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(594), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_SINGLERESP_get_ext(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_OCSP_SINGLERESP_get_ext _cffi_d_OCSP_SINGLERESP_get_ext +#endif + +static int _cffi_d_OCSP_SINGLERESP_get_ext_count(OCSP_SINGLERESP * x0) +{ + return OCSP_SINGLERESP_get_ext_count(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_SINGLERESP_get_ext_count(PyObject *self, PyObject *arg0) +{ + OCSP_SINGLERESP * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(594), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_SINGLERESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(594), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_SINGLERESP_get_ext_count(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_SINGLERESP_get_ext_count _cffi_d_OCSP_SINGLERESP_get_ext_count +#endif + +static int _cffi_d_OCSP_basic_add1_cert(OCSP_BASICRESP * x0, X509 * x1) +{ + return OCSP_basic_add1_cert(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_basic_add1_cert(PyObject *self, PyObject *args) +{ + OCSP_BASICRESP * x0; + X509 * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "OCSP_basic_add1_cert", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(387), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(387), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_basic_add1_cert(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_basic_add1_cert _cffi_d_OCSP_basic_add1_cert +#endif + +static OCSP_SINGLERESP * _cffi_d_OCSP_basic_add1_status(OCSP_BASICRESP * x0, OCSP_CERTID * x1, int x2, int x3, ASN1_OCTET_STRING * x4, ASN1_OCTET_STRING * x5, ASN1_OCTET_STRING * x6) +{ + return OCSP_basic_add1_status(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_basic_add1_status(PyObject *self, PyObject *args) +{ + OCSP_BASICRESP * x0; + OCSP_CERTID * x1; + int x2; + int x3; + ASN1_OCTET_STRING * x4; + ASN1_OCTET_STRING * x5; + ASN1_OCTET_STRING * x6; + Py_ssize_t datasize; + OCSP_SINGLERESP * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "OCSP_basic_add1_status", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(387), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(387), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(366), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (OCSP_CERTID *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(366), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(13), arg4) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(13), arg5) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg6, (char **)&x6); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x6 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x6, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x6, _cffi_type(13), arg6) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_basic_add1_status(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(594)); +} +#else +# define _cffi_f_OCSP_basic_add1_status _cffi_d_OCSP_basic_add1_status +#endif + +static int _cffi_d_OCSP_basic_sign(OCSP_BASICRESP * x0, X509 * x1, EVP_PKEY * x2, EVP_MD const * x3, Cryptography_STACK_OF_X509 * x4, unsigned long x5) +{ + return OCSP_basic_sign(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_basic_sign(PyObject *self, PyObject *args) +{ + OCSP_BASICRESP * x0; + X509 * x1; + EVP_PKEY * x2; + EVP_MD const * x3; + Cryptography_STACK_OF_X509 * x4; + unsigned long x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "OCSP_basic_sign", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(387), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(387), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(199), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(354), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(413), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (Cryptography_STACK_OF_X509 *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(413), arg4) < 0) + return NULL; + } + + x5 = _cffi_to_c_int(arg5, unsigned long); + if (x5 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_basic_sign(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_basic_sign _cffi_d_OCSP_basic_sign +#endif + +static OCSP_CERTID * _cffi_d_OCSP_cert_to_id(EVP_MD const * x0, X509 const * x1, X509 const * x2) +{ + return OCSP_cert_to_id(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_cert_to_id(PyObject *self, PyObject *args) +{ + EVP_MD const * x0; + X509 const * x1; + X509 const * x2; + Py_ssize_t datasize; + OCSP_CERTID * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "OCSP_cert_to_id", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(354), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(355), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(355), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(355), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (X509 const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(355), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_cert_to_id(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(366)); +} +#else +# define _cffi_f_OCSP_cert_to_id _cffi_d_OCSP_cert_to_id +#endif + +static int _cffi_d_OCSP_id_get0_info(ASN1_OCTET_STRING * * x0, ASN1_OBJECT * * x1, ASN1_OCTET_STRING * * x2, ASN1_INTEGER * * x3, OCSP_CERTID * x4) +{ + return OCSP_id_get0_info(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_id_get0_info(PyObject *self, PyObject *args) +{ + ASN1_OCTET_STRING * * x0; + ASN1_OBJECT * * x1; + ASN1_OCTET_STRING * * x2; + ASN1_INTEGER * * x3; + OCSP_CERTID * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "OCSP_id_get0_info", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(768), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING * *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(768), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(769), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OBJECT * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(769), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(768), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (ASN1_OCTET_STRING * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(768), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(771), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (ASN1_INTEGER * *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(771), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(366), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (OCSP_CERTID *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(366), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_id_get0_info(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_id_get0_info _cffi_d_OCSP_id_get0_info +#endif + +static OCSP_CERTID * _cffi_d_OCSP_onereq_get0_id(OCSP_ONEREQ * x0) +{ + return OCSP_onereq_get0_id(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_onereq_get0_id(PyObject *self, PyObject *arg0) +{ + OCSP_ONEREQ * x0; + Py_ssize_t datasize; + OCSP_CERTID * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(359), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_ONEREQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(359), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_onereq_get0_id(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(366)); +} +#else +# define _cffi_f_OCSP_onereq_get0_id _cffi_d_OCSP_onereq_get0_id +#endif + +static OCSP_ONEREQ * _cffi_d_OCSP_request_add0_id(OCSP_REQUEST * x0, OCSP_CERTID * x1) +{ + return OCSP_request_add0_id(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_request_add0_id(PyObject *self, PyObject *args) +{ + OCSP_REQUEST * x0; + OCSP_CERTID * x1; + Py_ssize_t datasize; + OCSP_ONEREQ * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "OCSP_request_add0_id", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(365), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_REQUEST *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(365), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(366), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (OCSP_CERTID *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(366), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_request_add0_id(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(359)); +} +#else +# define _cffi_f_OCSP_request_add0_id _cffi_d_OCSP_request_add0_id +#endif + +static int _cffi_d_OCSP_request_onereq_count(OCSP_REQUEST * x0) +{ + return OCSP_request_onereq_count(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_request_onereq_count(PyObject *self, PyObject *arg0) +{ + OCSP_REQUEST * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(365), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_REQUEST *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(365), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_request_onereq_count(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_request_onereq_count _cffi_d_OCSP_request_onereq_count +#endif + +static OCSP_ONEREQ * _cffi_d_OCSP_request_onereq_get0(OCSP_REQUEST * x0, int x1) +{ + return OCSP_request_onereq_get0(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_request_onereq_get0(PyObject *self, PyObject *args) +{ + OCSP_REQUEST * x0; + int x1; + Py_ssize_t datasize; + OCSP_ONEREQ * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "OCSP_request_onereq_get0", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(365), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_REQUEST *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(365), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_request_onereq_get0(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(359)); +} +#else +# define _cffi_f_OCSP_request_onereq_get0 _cffi_d_OCSP_request_onereq_get0 +#endif + +static int _cffi_d_OCSP_resp_count(OCSP_BASICRESP * x0) +{ + return OCSP_resp_count(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_resp_count(PyObject *self, PyObject *arg0) +{ + OCSP_BASICRESP * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(387), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(387), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_resp_count(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_resp_count _cffi_d_OCSP_resp_count +#endif + +static OCSP_SINGLERESP * _cffi_d_OCSP_resp_get0(OCSP_BASICRESP * x0, int x1) +{ + return OCSP_resp_get0(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_resp_get0(PyObject *self, PyObject *args) +{ + OCSP_BASICRESP * x0; + int x1; + Py_ssize_t datasize; + OCSP_SINGLERESP * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "OCSP_resp_get0", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(387), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(387), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_resp_get0(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(594)); +} +#else +# define _cffi_f_OCSP_resp_get0 _cffi_d_OCSP_resp_get0 +#endif + +static Cryptography_STACK_OF_X509 * _cffi_d_OCSP_resp_get0_certs(OCSP_BASICRESP const * x0) +{ + return OCSP_resp_get0_certs(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_resp_get0_certs(PyObject *self, PyObject *arg0) +{ + OCSP_BASICRESP const * x0; + Py_ssize_t datasize; + Cryptography_STACK_OF_X509 * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(17), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_resp_get0_certs(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(413)); +} +#else +# define _cffi_f_OCSP_resp_get0_certs _cffi_d_OCSP_resp_get0_certs +#endif + +static int _cffi_d_OCSP_resp_get0_id(OCSP_BASICRESP const * x0, ASN1_OCTET_STRING const * * x1, X509_NAME const * * x2) +{ + return OCSP_resp_get0_id(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_resp_get0_id(PyObject *self, PyObject *args) +{ + OCSP_BASICRESP const * x0; + ASN1_OCTET_STRING const * * x1; + X509_NAME const * * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "OCSP_resp_get0_id", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(17), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1566), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OCTET_STRING const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1566), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1567), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (X509_NAME const * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1567), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_resp_get0_id(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_resp_get0_id _cffi_d_OCSP_resp_get0_id +#endif + +static ASN1_GENERALIZEDTIME const * _cffi_d_OCSP_resp_get0_produced_at(OCSP_BASICRESP const * x0) +{ + return OCSP_resp_get0_produced_at(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_resp_get0_produced_at(PyObject *self, PyObject *arg0) +{ + OCSP_BASICRESP const * x0; + Py_ssize_t datasize; + ASN1_GENERALIZEDTIME const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(17), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_resp_get0_produced_at(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3009)); +} +#else +# define _cffi_f_OCSP_resp_get0_produced_at _cffi_d_OCSP_resp_get0_produced_at +#endif + +static OCSP_RESPDATA const * _cffi_d_OCSP_resp_get0_respdata(OCSP_BASICRESP const * x0) +{ + return OCSP_resp_get0_respdata(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_resp_get0_respdata(PyObject *self, PyObject *arg0) +{ + OCSP_BASICRESP const * x0; + Py_ssize_t datasize; + OCSP_RESPDATA const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(17), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_resp_get0_respdata(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3083)); +} +#else +# define _cffi_f_OCSP_resp_get0_respdata _cffi_d_OCSP_resp_get0_respdata +#endif + +static ASN1_OCTET_STRING const * _cffi_d_OCSP_resp_get0_signature(OCSP_BASICRESP const * x0) +{ + return OCSP_resp_get0_signature(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_resp_get0_signature(PyObject *self, PyObject *arg0) +{ + OCSP_BASICRESP const * x0; + Py_ssize_t datasize; + ASN1_OCTET_STRING const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(17), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_resp_get0_signature(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3016)); +} +#else +# define _cffi_f_OCSP_resp_get0_signature _cffi_d_OCSP_resp_get0_signature +#endif + +static X509_ALGOR const * _cffi_d_OCSP_resp_get0_tbs_sigalg(OCSP_BASICRESP const * x0) +{ + return OCSP_resp_get0_tbs_sigalg(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_resp_get0_tbs_sigalg(PyObject *self, PyObject *arg0) +{ + OCSP_BASICRESP const * x0; + Py_ssize_t datasize; + X509_ALGOR const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(17), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_BASICRESP const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(17), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_resp_get0_tbs_sigalg(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3121)); +} +#else +# define _cffi_f_OCSP_resp_get0_tbs_sigalg _cffi_d_OCSP_resp_get0_tbs_sigalg +#endif + +static OCSP_RESPONSE * _cffi_d_OCSP_response_create(int x0, OCSP_BASICRESP * x1) +{ + return OCSP_response_create(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_response_create(PyObject *self, PyObject *args) +{ + int x0; + OCSP_BASICRESP * x1; + Py_ssize_t datasize; + OCSP_RESPONSE * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "OCSP_response_create", 2, 2, &arg0, &arg1)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(387), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (OCSP_BASICRESP *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(387), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_response_create(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(349)); +} +#else +# define _cffi_f_OCSP_response_create _cffi_d_OCSP_response_create +#endif + +static OCSP_BASICRESP * _cffi_d_OCSP_response_get1_basic(OCSP_RESPONSE * x0) +{ + return OCSP_response_get1_basic(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_response_get1_basic(PyObject *self, PyObject *arg0) +{ + OCSP_RESPONSE * x0; + Py_ssize_t datasize; + OCSP_BASICRESP * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(349), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_RESPONSE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(349), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_response_get1_basic(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(387)); +} +#else +# define _cffi_f_OCSP_response_get1_basic _cffi_d_OCSP_response_get1_basic +#endif + +static int _cffi_d_OCSP_response_status(OCSP_RESPONSE * x0) +{ + return OCSP_response_status(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_response_status(PyObject *self, PyObject *arg0) +{ + OCSP_RESPONSE * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(349), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_RESPONSE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(349), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_response_status(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_response_status _cffi_d_OCSP_response_status +#endif + +static int _cffi_d_OCSP_single_get0_status(OCSP_SINGLERESP * x0, int * x1, ASN1_GENERALIZEDTIME * * x2, ASN1_GENERALIZEDTIME * * x3, ASN1_GENERALIZEDTIME * * x4) +{ + return OCSP_single_get0_status(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OCSP_single_get0_status(PyObject *self, PyObject *args) +{ + OCSP_SINGLERESP * x0; + int * x1; + ASN1_GENERALIZEDTIME * * x2; + ASN1_GENERALIZEDTIME * * x3; + ASN1_GENERALIZEDTIME * * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "OCSP_single_get0_status", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(594), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_SINGLERESP *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(594), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (int *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1169), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(14), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (ASN1_GENERALIZEDTIME * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(14), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(14), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (ASN1_GENERALIZEDTIME * *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(14), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(14), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (ASN1_GENERALIZEDTIME * *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(14), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OCSP_single_get0_status(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_OCSP_single_get0_status _cffi_d_OCSP_single_get0_status +#endif + +static void _cffi_d_OPENSSL_cleanup(void) +{ + OPENSSL_cleanup(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OPENSSL_cleanup(PyObject *self, PyObject *noarg) +{ + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { OPENSSL_cleanup(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_OPENSSL_cleanup _cffi_d_OPENSSL_cleanup +#endif + +static void _cffi_d_OPENSSL_config(char const * x0) +{ + OPENSSL_config(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OPENSSL_config(PyObject *self, PyObject *arg0) +{ + char const * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { OPENSSL_config(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_OPENSSL_config _cffi_d_OPENSSL_config +#endif + +static void _cffi_d_OPENSSL_free(void * x0) +{ + OPENSSL_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OPENSSL_free(PyObject *self, PyObject *arg0) +{ + void * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (void *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(193), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { OPENSSL_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_OPENSSL_free _cffi_d_OPENSSL_free +#endif + +static void * _cffi_d_OPENSSL_malloc(size_t x0) +{ + return OPENSSL_malloc(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OPENSSL_malloc(PyObject *self, PyObject *arg0) +{ + size_t x0; + void * result; + + x0 = _cffi_to_c_int(arg0, size_t); + if (x0 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OPENSSL_malloc(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(193)); +} +#else +# define _cffi_f_OPENSSL_malloc _cffi_d_OPENSSL_malloc +#endif + +static void _cffi_d_OPENSSL_no_config(void) +{ + OPENSSL_no_config(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OPENSSL_no_config(PyObject *self, PyObject *noarg) +{ + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { OPENSSL_no_config(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_OPENSSL_no_config _cffi_d_OPENSSL_no_config +#endif + +static void _cffi_d_OTHERNAME_free(OTHERNAME * x0) +{ + OTHERNAME_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OTHERNAME_free(PyObject *self, PyObject *arg0) +{ + OTHERNAME * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2726), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OTHERNAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2726), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { OTHERNAME_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_OTHERNAME_free _cffi_d_OTHERNAME_free +#endif + +static OTHERNAME * _cffi_d_OTHERNAME_new(void) +{ + return OTHERNAME_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OTHERNAME_new(PyObject *self, PyObject *noarg) +{ + OTHERNAME * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OTHERNAME_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2726)); +} +#else +# define _cffi_f_OTHERNAME_new _cffi_d_OTHERNAME_new +#endif + +static void _cffi_d_OpenSSL_add_all_algorithms(void) +{ + OpenSSL_add_all_algorithms(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OpenSSL_add_all_algorithms(PyObject *self, PyObject *noarg) +{ + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { OpenSSL_add_all_algorithms(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_OpenSSL_add_all_algorithms _cffi_d_OpenSSL_add_all_algorithms +#endif + +static char const * _cffi_d_OpenSSL_version(int x0) +{ + return OpenSSL_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OpenSSL_version(PyObject *self, PyObject *arg0) +{ + int x0; + char const * result; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OpenSSL_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_OpenSSL_version _cffi_d_OpenSSL_version +#endif + +static unsigned long _cffi_d_OpenSSL_version_num(void) +{ + return OpenSSL_version_num(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_OpenSSL_version_num(PyObject *self, PyObject *noarg) +{ + unsigned long result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = OpenSSL_version_num(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_OpenSSL_version_num _cffi_d_OpenSSL_version_num +#endif + +static DH * _cffi_d_PEM_read_bio_DHparams(BIO * x0, DH * * x1, int(* x2)(char *, int, int, void *), void * x3) +{ + return PEM_read_bio_DHparams(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_read_bio_DHparams(PyObject *self, PyObject *args) +{ + BIO * x0; + DH * * x1; + int(* x2)(char *, int, int, void *); + void * x3; + Py_ssize_t datasize; + DH * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "PEM_read_bio_DHparams", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(187), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DH * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(187), arg1) < 0) + return NULL; + } + + x2 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg2, _cffi_type(192)); + if (x2 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_read_bio_DHparams(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(196)); +} +#else +# define _cffi_f_PEM_read_bio_DHparams _cffi_d_PEM_read_bio_DHparams +#endif + +static PKCS7 * _cffi_d_PEM_read_bio_PKCS7(BIO * x0, PKCS7 * * x1, int(* x2)(char *, int, int, void *), void * x3) +{ + return PEM_read_bio_PKCS7(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_read_bio_PKCS7(PyObject *self, PyObject *args) +{ + BIO * x0; + PKCS7 * * x1; + int(* x2)(char *, int, int, void *); + void * x3; + Py_ssize_t datasize; + PKCS7 * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "PEM_read_bio_PKCS7", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(426), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (PKCS7 * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(426), arg1) < 0) + return NULL; + } + + x2 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg2, _cffi_type(192)); + if (x2 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_read_bio_PKCS7(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(442)); +} +#else +# define _cffi_f_PEM_read_bio_PKCS7 _cffi_d_PEM_read_bio_PKCS7 +#endif + +static EVP_PKEY * _cffi_d_PEM_read_bio_PUBKEY(BIO * x0, EVP_PKEY * * x1, int(* x2)(char *, int, int, void *), void * x3) +{ + return PEM_read_bio_PUBKEY(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_read_bio_PUBKEY(PyObject *self, PyObject *args) +{ + BIO * x0; + EVP_PKEY * * x1; + int(* x2)(char *, int, int, void *); + void * x3; + Py_ssize_t datasize; + EVP_PKEY * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "PEM_read_bio_PUBKEY", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(273), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(273), arg1) < 0) + return NULL; + } + + x2 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg2, _cffi_type(192)); + if (x2 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_read_bio_PUBKEY(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_PEM_read_bio_PUBKEY _cffi_d_PEM_read_bio_PUBKEY +#endif + +static EVP_PKEY * _cffi_d_PEM_read_bio_PrivateKey(BIO * x0, EVP_PKEY * * x1, int(* x2)(char *, int, int, void *), void * x3) +{ + return PEM_read_bio_PrivateKey(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_read_bio_PrivateKey(PyObject *self, PyObject *args) +{ + BIO * x0; + EVP_PKEY * * x1; + int(* x2)(char *, int, int, void *); + void * x3; + Py_ssize_t datasize; + EVP_PKEY * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "PEM_read_bio_PrivateKey", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(273), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(273), arg1) < 0) + return NULL; + } + + x2 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg2, _cffi_type(192)); + if (x2 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_read_bio_PrivateKey(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_PEM_read_bio_PrivateKey _cffi_d_PEM_read_bio_PrivateKey +#endif + +static RSA * _cffi_d_PEM_read_bio_RSAPublicKey(BIO * x0, RSA * * x1, int(* x2)(char *, int, int, void *), void * x3) +{ + return PEM_read_bio_RSAPublicKey(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_read_bio_RSAPublicKey(PyObject *self, PyObject *args) +{ + BIO * x0; + RSA * * x1; + int(* x2)(char *, int, int, void *); + void * x3; + Py_ssize_t datasize; + RSA * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "PEM_read_bio_RSAPublicKey", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(464), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (RSA * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(464), arg1) < 0) + return NULL; + } + + x2 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg2, _cffi_type(192)); + if (x2 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_read_bio_RSAPublicKey(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(476)); +} +#else +# define _cffi_f_PEM_read_bio_RSAPublicKey _cffi_d_PEM_read_bio_RSAPublicKey +#endif + +static X509 * _cffi_d_PEM_read_bio_X509(BIO * x0, X509 * * x1, int(* x2)(char *, int, int, void *), void * x3) +{ + return PEM_read_bio_X509(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_read_bio_X509(PyObject *self, PyObject *args) +{ + BIO * x0; + X509 * * x1; + int(* x2)(char *, int, int, void *); + void * x3; + Py_ssize_t datasize; + X509 * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "PEM_read_bio_X509", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(518), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(518), arg1) < 0) + return NULL; + } + + x2 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg2, _cffi_type(192)); + if (x2 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_read_bio_X509(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(28)); +} +#else +# define _cffi_f_PEM_read_bio_X509 _cffi_d_PEM_read_bio_X509 +#endif + +static X509_CRL * _cffi_d_PEM_read_bio_X509_CRL(BIO * x0, X509_CRL * * x1, int(* x2)(char *, int, int, void *), void * x3) +{ + return PEM_read_bio_X509_CRL(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_read_bio_X509_CRL(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_CRL * * x1; + int(* x2)(char *, int, int, void *); + void * x3; + Py_ssize_t datasize; + X509_CRL * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "PEM_read_bio_X509_CRL", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(556), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_CRL * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(556), arg1) < 0) + return NULL; + } + + x2 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg2, _cffi_type(192)); + if (x2 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_read_bio_X509_CRL(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(57)); +} +#else +# define _cffi_f_PEM_read_bio_X509_CRL _cffi_d_PEM_read_bio_X509_CRL +#endif + +static X509_REQ * _cffi_d_PEM_read_bio_X509_REQ(BIO * x0, X509_REQ * * x1, int(* x2)(char *, int, int, void *), void * x3) +{ + return PEM_read_bio_X509_REQ(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_read_bio_X509_REQ(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_REQ * * x1; + int(* x2)(char *, int, int, void *); + void * x3; + Py_ssize_t datasize; + X509_REQ * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "PEM_read_bio_X509_REQ", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(671), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_REQ * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(671), arg1) < 0) + return NULL; + } + + x2 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg2, _cffi_type(192)); + if (x2 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_read_bio_X509_REQ(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(294)); +} +#else +# define _cffi_f_PEM_read_bio_X509_REQ _cffi_d_PEM_read_bio_X509_REQ +#endif + +static int _cffi_d_PEM_write_bio_DHparams(BIO * x0, DH * x1) +{ + return PEM_write_bio_DHparams(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_DHparams(PyObject *self, PyObject *args) +{ + BIO * x0; + DH * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_DHparams", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DH *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(196), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_DHparams(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_DHparams _cffi_d_PEM_write_bio_DHparams +#endif + +static int _cffi_d_PEM_write_bio_DHxparams(BIO * x0, DH * x1) +{ + return PEM_write_bio_DHxparams(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_DHxparams(PyObject *self, PyObject *args) +{ + BIO * x0; + DH * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_DHxparams", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DH *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(196), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_DHxparams(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_DHxparams _cffi_d_PEM_write_bio_DHxparams +#endif + +static int _cffi_d_PEM_write_bio_DSAPrivateKey(BIO * x0, DSA * x1, EVP_CIPHER const * x2, unsigned char * x3, int x4, int(* x5)(char *, int, int, void *), void * x6) +{ + return PEM_write_bio_DSAPrivateKey(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_DSAPrivateKey(PyObject *self, PyObject *args) +{ + BIO * x0; + DSA * x1; + EVP_CIPHER const * x2; + unsigned char * x3; + int x4; + int(* x5)(char *, int, int, void *); + void * x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_DSAPrivateKey", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(212), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DSA *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(212), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(885), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_CIPHER const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(885), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(752), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + x5 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg5, _cffi_type(192)); + if (x5 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg6, (char **)&x6); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x6 = (void *)alloca((size_t)datasize); + memset((void *)x6, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x6, _cffi_type(193), arg6) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_DSAPrivateKey(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_DSAPrivateKey _cffi_d_PEM_write_bio_DSAPrivateKey +#endif + +static int _cffi_d_PEM_write_bio_ECPrivateKey(BIO * x0, EC_KEY * x1, EVP_CIPHER const * x2, unsigned char * x3, int x4, int(* x5)(char *, int, int, void *), void * x6) +{ + return PEM_write_bio_ECPrivateKey(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_ECPrivateKey(PyObject *self, PyObject *args) +{ + BIO * x0; + EC_KEY * x1; + EVP_CIPHER const * x2; + unsigned char * x3; + int x4; + int(* x5)(char *, int, int, void *); + void * x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_ECPrivateKey", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(893), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(885), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_CIPHER const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(885), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(752), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + x5 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg5, _cffi_type(192)); + if (x5 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg6, (char **)&x6); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x6 = (void *)alloca((size_t)datasize); + memset((void *)x6, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x6, _cffi_type(193), arg6) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_ECPrivateKey(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_ECPrivateKey _cffi_d_PEM_write_bio_ECPrivateKey +#endif + +static int _cffi_d_PEM_write_bio_PKCS7(BIO * x0, PKCS7 * x1) +{ + return PEM_write_bio_PKCS7(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_PKCS7(PyObject *self, PyObject *args) +{ + BIO * x0; + PKCS7 * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_PKCS7", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(442), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_PKCS7(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_PKCS7 _cffi_d_PEM_write_bio_PKCS7 +#endif + +static int _cffi_d_PEM_write_bio_PKCS7_stream(BIO * x0, PKCS7 * x1, BIO * x2, int x3) +{ + return PEM_write_bio_PKCS7_stream(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_PKCS7_stream(PyObject *self, PyObject *args) +{ + BIO * x0; + PKCS7 * x1; + BIO * x2; + int x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_PKCS7_stream", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(442), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIO *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(186), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_PKCS7_stream(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_PKCS7_stream _cffi_d_PEM_write_bio_PKCS7_stream +#endif + +static int _cffi_d_PEM_write_bio_PKCS8PrivateKey(BIO * x0, EVP_PKEY * x1, EVP_CIPHER const * x2, char * x3, int x4, int(* x5)(char *, int, int, void *), void * x6) +{ + return PEM_write_bio_PKCS8PrivateKey(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_PKCS8PrivateKey(PyObject *self, PyObject *args) +{ + BIO * x0; + EVP_PKEY * x1; + EVP_CIPHER const * x2; + char * x3; + int x4; + int(* x5)(char *, int, int, void *); + void * x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_PKCS8PrivateKey", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(885), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_CIPHER const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(885), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(409), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + x5 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg5, _cffi_type(192)); + if (x5 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg6, (char **)&x6); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x6 = (void *)alloca((size_t)datasize); + memset((void *)x6, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x6, _cffi_type(193), arg6) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_PKCS8PrivateKey(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_PKCS8PrivateKey _cffi_d_PEM_write_bio_PKCS8PrivateKey +#endif + +static int _cffi_d_PEM_write_bio_PUBKEY(BIO * x0, EVP_PKEY * x1) +{ + return PEM_write_bio_PUBKEY(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_PUBKEY(PyObject *self, PyObject *args) +{ + BIO * x0; + EVP_PKEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_PUBKEY", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_PUBKEY(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_PUBKEY _cffi_d_PEM_write_bio_PUBKEY +#endif + +static int _cffi_d_PEM_write_bio_PrivateKey(BIO * x0, EVP_PKEY * x1, EVP_CIPHER const * x2, unsigned char * x3, int x4, int(* x5)(char *, int, int, void *), void * x6) +{ + return PEM_write_bio_PrivateKey(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_PrivateKey(PyObject *self, PyObject *args) +{ + BIO * x0; + EVP_PKEY * x1; + EVP_CIPHER const * x2; + unsigned char * x3; + int x4; + int(* x5)(char *, int, int, void *); + void * x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_PrivateKey", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(885), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_CIPHER const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(885), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(752), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + x5 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg5, _cffi_type(192)); + if (x5 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg6, (char **)&x6); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x6 = (void *)alloca((size_t)datasize); + memset((void *)x6, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x6, _cffi_type(193), arg6) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_PrivateKey(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_PrivateKey _cffi_d_PEM_write_bio_PrivateKey +#endif + +static int _cffi_d_PEM_write_bio_RSAPrivateKey(BIO * x0, RSA * x1, EVP_CIPHER const * x2, unsigned char * x3, int x4, int(* x5)(char *, int, int, void *), void * x6) +{ + return PEM_write_bio_RSAPrivateKey(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_RSAPrivateKey(PyObject *self, PyObject *args) +{ + BIO * x0; + RSA * x1; + EVP_CIPHER const * x2; + unsigned char * x3; + int x4; + int(* x5)(char *, int, int, void *); + void * x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_RSAPrivateKey", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (RSA *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(476), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(885), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_CIPHER const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(885), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(752), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + x5 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg5, _cffi_type(192)); + if (x5 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg6, (char **)&x6); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x6 = (void *)alloca((size_t)datasize); + memset((void *)x6, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x6, _cffi_type(193), arg6) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_RSAPrivateKey(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_RSAPrivateKey _cffi_d_PEM_write_bio_RSAPrivateKey +#endif + +static int _cffi_d_PEM_write_bio_RSAPublicKey(BIO * x0, RSA const * x1) +{ + return PEM_write_bio_RSAPublicKey(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_RSAPublicKey(PyObject *self, PyObject *args) +{ + BIO * x0; + RSA const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_RSAPublicKey", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(967), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (RSA const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(967), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_RSAPublicKey(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_RSAPublicKey _cffi_d_PEM_write_bio_RSAPublicKey +#endif + +static int _cffi_d_PEM_write_bio_X509(BIO * x0, X509 * x1) +{ + return PEM_write_bio_X509(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_X509(PyObject *self, PyObject *args) +{ + BIO * x0; + X509 * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_X509", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_X509(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_X509 _cffi_d_PEM_write_bio_X509 +#endif + +static int _cffi_d_PEM_write_bio_X509_CRL(BIO * x0, X509_CRL * x1) +{ + return PEM_write_bio_X509_CRL(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_X509_CRL(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_CRL * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_X509_CRL", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(57), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_X509_CRL(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_X509_CRL _cffi_d_PEM_write_bio_X509_CRL +#endif + +static int _cffi_d_PEM_write_bio_X509_REQ(BIO * x0, X509_REQ * x1) +{ + return PEM_write_bio_X509_REQ(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PEM_write_bio_X509_REQ(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_REQ * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "PEM_write_bio_X509_REQ", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(294), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PEM_write_bio_X509_REQ(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PEM_write_bio_X509_REQ _cffi_d_PEM_write_bio_X509_REQ +#endif + +static PKCS12 * _cffi_d_PKCS12_create(char * x0, char * x1, EVP_PKEY * x2, X509 * x3, Cryptography_STACK_OF_X509 * x4, int x5, int x6, int x7, int x8, int x9) +{ + return PKCS12_create(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS12_create(PyObject *self, PyObject *args) +{ + char * x0; + char * x1; + EVP_PKEY * x2; + X509 * x3; + Cryptography_STACK_OF_X509 * x4; + int x5; + int x6; + int x7; + int x8; + int x9; + Py_ssize_t datasize; + PKCS12 * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + PyObject *arg7; + PyObject *arg8; + PyObject *arg9; + + if (!PyArg_UnpackTuple(args, "PKCS12_create", 10, 10, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6, &arg7, &arg8, &arg9)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(409), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(409), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(199), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (X509 *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(28), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(413), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (Cryptography_STACK_OF_X509 *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(413), arg4) < 0) + return NULL; + } + + x5 = _cffi_to_c_int(arg5, int); + if (x5 == (int)-1 && PyErr_Occurred()) + return NULL; + + x6 = _cffi_to_c_int(arg6, int); + if (x6 == (int)-1 && PyErr_Occurred()) + return NULL; + + x7 = _cffi_to_c_int(arg7, int); + if (x7 == (int)-1 && PyErr_Occurred()) + return NULL; + + x8 = _cffi_to_c_int(arg8, int); + if (x8 == (int)-1 && PyErr_Occurred()) + return NULL; + + x9 = _cffi_to_c_int(arg9, int); + if (x9 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PKCS12_create(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(940)); +} +#else +# define _cffi_f_PKCS12_create _cffi_d_PKCS12_create +#endif + +static void _cffi_d_PKCS12_free(PKCS12 * x0) +{ + PKCS12_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS12_free(PyObject *self, PyObject *arg0) +{ + PKCS12 * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(940), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (PKCS12 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(940), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { PKCS12_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_PKCS12_free _cffi_d_PKCS12_free +#endif + +static int _cffi_d_PKCS12_parse(PKCS12 * x0, char const * x1, EVP_PKEY * * x2, X509 * * x3, Cryptography_STACK_OF_X509 * * x4) +{ + return PKCS12_parse(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS12_parse(PyObject *self, PyObject *args) +{ + PKCS12 * x0; + char const * x1; + EVP_PKEY * * x2; + X509 * * x3; + Cryptography_STACK_OF_X509 * * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "PKCS12_parse", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(940), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (PKCS12 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(940), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(273), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_PKEY * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(273), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(518), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (X509 * *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(518), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1599), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (Cryptography_STACK_OF_X509 * *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(1599), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PKCS12_parse(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PKCS12_parse _cffi_d_PKCS12_parse +#endif + +static int _cffi_d_PKCS5_PBKDF2_HMAC(char const * x0, int x1, unsigned char const * x2, int x3, int x4, EVP_MD const * x5, int x6, unsigned char * x7) +{ + return PKCS5_PBKDF2_HMAC(x0, x1, x2, x3, x4, x5, x6, x7); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS5_PBKDF2_HMAC(PyObject *self, PyObject *args) +{ + char const * x0; + int x1; + unsigned char const * x2; + int x3; + int x4; + EVP_MD const * x5; + int x6; + unsigned char * x7; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + PyObject *arg7; + + if (!PyArg_UnpackTuple(args, "PKCS5_PBKDF2_HMAC", 8, 8, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6, &arg7)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(103), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(354), arg5) < 0) + return NULL; + } + + x6 = _cffi_to_c_int(arg6, int); + if (x6 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg7, (char **)&x7); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x7 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x7, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x7, _cffi_type(752), arg7) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PKCS5_PBKDF2_HMAC(x0, x1, x2, x3, x4, x5, x6, x7); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PKCS5_PBKDF2_HMAC _cffi_d_PKCS5_PBKDF2_HMAC +#endif + +static int _cffi_d_PKCS7_final(PKCS7 * x0, BIO * x1, int x2) +{ + return PKCS7_final(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS7_final(PyObject *self, PyObject *args) +{ + PKCS7 * x0; + BIO * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "PKCS7_final", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(442), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIO *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(186), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PKCS7_final(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PKCS7_final _cffi_d_PKCS7_final +#endif + +static void _cffi_d_PKCS7_free(PKCS7 * x0) +{ + PKCS7_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS7_free(PyObject *self, PyObject *arg0) +{ + PKCS7 * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(442), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { PKCS7_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_PKCS7_free _cffi_d_PKCS7_free +#endif + +static PKCS7 * _cffi_d_PKCS7_sign(X509 * x0, EVP_PKEY * x1, Cryptography_STACK_OF_X509 * x2, BIO * x3, int x4) +{ + return PKCS7_sign(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS7_sign(PyObject *self, PyObject *args) +{ + X509 * x0; + EVP_PKEY * x1; + Cryptography_STACK_OF_X509 * x2; + BIO * x3; + int x4; + Py_ssize_t datasize; + PKCS7 * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "PKCS7_sign", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(413), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (Cryptography_STACK_OF_X509 *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(413), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIO *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(186), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PKCS7_sign(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(442)); +} +#else +# define _cffi_f_PKCS7_sign _cffi_d_PKCS7_sign +#endif + +static PKCS7_SIGNER_INFO * _cffi_d_PKCS7_sign_add_signer(PKCS7 * x0, X509 * x1, EVP_PKEY * x2, EVP_MD const * x3, int x4) +{ + return PKCS7_sign_add_signer(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS7_sign_add_signer(PyObject *self, PyObject *args) +{ + PKCS7 * x0; + X509 * x1; + EVP_PKEY * x2; + EVP_MD const * x3; + int x4; + Py_ssize_t datasize; + PKCS7_SIGNER_INFO * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "PKCS7_sign_add_signer", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(442), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(199), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(354), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PKCS7_sign_add_signer(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3098)); +} +#else +# define _cffi_f_PKCS7_sign_add_signer _cffi_d_PKCS7_sign_add_signer +#endif + +static int _cffi_d_PKCS7_type_is_data(PKCS7 * x0) +{ + return PKCS7_type_is_data(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS7_type_is_data(PyObject *self, PyObject *arg0) +{ + PKCS7 * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(442), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PKCS7_type_is_data(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PKCS7_type_is_data _cffi_d_PKCS7_type_is_data +#endif + +static int _cffi_d_PKCS7_type_is_enveloped(PKCS7 * x0) +{ + return PKCS7_type_is_enveloped(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS7_type_is_enveloped(PyObject *self, PyObject *arg0) +{ + PKCS7 * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(442), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PKCS7_type_is_enveloped(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PKCS7_type_is_enveloped _cffi_d_PKCS7_type_is_enveloped +#endif + +static int _cffi_d_PKCS7_type_is_signed(PKCS7 * x0) +{ + return PKCS7_type_is_signed(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS7_type_is_signed(PyObject *self, PyObject *arg0) +{ + PKCS7 * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(442), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PKCS7_type_is_signed(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PKCS7_type_is_signed _cffi_d_PKCS7_type_is_signed +#endif + +static int _cffi_d_PKCS7_type_is_signedAndEnveloped(PKCS7 * x0) +{ + return PKCS7_type_is_signedAndEnveloped(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS7_type_is_signedAndEnveloped(PyObject *self, PyObject *arg0) +{ + PKCS7 * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(442), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PKCS7_type_is_signedAndEnveloped(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PKCS7_type_is_signedAndEnveloped _cffi_d_PKCS7_type_is_signedAndEnveloped +#endif + +static int _cffi_d_PKCS7_verify(PKCS7 * x0, Cryptography_STACK_OF_X509 * x1, X509_STORE * x2, BIO * x3, BIO * x4, int x5) +{ + return PKCS7_verify(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_PKCS7_verify(PyObject *self, PyObject *args) +{ + PKCS7 * x0; + Cryptography_STACK_OF_X509 * x1; + X509_STORE * x2; + BIO * x3; + BIO * x4; + int x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "PKCS7_verify", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(442), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(413), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (Cryptography_STACK_OF_X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(413), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(180), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIO *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(186), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (BIO *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(186), arg4) < 0) + return NULL; + } + + x5 = _cffi_to_c_int(arg5, int); + if (x5 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = PKCS7_verify(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_PKCS7_verify _cffi_d_PKCS7_verify +#endif + +static void _cffi_d_POLICYINFO_free(POLICYINFO * x0) +{ + POLICYINFO_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_POLICYINFO_free(PyObject *self, PyObject *arg0) +{ + POLICYINFO * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1091), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (POLICYINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1091), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { POLICYINFO_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_POLICYINFO_free _cffi_d_POLICYINFO_free +#endif + +static POLICYINFO * _cffi_d_POLICYINFO_new(void) +{ + return POLICYINFO_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_POLICYINFO_new(PyObject *self, PyObject *noarg) +{ + POLICYINFO * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = POLICYINFO_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1091)); +} +#else +# define _cffi_f_POLICYINFO_new _cffi_d_POLICYINFO_new +#endif + +static void _cffi_d_POLICYQUALINFO_free(POLICYQUALINFO * x0) +{ + POLICYQUALINFO_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_POLICYQUALINFO_free(PyObject *self, PyObject *arg0) +{ + POLICYQUALINFO * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1098), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (POLICYQUALINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1098), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { POLICYQUALINFO_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_POLICYQUALINFO_free _cffi_d_POLICYQUALINFO_free +#endif + +static POLICYQUALINFO * _cffi_d_POLICYQUALINFO_new(void) +{ + return POLICYQUALINFO_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_POLICYQUALINFO_new(PyObject *self, PyObject *noarg) +{ + POLICYQUALINFO * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = POLICYQUALINFO_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1098)); +} +#else +# define _cffi_f_POLICYQUALINFO_new _cffi_d_POLICYQUALINFO_new +#endif + +static void _cffi_d_POLICY_CONSTRAINTS_free(POLICY_CONSTRAINTS * x0) +{ + POLICY_CONSTRAINTS_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_POLICY_CONSTRAINTS_free(PyObject *self, PyObject *arg0) +{ + POLICY_CONSTRAINTS * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2741), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (POLICY_CONSTRAINTS *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2741), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { POLICY_CONSTRAINTS_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_POLICY_CONSTRAINTS_free _cffi_d_POLICY_CONSTRAINTS_free +#endif + +static POLICY_CONSTRAINTS * _cffi_d_POLICY_CONSTRAINTS_new(void) +{ + return POLICY_CONSTRAINTS_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_POLICY_CONSTRAINTS_new(PyObject *self, PyObject *noarg) +{ + POLICY_CONSTRAINTS * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = POLICY_CONSTRAINTS_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2741)); +} +#else +# define _cffi_f_POLICY_CONSTRAINTS_new _cffi_d_POLICY_CONSTRAINTS_new +#endif + +static void _cffi_d_RAND_add(void const * x0, int x1, double x2) +{ + RAND_add(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RAND_add(PyObject *self, PyObject *args) +{ + void const * x0; + int x1; + double x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "RAND_add", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (void const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(126), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = (double)_cffi_to_c_double(arg2); + if (x2 == (double)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { RAND_add(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_RAND_add _cffi_d_RAND_add +#endif + +static int _cffi_d_RAND_bytes(unsigned char * x0, int x1) +{ + return RAND_bytes(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RAND_bytes(PyObject *self, PyObject *args) +{ + unsigned char * x0; + int x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "RAND_bytes", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(752), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RAND_bytes(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_RAND_bytes _cffi_d_RAND_bytes +#endif + +static int _cffi_d_RAND_set_rand_method(RAND_METHOD const * x0) +{ + return RAND_set_rand_method(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RAND_set_rand_method(PyObject *self, PyObject *arg0) +{ + RAND_METHOD const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1618), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RAND_METHOD const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1618), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RAND_set_rand_method(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_RAND_set_rand_method _cffi_d_RAND_set_rand_method +#endif + +static int _cffi_d_RAND_status(void) +{ + return RAND_status(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RAND_status(PyObject *self, PyObject *noarg) +{ + int result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RAND_status(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_RAND_status _cffi_d_RAND_status +#endif + +static RSA * _cffi_d_RSAPublicKey_dup(RSA * x0) +{ + return RSAPublicKey_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSAPublicKey_dup(PyObject *self, PyObject *arg0) +{ + RSA * x0; + Py_ssize_t datasize; + RSA * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(476), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RSAPublicKey_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(476)); +} +#else +# define _cffi_f_RSAPublicKey_dup _cffi_d_RSAPublicKey_dup +#endif + +static int _cffi_d_RSA_blinding_on(RSA * x0, BN_CTX * x1) +{ + return RSA_blinding_on(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_blinding_on(PyObject *self, PyObject *args) +{ + RSA * x0; + BN_CTX * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "RSA_blinding_on", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(476), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(94), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BN_CTX *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(94), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RSA_blinding_on(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_RSA_blinding_on _cffi_d_RSA_blinding_on +#endif + +static int _cffi_d_RSA_check_key(RSA const * x0) +{ + return RSA_check_key(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_check_key(PyObject *self, PyObject *arg0) +{ + RSA const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(967), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RSA const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(967), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RSA_check_key(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_RSA_check_key _cffi_d_RSA_check_key +#endif + +static void _cffi_d_RSA_free(RSA * x0) +{ + RSA_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_free(PyObject *self, PyObject *arg0) +{ + RSA * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(476), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { RSA_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_RSA_free _cffi_d_RSA_free +#endif + +static int _cffi_d_RSA_generate_key_ex(RSA * x0, int x1, BIGNUM * x2, BN_GENCB * x3) +{ + return RSA_generate_key_ex(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_generate_key_ex(PyObject *self, PyObject *args) +{ + RSA * x0; + int x1; + BIGNUM * x2; + BN_GENCB * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "RSA_generate_key_ex", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(476), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(848), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BN_GENCB *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(848), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RSA_generate_key_ex(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_RSA_generate_key_ex _cffi_d_RSA_generate_key_ex +#endif + +static void _cffi_d_RSA_get0_crt_params(RSA const * x0, BIGNUM const * * x1, BIGNUM const * * x2, BIGNUM const * * x3) +{ + RSA_get0_crt_params(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_get0_crt_params(PyObject *self, PyObject *args) +{ + RSA const * x0; + BIGNUM const * * x1; + BIGNUM const * * x2; + BIGNUM const * * x3; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "RSA_get0_crt_params", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(967), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RSA const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(967), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2631), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2631), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(2631), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { RSA_get0_crt_params(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_RSA_get0_crt_params _cffi_d_RSA_get0_crt_params +#endif + +static void _cffi_d_RSA_get0_factors(RSA const * x0, BIGNUM const * * x1, BIGNUM const * * x2) +{ + RSA_get0_factors(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_get0_factors(PyObject *self, PyObject *args) +{ + RSA const * x0; + BIGNUM const * * x1; + BIGNUM const * * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "RSA_get0_factors", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(967), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RSA const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(967), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2631), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2631), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { RSA_get0_factors(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_RSA_get0_factors _cffi_d_RSA_get0_factors +#endif + +static void _cffi_d_RSA_get0_key(RSA const * x0, BIGNUM const * * x1, BIGNUM const * * x2, BIGNUM const * * x3) +{ + RSA_get0_key(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_get0_key(PyObject *self, PyObject *args) +{ + RSA const * x0; + BIGNUM const * * x1; + BIGNUM const * * x2; + BIGNUM const * * x3; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "RSA_get0_key", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(967), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RSA const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(967), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2631), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2631), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2631), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM const * *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(2631), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { RSA_get0_key(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_RSA_get0_key _cffi_d_RSA_get0_key +#endif + +static RSA * _cffi_d_RSA_new(void) +{ + return RSA_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_new(PyObject *self, PyObject *noarg) +{ + RSA * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RSA_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(476)); +} +#else +# define _cffi_f_RSA_new _cffi_d_RSA_new +#endif + +static int _cffi_d_RSA_print(BIO * x0, RSA const * x1, int x2) +{ + return RSA_print(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_print(PyObject *self, PyObject *args) +{ + BIO * x0; + RSA const * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "RSA_print", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(967), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (RSA const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(967), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RSA_print(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_RSA_print _cffi_d_RSA_print +#endif + +static int _cffi_d_RSA_set0_crt_params(RSA * x0, BIGNUM * x1, BIGNUM * x2, BIGNUM * x3) +{ + return RSA_set0_crt_params(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_set0_crt_params(PyObject *self, PyObject *args) +{ + RSA * x0; + BIGNUM * x1; + BIGNUM * x2; + BIGNUM * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "RSA_set0_crt_params", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(476), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(20), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(20), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RSA_set0_crt_params(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_RSA_set0_crt_params _cffi_d_RSA_set0_crt_params +#endif + +static int _cffi_d_RSA_set0_factors(RSA * x0, BIGNUM * x1, BIGNUM * x2) +{ + return RSA_set0_factors(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_set0_factors(PyObject *self, PyObject *args) +{ + RSA * x0; + BIGNUM * x1; + BIGNUM * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "RSA_set0_factors", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(476), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(20), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RSA_set0_factors(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_RSA_set0_factors _cffi_d_RSA_set0_factors +#endif + +static int _cffi_d_RSA_set0_key(RSA * x0, BIGNUM * x1, BIGNUM * x2, BIGNUM * x3) +{ + return RSA_set0_key(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_RSA_set0_key(PyObject *self, PyObject *args) +{ + RSA * x0; + BIGNUM * x1; + BIGNUM * x2; + BIGNUM * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "RSA_set0_key", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (RSA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(476), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(20), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(20), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(20), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (BIGNUM *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(20), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = RSA_set0_key(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_RSA_set0_key _cffi_d_RSA_set0_key +#endif + +static void _cffi_d_SCT_LIST_free(Cryptography_STACK_OF_SCT * x0) +{ + SCT_LIST_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_LIST_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_SCT * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1101), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_SCT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1101), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SCT_LIST_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SCT_LIST_free _cffi_d_SCT_LIST_free +#endif + +static size_t _cffi_d_SCT_get0_log_id(SCT const * x0, unsigned char * * x1) +{ + return SCT_get0_log_id(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_get0_log_id(PyObject *self, PyObject *args) +{ + SCT const * x0; + unsigned char * * x1; + Py_ssize_t datasize; + size_t result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SCT_get0_log_id", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(747), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SCT const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(747), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(802), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SCT_get0_log_id(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, size_t); +} +#else +# define _cffi_f_SCT_get0_log_id _cffi_d_SCT_get0_log_id +#endif + +static size_t _cffi_d_SCT_get0_signature(SCT const * x0, unsigned char * * x1) +{ + return SCT_get0_signature(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_get0_signature(PyObject *self, PyObject *args) +{ + SCT const * x0; + unsigned char * * x1; + Py_ssize_t datasize; + size_t result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SCT_get0_signature", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(747), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SCT const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(747), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(802), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SCT_get0_signature(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, size_t); +} +#else +# define _cffi_f_SCT_get0_signature _cffi_d_SCT_get0_signature +#endif + +static ct_log_entry_type_t _cffi_d_SCT_get_log_entry_type(SCT const * x0) +{ + return SCT_get_log_entry_type(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_get_log_entry_type(PyObject *self, PyObject *arg0) +{ + SCT const * x0; + Py_ssize_t datasize; + ct_log_entry_type_t result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(747), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SCT const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(747), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SCT_get_log_entry_type(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_deref((char *)&result, _cffi_type(1646)); +} +#else +# define _cffi_f_SCT_get_log_entry_type _cffi_d_SCT_get_log_entry_type +#endif + +static uint64_t _cffi_d_SCT_get_timestamp(SCT const * x0) +{ + return SCT_get_timestamp(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_get_timestamp(PyObject *self, PyObject *arg0) +{ + SCT const * x0; + Py_ssize_t datasize; + uint64_t result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(747), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SCT const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(747), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SCT_get_timestamp(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, uint64_t); +} +#else +# define _cffi_f_SCT_get_timestamp _cffi_d_SCT_get_timestamp +#endif + +static sct_version_t _cffi_d_SCT_get_version(SCT const * x0) +{ + return SCT_get_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_get_version(PyObject *self, PyObject *arg0) +{ + SCT const * x0; + Py_ssize_t datasize; + sct_version_t result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(747), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SCT const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(747), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SCT_get_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_deref((char *)&result, _cffi_type(1654)); +} +#else +# define _cffi_f_SCT_get_version _cffi_d_SCT_get_version +#endif + +static SCT * _cffi_d_SCT_new(void) +{ + return SCT_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_new(PyObject *self, PyObject *noarg) +{ + SCT * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SCT_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1102)); +} +#else +# define _cffi_f_SCT_new _cffi_d_SCT_new +#endif + +static int _cffi_d_SCT_set1_log_id(SCT * x0, unsigned char * x1, size_t x2) +{ + return SCT_set1_log_id(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_set1_log_id(PyObject *self, PyObject *args) +{ + SCT * x0; + unsigned char * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SCT_set1_log_id", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1102), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SCT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1102), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SCT_set1_log_id(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SCT_set1_log_id _cffi_d_SCT_set1_log_id +#endif + +static int _cffi_d_SCT_set_log_entry_type(SCT * x0, ct_log_entry_type_t x1) +{ + return SCT_set_log_entry_type(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_set_log_entry_type(PyObject *self, PyObject *args) +{ + SCT * x0; + ct_log_entry_type_t x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SCT_set_log_entry_type", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1102), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SCT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1102), arg0) < 0) + return NULL; + } + + if (_cffi_to_c((char *)&x1, _cffi_type(1646), arg1) < 0) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SCT_set_log_entry_type(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SCT_set_log_entry_type _cffi_d_SCT_set_log_entry_type +#endif + +static int _cffi_d_SCT_set_source(SCT * x0, sct_source_t x1) +{ + return SCT_set_source(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_set_source(PyObject *self, PyObject *args) +{ + SCT * x0; + sct_source_t x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SCT_set_source", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1102), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SCT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1102), arg0) < 0) + return NULL; + } + + if (_cffi_to_c((char *)&x1, _cffi_type(1650), arg1) < 0) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SCT_set_source(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SCT_set_source _cffi_d_SCT_set_source +#endif + +static void _cffi_d_SCT_set_timestamp(SCT * x0, uint64_t x1) +{ + SCT_set_timestamp(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_set_timestamp(PyObject *self, PyObject *args) +{ + SCT * x0; + uint64_t x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SCT_set_timestamp", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1102), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SCT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1102), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, uint64_t); + if (x1 == (uint64_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SCT_set_timestamp(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SCT_set_timestamp _cffi_d_SCT_set_timestamp +#endif + +static int _cffi_d_SCT_set_version(SCT * x0, sct_version_t x1) +{ + return SCT_set_version(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SCT_set_version(PyObject *self, PyObject *args) +{ + SCT * x0; + sct_version_t x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SCT_set_version", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1102), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SCT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1102), arg0) < 0) + return NULL; + } + + if (_cffi_to_c((char *)&x1, _cffi_type(1654), arg1) < 0) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SCT_set_version(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SCT_set_version _cffi_d_SCT_set_version +#endif + +static PKCS7 * _cffi_d_SMIME_read_PKCS7(BIO * x0, BIO * * x1) +{ + return SMIME_read_PKCS7(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SMIME_read_PKCS7(PyObject *self, PyObject *args) +{ + BIO * x0; + BIO * * x1; + Py_ssize_t datasize; + PKCS7 * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SMIME_read_PKCS7", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(422), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIO * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(422), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SMIME_read_PKCS7(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(442)); +} +#else +# define _cffi_f_SMIME_read_PKCS7 _cffi_d_SMIME_read_PKCS7 +#endif + +static int _cffi_d_SMIME_write_PKCS7(BIO * x0, PKCS7 * x1, BIO * x2, int x3) +{ + return SMIME_write_PKCS7(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SMIME_write_PKCS7(PyObject *self, PyObject *args) +{ + BIO * x0; + PKCS7 * x1; + BIO * x2; + int x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "SMIME_write_PKCS7", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(442), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIO *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(186), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SMIME_write_PKCS7(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SMIME_write_PKCS7 _cffi_d_SMIME_write_PKCS7 +#endif + +static int _cffi_d_SSL_CIPHER_get_auth_nid(SSL_CIPHER const * x0) +{ + return SSL_CIPHER_get_auth_nid(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CIPHER_get_auth_nid(PyObject *self, PyObject *arg0) +{ + SSL_CIPHER const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(733), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CIPHER const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(733), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CIPHER_get_auth_nid(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CIPHER_get_auth_nid _cffi_d_SSL_CIPHER_get_auth_nid +#endif + +static int _cffi_d_SSL_CIPHER_get_bits(SSL_CIPHER const * x0, int * x1) +{ + return SSL_CIPHER_get_bits(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CIPHER_get_bits(PyObject *self, PyObject *args) +{ + SSL_CIPHER const * x0; + int * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CIPHER_get_bits", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(733), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CIPHER const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(733), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (int *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1169), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CIPHER_get_bits(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CIPHER_get_bits _cffi_d_SSL_CIPHER_get_bits +#endif + +static int _cffi_d_SSL_CIPHER_get_cipher_nid(SSL_CIPHER const * x0) +{ + return SSL_CIPHER_get_cipher_nid(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CIPHER_get_cipher_nid(PyObject *self, PyObject *arg0) +{ + SSL_CIPHER const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(733), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CIPHER const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(733), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CIPHER_get_cipher_nid(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CIPHER_get_cipher_nid _cffi_d_SSL_CIPHER_get_cipher_nid +#endif + +static int _cffi_d_SSL_CIPHER_get_digest_nid(SSL_CIPHER const * x0) +{ + return SSL_CIPHER_get_digest_nid(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CIPHER_get_digest_nid(PyObject *self, PyObject *arg0) +{ + SSL_CIPHER const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(733), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CIPHER const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(733), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CIPHER_get_digest_nid(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CIPHER_get_digest_nid _cffi_d_SSL_CIPHER_get_digest_nid +#endif + +static uint64_t _cffi_d_SSL_CIPHER_get_id(SSL_CIPHER const * x0) +{ + return SSL_CIPHER_get_id(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CIPHER_get_id(PyObject *self, PyObject *arg0) +{ + SSL_CIPHER const * x0; + Py_ssize_t datasize; + uint64_t result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(733), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CIPHER const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(733), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CIPHER_get_id(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, uint64_t); +} +#else +# define _cffi_f_SSL_CIPHER_get_id _cffi_d_SSL_CIPHER_get_id +#endif + +static int _cffi_d_SSL_CIPHER_get_kx_nid(SSL_CIPHER const * x0) +{ + return SSL_CIPHER_get_kx_nid(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CIPHER_get_kx_nid(PyObject *self, PyObject *arg0) +{ + SSL_CIPHER const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(733), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CIPHER const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(733), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CIPHER_get_kx_nid(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CIPHER_get_kx_nid _cffi_d_SSL_CIPHER_get_kx_nid +#endif + +static char const * _cffi_d_SSL_CIPHER_get_name(SSL_CIPHER const * x0) +{ + return SSL_CIPHER_get_name(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CIPHER_get_name(PyObject *self, PyObject *arg0) +{ + SSL_CIPHER const * x0; + Py_ssize_t datasize; + char const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(733), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CIPHER const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(733), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CIPHER_get_name(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_SSL_CIPHER_get_name _cffi_d_SSL_CIPHER_get_name +#endif + +static char const * _cffi_d_SSL_CIPHER_get_version(SSL_CIPHER const * x0) +{ + return SSL_CIPHER_get_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CIPHER_get_version(PyObject *self, PyObject *arg0) +{ + SSL_CIPHER const * x0; + Py_ssize_t datasize; + char const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(733), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CIPHER const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(733), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CIPHER_get_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_SSL_CIPHER_get_version _cffi_d_SSL_CIPHER_get_version +#endif + +static int _cffi_d_SSL_CIPHER_is_aead(SSL_CIPHER const * x0) +{ + return SSL_CIPHER_is_aead(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CIPHER_is_aead(PyObject *self, PyObject *arg0) +{ + SSL_CIPHER const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(733), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CIPHER const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(733), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CIPHER_is_aead(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CIPHER_is_aead _cffi_d_SSL_CIPHER_is_aead +#endif + +static int _cffi_d_SSL_CTX_add_client_CA(SSL_CTX * x0, X509 * x1) +{ + return SSL_CTX_add_client_CA(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_add_client_CA(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + X509 * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_add_client_CA", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_add_client_CA(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_add_client_CA _cffi_d_SSL_CTX_add_client_CA +#endif + +static int _cffi_d_SSL_CTX_add_client_custom_ext(SSL_CTX * x0, unsigned int x1, int(* x2)(SSL *, unsigned int, unsigned char const * *, size_t *, int *, void *), void(* x3)(SSL *, unsigned int, unsigned char const *, void *), void * x4, int(* x5)(SSL *, unsigned int, unsigned char const *, size_t, int *, void *), void * x6) +{ + return SSL_CTX_add_client_custom_ext(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_add_client_custom_ext(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + unsigned int x1; + int(* x2)(SSL *, unsigned int, unsigned char const * *, size_t *, int *, void *); + void(* x3)(SSL *, unsigned int, unsigned char const *, void *); + void * x4; + int(* x5)(SSL *, unsigned int, unsigned char const *, size_t, int *, void *); + void * x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_add_client_custom_ext", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned int); + if (x1 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + x2 = (int(*)(SSL *, unsigned int, unsigned char const * *, size_t *, int *, void *))_cffi_to_c_pointer(arg2, _cffi_type(1821)); + if (x2 == (int(*)(SSL *, unsigned int, unsigned char const * *, size_t *, int *, void *))NULL && PyErr_Occurred()) + return NULL; + + x3 = (void(*)(SSL *, unsigned int, unsigned char const *, void *))_cffi_to_c_pointer(arg3, _cffi_type(1822)); + if (x3 == (void(*)(SSL *, unsigned int, unsigned char const *, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (void *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(193), arg4) < 0) + return NULL; + } + + x5 = (int(*)(SSL *, unsigned int, unsigned char const *, size_t, int *, void *))_cffi_to_c_pointer(arg5, _cffi_type(1824)); + if (x5 == (int(*)(SSL *, unsigned int, unsigned char const *, size_t, int *, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg6, (char **)&x6); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x6 = (void *)alloca((size_t)datasize); + memset((void *)x6, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x6, _cffi_type(193), arg6) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_add_client_custom_ext(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_add_client_custom_ext _cffi_d_SSL_CTX_add_client_custom_ext +#endif + +static unsigned long _cffi_d_SSL_CTX_add_extra_chain_cert(SSL_CTX * x0, X509 * x1) +{ + return SSL_CTX_add_extra_chain_cert(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_add_extra_chain_cert(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + X509 * x1; + Py_ssize_t datasize; + unsigned long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_add_extra_chain_cert", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_add_extra_chain_cert(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_CTX_add_extra_chain_cert _cffi_d_SSL_CTX_add_extra_chain_cert +#endif + +static int _cffi_d_SSL_CTX_add_server_custom_ext(SSL_CTX * x0, unsigned int x1, int(* x2)(SSL *, unsigned int, unsigned char const * *, size_t *, int *, void *), void(* x3)(SSL *, unsigned int, unsigned char const *, void *), void * x4, int(* x5)(SSL *, unsigned int, unsigned char const *, size_t, int *, void *), void * x6) +{ + return SSL_CTX_add_server_custom_ext(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_add_server_custom_ext(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + unsigned int x1; + int(* x2)(SSL *, unsigned int, unsigned char const * *, size_t *, int *, void *); + void(* x3)(SSL *, unsigned int, unsigned char const *, void *); + void * x4; + int(* x5)(SSL *, unsigned int, unsigned char const *, size_t, int *, void *); + void * x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_add_server_custom_ext", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned int); + if (x1 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + x2 = (int(*)(SSL *, unsigned int, unsigned char const * *, size_t *, int *, void *))_cffi_to_c_pointer(arg2, _cffi_type(1821)); + if (x2 == (int(*)(SSL *, unsigned int, unsigned char const * *, size_t *, int *, void *))NULL && PyErr_Occurred()) + return NULL; + + x3 = (void(*)(SSL *, unsigned int, unsigned char const *, void *))_cffi_to_c_pointer(arg3, _cffi_type(1822)); + if (x3 == (void(*)(SSL *, unsigned int, unsigned char const *, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (void *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(193), arg4) < 0) + return NULL; + } + + x5 = (int(*)(SSL *, unsigned int, unsigned char const *, size_t, int *, void *))_cffi_to_c_pointer(arg5, _cffi_type(1824)); + if (x5 == (int(*)(SSL *, unsigned int, unsigned char const *, size_t, int *, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg6, (char **)&x6); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x6 = (void *)alloca((size_t)datasize); + memset((void *)x6, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x6, _cffi_type(193), arg6) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_add_server_custom_ext(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_add_server_custom_ext _cffi_d_SSL_CTX_add_server_custom_ext +#endif + +static int _cffi_d_SSL_CTX_check_private_key(SSL_CTX const * x0) +{ + return SSL_CTX_check_private_key(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_check_private_key(PyObject *self, PyObject *arg0) +{ + SSL_CTX const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(691), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(691), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_check_private_key(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_check_private_key _cffi_d_SSL_CTX_check_private_key +#endif + +static unsigned long _cffi_d_SSL_CTX_clear_mode(SSL_CTX * x0, unsigned long x1) +{ + return SSL_CTX_clear_mode(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_clear_mode(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + unsigned long x1; + Py_ssize_t datasize; + unsigned long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_clear_mode", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_clear_mode(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_CTX_clear_mode _cffi_d_SSL_CTX_clear_mode +#endif + +static unsigned long _cffi_d_SSL_CTX_clear_options(SSL_CTX * x0, unsigned long x1) +{ + return SSL_CTX_clear_options(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_clear_options(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + unsigned long x1; + Py_ssize_t datasize; + unsigned long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_clear_options", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_clear_options(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_CTX_clear_options _cffi_d_SSL_CTX_clear_options +#endif + +static void _cffi_d_SSL_CTX_free(SSL_CTX * x0) +{ + SSL_CTX_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_free(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_free _cffi_d_SSL_CTX_free +#endif + +static X509_VERIFY_PARAM * _cffi_d_SSL_CTX_get0_param(SSL_CTX * x0) +{ + return SSL_CTX_get0_param(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get0_param(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + X509_VERIFY_PARAM * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get0_param(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2085)); +} +#else +# define _cffi_f_SSL_CTX_get0_param _cffi_d_SSL_CTX_get0_param +#endif + +static X509_STORE * _cffi_d_SSL_CTX_get_cert_store(SSL_CTX const * x0) +{ + return SSL_CTX_get_cert_store(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_cert_store(PyObject *self, PyObject *arg0) +{ + SSL_CTX const * x0; + Py_ssize_t datasize; + X509_STORE * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(691), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(691), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_cert_store(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(180)); +} +#else +# define _cffi_f_SSL_CTX_get_cert_store _cffi_d_SSL_CTX_get_cert_store +#endif + +static void * _cffi_d_SSL_CTX_get_ex_data(SSL_CTX const * x0, int x1) +{ + return SSL_CTX_get_ex_data(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_ex_data(PyObject *self, PyObject *args) +{ + SSL_CTX const * x0; + int x1; + Py_ssize_t datasize; + void * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_get_ex_data", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(691), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(691), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_ex_data(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(193)); +} +#else +# define _cffi_f_SSL_CTX_get_ex_data _cffi_d_SSL_CTX_get_ex_data +#endif + +static int _cffi_d_SSL_CTX_get_ex_new_index(long x0, void * x1, CRYPTO_EX_new * x2, CRYPTO_EX_dup * x3, CRYPTO_EX_free * x4) +{ + return SSL_CTX_get_ex_new_index(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_ex_new_index(PyObject *self, PyObject *args) +{ + long x0; + void * x1; + CRYPTO_EX_new * x2; + CRYPTO_EX_dup * x3; + CRYPTO_EX_free * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_get_ex_new_index", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + x0 = _cffi_to_c_int(arg0, long); + if (x0 == (long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2237), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (CRYPTO_EX_new *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2237), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2238), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (CRYPTO_EX_dup *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(2238), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2239), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (CRYPTO_EX_free *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(2239), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_ex_new_index(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_get_ex_new_index _cffi_d_SSL_CTX_get_ex_new_index +#endif + +static void(* _cffi_d_SSL_CTX_get_info_callback(SSL_CTX * x0))(SSL const *, int, int) +{ + return SSL_CTX_get_info_callback(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_info_callback(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + void(* result)(SSL const *, int, int); + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_info_callback(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2867)); +} +#else +# define _cffi_f_SSL_CTX_get_info_callback _cffi_d_SSL_CTX_get_info_callback +#endif + +static void(* _cffi_d_SSL_CTX_get_keylog_callback(SSL_CTX * x0))(SSL const *, char const *) +{ + return SSL_CTX_get_keylog_callback(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_keylog_callback(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + void(* result)(SSL const *, char const *); + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_keylog_callback(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2863)); +} +#else +# define _cffi_f_SSL_CTX_get_keylog_callback _cffi_d_SSL_CTX_get_keylog_callback +#endif + +static long _cffi_d_SSL_CTX_get_max_proto_version(SSL_CTX * x0) +{ + return SSL_CTX_get_max_proto_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_max_proto_version(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_max_proto_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_get_max_proto_version _cffi_d_SSL_CTX_get_max_proto_version +#endif + +static long _cffi_d_SSL_CTX_get_min_proto_version(SSL_CTX * x0) +{ + return SSL_CTX_get_min_proto_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_min_proto_version(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_min_proto_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_get_min_proto_version _cffi_d_SSL_CTX_get_min_proto_version +#endif + +static unsigned long _cffi_d_SSL_CTX_get_mode(SSL_CTX * x0) +{ + return SSL_CTX_get_mode(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_mode(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + unsigned long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_mode(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_CTX_get_mode _cffi_d_SSL_CTX_get_mode +#endif + +static unsigned long _cffi_d_SSL_CTX_get_options(SSL_CTX * x0) +{ + return SSL_CTX_get_options(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_options(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + unsigned long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_options(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_CTX_get_options _cffi_d_SSL_CTX_get_options +#endif + +static long _cffi_d_SSL_CTX_get_read_ahead(SSL_CTX * x0) +{ + return SSL_CTX_get_read_ahead(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_read_ahead(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_read_ahead(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_get_read_ahead _cffi_d_SSL_CTX_get_read_ahead +#endif + +static unsigned long _cffi_d_SSL_CTX_get_session_cache_mode(SSL_CTX * x0) +{ + return SSL_CTX_get_session_cache_mode(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_session_cache_mode(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + unsigned long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_session_cache_mode(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_CTX_get_session_cache_mode _cffi_d_SSL_CTX_get_session_cache_mode +#endif + +static long _cffi_d_SSL_CTX_get_timeout(SSL_CTX const * x0) +{ + return SSL_CTX_get_timeout(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_timeout(PyObject *self, PyObject *arg0) +{ + SSL_CTX const * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(691), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(691), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_timeout(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_get_timeout _cffi_d_SSL_CTX_get_timeout +#endif + +static int _cffi_d_SSL_CTX_get_verify_depth(SSL_CTX const * x0) +{ + return SSL_CTX_get_verify_depth(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_verify_depth(PyObject *self, PyObject *arg0) +{ + SSL_CTX const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(691), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(691), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_verify_depth(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_get_verify_depth _cffi_d_SSL_CTX_get_verify_depth +#endif + +static int _cffi_d_SSL_CTX_get_verify_mode(SSL_CTX const * x0) +{ + return SSL_CTX_get_verify_mode(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_get_verify_mode(PyObject *self, PyObject *arg0) +{ + SSL_CTX const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(691), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(691), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_get_verify_mode(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_get_verify_mode _cffi_d_SSL_CTX_get_verify_mode +#endif + +static int _cffi_d_SSL_CTX_load_verify_locations(SSL_CTX * x0, char const * x1, char const * x2) +{ + return SSL_CTX_load_verify_locations(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_load_verify_locations(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + char const * x1; + char const * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_load_verify_locations", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (char const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(46), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_load_verify_locations(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_load_verify_locations _cffi_d_SSL_CTX_load_verify_locations +#endif + +static SSL_CTX * _cffi_d_SSL_CTX_new(SSL_METHOD * x0) +{ + return SSL_CTX_new(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_new(PyObject *self, PyObject *arg0) +{ + SSL_METHOD * x0; + Py_ssize_t datasize; + SSL_CTX * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(504), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_METHOD *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(504), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_new(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(490)); +} +#else +# define _cffi_f_SSL_CTX_new _cffi_d_SSL_CTX_new +#endif + +static long _cffi_d_SSL_CTX_sess_accept(SSL_CTX * x0) +{ + return SSL_CTX_sess_accept(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_accept(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_accept(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_accept _cffi_d_SSL_CTX_sess_accept +#endif + +static long _cffi_d_SSL_CTX_sess_accept_good(SSL_CTX * x0) +{ + return SSL_CTX_sess_accept_good(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_accept_good(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_accept_good(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_accept_good _cffi_d_SSL_CTX_sess_accept_good +#endif + +static long _cffi_d_SSL_CTX_sess_accept_renegotiate(SSL_CTX * x0) +{ + return SSL_CTX_sess_accept_renegotiate(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_accept_renegotiate(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_accept_renegotiate(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_accept_renegotiate _cffi_d_SSL_CTX_sess_accept_renegotiate +#endif + +static long _cffi_d_SSL_CTX_sess_cache_full(SSL_CTX * x0) +{ + return SSL_CTX_sess_cache_full(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_cache_full(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_cache_full(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_cache_full _cffi_d_SSL_CTX_sess_cache_full +#endif + +static long _cffi_d_SSL_CTX_sess_cb_hits(SSL_CTX * x0) +{ + return SSL_CTX_sess_cb_hits(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_cb_hits(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_cb_hits(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_cb_hits _cffi_d_SSL_CTX_sess_cb_hits +#endif + +static long _cffi_d_SSL_CTX_sess_connect(SSL_CTX * x0) +{ + return SSL_CTX_sess_connect(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_connect(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_connect(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_connect _cffi_d_SSL_CTX_sess_connect +#endif + +static long _cffi_d_SSL_CTX_sess_connect_good(SSL_CTX * x0) +{ + return SSL_CTX_sess_connect_good(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_connect_good(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_connect_good(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_connect_good _cffi_d_SSL_CTX_sess_connect_good +#endif + +static long _cffi_d_SSL_CTX_sess_connect_renegotiate(SSL_CTX * x0) +{ + return SSL_CTX_sess_connect_renegotiate(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_connect_renegotiate(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_connect_renegotiate(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_connect_renegotiate _cffi_d_SSL_CTX_sess_connect_renegotiate +#endif + +static long _cffi_d_SSL_CTX_sess_hits(SSL_CTX * x0) +{ + return SSL_CTX_sess_hits(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_hits(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_hits(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_hits _cffi_d_SSL_CTX_sess_hits +#endif + +static long _cffi_d_SSL_CTX_sess_misses(SSL_CTX * x0) +{ + return SSL_CTX_sess_misses(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_misses(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_misses(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_misses _cffi_d_SSL_CTX_sess_misses +#endif + +static long _cffi_d_SSL_CTX_sess_number(SSL_CTX * x0) +{ + return SSL_CTX_sess_number(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_number(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_number(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_number _cffi_d_SSL_CTX_sess_number +#endif + +static long _cffi_d_SSL_CTX_sess_timeouts(SSL_CTX * x0) +{ + return SSL_CTX_sess_timeouts(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_sess_timeouts(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_sess_timeouts(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_sess_timeouts _cffi_d_SSL_CTX_sess_timeouts +#endif + +static long _cffi_d_SSL_CTX_set1_sigalgs_list(SSL_CTX * x0, char const * x1) +{ + return SSL_CTX_set1_sigalgs_list(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set1_sigalgs_list(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + char const * x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set1_sigalgs_list", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set1_sigalgs_list(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_set1_sigalgs_list _cffi_d_SSL_CTX_set1_sigalgs_list +#endif + +static int _cffi_d_SSL_CTX_set_alpn_protos(SSL_CTX * x0, unsigned char const * x1, unsigned int x2) +{ + return SSL_CTX_set_alpn_protos(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_alpn_protos(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + unsigned char const * x1; + unsigned int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_alpn_protos", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, unsigned int); + if (x2 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_alpn_protos(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_set_alpn_protos _cffi_d_SSL_CTX_set_alpn_protos +#endif + +static void _cffi_d_SSL_CTX_set_alpn_select_cb(SSL_CTX * x0, int(* x1)(SSL *, unsigned char const * *, unsigned char *, unsigned char const *, unsigned int, void *), void * x2) +{ + SSL_CTX_set_alpn_select_cb(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_alpn_select_cb(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int(* x1)(SSL *, unsigned char const * *, unsigned char *, unsigned char const *, unsigned int, void *); + void * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_alpn_select_cb", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = (int(*)(SSL *, unsigned char const * *, unsigned char *, unsigned char const *, unsigned int, void *))_cffi_to_c_pointer(arg1, _cffi_type(2823)); + if (x1 == (int(*)(SSL *, unsigned char const * *, unsigned char *, unsigned char const *, unsigned int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (void *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(193), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_alpn_select_cb(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_alpn_select_cb _cffi_d_SSL_CTX_set_alpn_select_cb +#endif + +static void _cffi_d_SSL_CTX_set_cert_cb(SSL_CTX * x0, int(* x1)(SSL *, void *), void * x2) +{ + SSL_CTX_set_cert_cb(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_cert_cb(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int(* x1)(SSL *, void *); + void * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_cert_cb", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = (int(*)(SSL *, void *))_cffi_to_c_pointer(arg1, _cffi_type(2337)); + if (x1 == (int(*)(SSL *, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (void *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(193), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_cert_cb(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_cert_cb _cffi_d_SSL_CTX_set_cert_cb +#endif + +static void _cffi_d_SSL_CTX_set_cert_store(SSL_CTX * x0, X509_STORE * x1) +{ + SSL_CTX_set_cert_store(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_cert_store(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + X509_STORE * x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_cert_store", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(180), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_cert_store(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_cert_store _cffi_d_SSL_CTX_set_cert_store +#endif + +static void _cffi_d_SSL_CTX_set_cert_verify_callback(SSL_CTX * x0, int(* x1)(X509_STORE_CTX *, void *), void * x2) +{ + SSL_CTX_set_cert_verify_callback(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_cert_verify_callback(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int(* x1)(X509_STORE_CTX *, void *); + void * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_cert_verify_callback", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = (int(*)(X509_STORE_CTX *, void *))_cffi_to_c_pointer(arg1, _cffi_type(2833)); + if (x1 == (int(*)(X509_STORE_CTX *, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (void *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(193), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_cert_verify_callback(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_cert_verify_callback _cffi_d_SSL_CTX_set_cert_verify_callback +#endif + +static int _cffi_d_SSL_CTX_set_cipher_list(SSL_CTX * x0, char const * x1) +{ + return SSL_CTX_set_cipher_list(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_cipher_list(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + char const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_cipher_list", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_cipher_list(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_set_cipher_list _cffi_d_SSL_CTX_set_cipher_list +#endif + +static int _cffi_d_SSL_CTX_set_ciphersuites(SSL_CTX * x0, char const * x1) +{ + return SSL_CTX_set_ciphersuites(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_ciphersuites(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + char const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_ciphersuites", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_ciphersuites(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_set_ciphersuites _cffi_d_SSL_CTX_set_ciphersuites +#endif + +static void _cffi_d_SSL_CTX_set_client_CA_list(SSL_CTX * x0, Cryptography_STACK_OF_X509_NAME * x1) +{ + SSL_CTX_set_client_CA_list(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_client_CA_list(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + Cryptography_STACK_OF_X509_NAME * x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_client_CA_list", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(633), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (Cryptography_STACK_OF_X509_NAME *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(633), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_client_CA_list(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_client_CA_list _cffi_d_SSL_CTX_set_client_CA_list +#endif + +static void _cffi_d_SSL_CTX_set_cookie_generate_cb(SSL_CTX * x0, int(* x1)(SSL *, unsigned char *, unsigned int *)) +{ + SSL_CTX_set_cookie_generate_cb(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_cookie_generate_cb(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int(* x1)(SSL *, unsigned char *, unsigned int *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_cookie_generate_cb", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = (int(*)(SSL *, unsigned char *, unsigned int *))_cffi_to_c_pointer(arg1, _cffi_type(2819)); + if (x1 == (int(*)(SSL *, unsigned char *, unsigned int *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_cookie_generate_cb(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_cookie_generate_cb _cffi_d_SSL_CTX_set_cookie_generate_cb +#endif + +static void _cffi_d_SSL_CTX_set_default_passwd_cb(SSL_CTX * x0, int(* x1)(char *, int, int, void *)) +{ + SSL_CTX_set_default_passwd_cb(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_default_passwd_cb(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int(* x1)(char *, int, int, void *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_default_passwd_cb", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg1, _cffi_type(192)); + if (x1 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_default_passwd_cb(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_default_passwd_cb _cffi_d_SSL_CTX_set_default_passwd_cb +#endif + +static void _cffi_d_SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX * x0, void * x1) +{ + SSL_CTX_set_default_passwd_cb_userdata(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_default_passwd_cb_userdata(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + void * x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_default_passwd_cb_userdata", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_default_passwd_cb_userdata(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_default_passwd_cb_userdata _cffi_d_SSL_CTX_set_default_passwd_cb_userdata +#endif + +static int _cffi_d_SSL_CTX_set_default_verify_paths(SSL_CTX * x0) +{ + return SSL_CTX_set_default_verify_paths(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_default_verify_paths(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_default_verify_paths(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_set_default_verify_paths _cffi_d_SSL_CTX_set_default_verify_paths +#endif + +static long _cffi_d_SSL_CTX_set_ecdh_auto(SSL_CTX * x0, int x1) +{ + return SSL_CTX_set_ecdh_auto(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_ecdh_auto(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_ecdh_auto", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_ecdh_auto(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_set_ecdh_auto _cffi_d_SSL_CTX_set_ecdh_auto +#endif + +static int _cffi_d_SSL_CTX_set_ex_data(SSL_CTX * x0, int x1, void * x2) +{ + return SSL_CTX_set_ex_data(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_ex_data(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int x1; + void * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_ex_data", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (void *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(193), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_ex_data(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_set_ex_data _cffi_d_SSL_CTX_set_ex_data +#endif + +static void _cffi_d_SSL_CTX_set_info_callback(SSL_CTX * x0, void(* x1)(SSL const *, int, int)) +{ + SSL_CTX_set_info_callback(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_info_callback(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + void(* x1)(SSL const *, int, int); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_info_callback", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = (void(*)(SSL const *, int, int))_cffi_to_c_pointer(arg1, _cffi_type(2867)); + if (x1 == (void(*)(SSL const *, int, int))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_info_callback(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_info_callback _cffi_d_SSL_CTX_set_info_callback +#endif + +static void _cffi_d_SSL_CTX_set_keylog_callback(SSL_CTX * x0, void(* x1)(SSL const *, char const *)) +{ + SSL_CTX_set_keylog_callback(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_keylog_callback(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + void(* x1)(SSL const *, char const *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_keylog_callback", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = (void(*)(SSL const *, char const *))_cffi_to_c_pointer(arg1, _cffi_type(2863)); + if (x1 == (void(*)(SSL const *, char const *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_keylog_callback(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_keylog_callback _cffi_d_SSL_CTX_set_keylog_callback +#endif + +static int _cffi_d_SSL_CTX_set_max_early_data(SSL_CTX * x0, uint32_t x1) +{ + return SSL_CTX_set_max_early_data(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_max_early_data(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + uint32_t x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_max_early_data", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, uint32_t); + if (x1 == (uint32_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_max_early_data(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_set_max_early_data _cffi_d_SSL_CTX_set_max_early_data +#endif + +static long _cffi_d_SSL_CTX_set_max_proto_version(SSL_CTX * x0, int x1) +{ + return SSL_CTX_set_max_proto_version(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_max_proto_version(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_max_proto_version", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_max_proto_version(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_set_max_proto_version _cffi_d_SSL_CTX_set_max_proto_version +#endif + +static long _cffi_d_SSL_CTX_set_min_proto_version(SSL_CTX * x0, int x1) +{ + return SSL_CTX_set_min_proto_version(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_min_proto_version(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_min_proto_version", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_min_proto_version(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_set_min_proto_version _cffi_d_SSL_CTX_set_min_proto_version +#endif + +static unsigned long _cffi_d_SSL_CTX_set_mode(SSL_CTX * x0, unsigned long x1) +{ + return SSL_CTX_set_mode(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_mode(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + unsigned long x1; + Py_ssize_t datasize; + unsigned long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_mode", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_mode(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_CTX_set_mode _cffi_d_SSL_CTX_set_mode +#endif + +static unsigned long _cffi_d_SSL_CTX_set_options(SSL_CTX * x0, unsigned long x1) +{ + return SSL_CTX_set_options(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_options(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + unsigned long x1; + Py_ssize_t datasize; + unsigned long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_options", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_options(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_CTX_set_options _cffi_d_SSL_CTX_set_options +#endif + +static void _cffi_d_SSL_CTX_set_post_handshake_auth(SSL_CTX * x0, int x1) +{ + SSL_CTX_set_post_handshake_auth(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_post_handshake_auth(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_post_handshake_auth", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_post_handshake_auth(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_post_handshake_auth _cffi_d_SSL_CTX_set_post_handshake_auth +#endif + +static void _cffi_d_SSL_CTX_set_psk_client_callback(SSL_CTX * x0, unsigned int(* x1)(SSL *, char const *, char *, unsigned int, unsigned char *, unsigned int)) +{ + SSL_CTX_set_psk_client_callback(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_psk_client_callback(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + unsigned int(* x1)(SSL *, char const *, char *, unsigned int, unsigned char *, unsigned int); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_psk_client_callback", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = (unsigned int(*)(SSL *, char const *, char *, unsigned int, unsigned char *, unsigned int))_cffi_to_c_pointer(arg1, _cffi_type(2851)); + if (x1 == (unsigned int(*)(SSL *, char const *, char *, unsigned int, unsigned char *, unsigned int))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_psk_client_callback(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_psk_client_callback _cffi_d_SSL_CTX_set_psk_client_callback +#endif + +static void _cffi_d_SSL_CTX_set_psk_server_callback(SSL_CTX * x0, unsigned int(* x1)(SSL *, char const *, unsigned char *, unsigned int)) +{ + SSL_CTX_set_psk_server_callback(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_psk_server_callback(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + unsigned int(* x1)(SSL *, char const *, unsigned char *, unsigned int); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_psk_server_callback", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = (unsigned int(*)(SSL *, char const *, unsigned char *, unsigned int))_cffi_to_c_pointer(arg1, _cffi_type(2855)); + if (x1 == (unsigned int(*)(SSL *, char const *, unsigned char *, unsigned int))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_psk_server_callback(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_psk_server_callback _cffi_d_SSL_CTX_set_psk_server_callback +#endif + +static long _cffi_d_SSL_CTX_set_read_ahead(SSL_CTX * x0, long x1) +{ + return SSL_CTX_set_read_ahead(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_read_ahead(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + long x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_read_ahead", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_read_ahead(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_set_read_ahead _cffi_d_SSL_CTX_set_read_ahead +#endif + +static unsigned long _cffi_d_SSL_CTX_set_session_cache_mode(SSL_CTX * x0, unsigned long x1) +{ + return SSL_CTX_set_session_cache_mode(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_session_cache_mode(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + unsigned long x1; + Py_ssize_t datasize; + unsigned long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_session_cache_mode", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_session_cache_mode(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_CTX_set_session_cache_mode _cffi_d_SSL_CTX_set_session_cache_mode +#endif + +static int _cffi_d_SSL_CTX_set_session_id_context(SSL_CTX * x0, unsigned char const * x1, unsigned int x2) +{ + return SSL_CTX_set_session_id_context(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_session_id_context(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + unsigned char const * x1; + unsigned int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_session_id_context", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, unsigned int); + if (x2 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_session_id_context(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_set_session_id_context _cffi_d_SSL_CTX_set_session_id_context +#endif + +static long _cffi_d_SSL_CTX_set_timeout(SSL_CTX * x0, long x1) +{ + return SSL_CTX_set_timeout(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_timeout(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + long x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_timeout", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_timeout(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_set_timeout _cffi_d_SSL_CTX_set_timeout +#endif + +static void _cffi_d_SSL_CTX_set_tlsext_servername_arg(SSL_CTX * x0, void * x1) +{ + SSL_CTX_set_tlsext_servername_arg(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_tlsext_servername_arg(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + void * x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_tlsext_servername_arg", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_tlsext_servername_arg(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_tlsext_servername_arg _cffi_d_SSL_CTX_set_tlsext_servername_arg +#endif + +static void _cffi_d_SSL_CTX_set_tlsext_servername_callback(SSL_CTX * x0, int(* x1)(SSL *, int *, void *)) +{ + SSL_CTX_set_tlsext_servername_callback(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_tlsext_servername_callback(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int(* x1)(SSL *, int *, void *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_tlsext_servername_callback", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = (int(*)(SSL *, int *, void *))_cffi_to_c_pointer(arg1, _cffi_type(2815)); + if (x1 == (int(*)(SSL *, int *, void *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_tlsext_servername_callback(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_tlsext_servername_callback _cffi_d_SSL_CTX_set_tlsext_servername_callback +#endif + +static long _cffi_d_SSL_CTX_set_tlsext_status_arg(SSL_CTX * x0, void * x1) +{ + return SSL_CTX_set_tlsext_status_arg(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_tlsext_status_arg(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + void * x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_tlsext_status_arg", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_tlsext_status_arg(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_set_tlsext_status_arg _cffi_d_SSL_CTX_set_tlsext_status_arg +#endif + +static long _cffi_d_SSL_CTX_set_tlsext_status_cb(SSL_CTX * x0, int(* x1)(SSL *, void *)) +{ + return SSL_CTX_set_tlsext_status_cb(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_tlsext_status_cb(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int(* x1)(SSL *, void *); + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_tlsext_status_cb", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = (int(*)(SSL *, void *))_cffi_to_c_pointer(arg1, _cffi_type(2337)); + if (x1 == (int(*)(SSL *, void *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_tlsext_status_cb(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_CTX_set_tlsext_status_cb _cffi_d_SSL_CTX_set_tlsext_status_cb +#endif + +static int _cffi_d_SSL_CTX_set_tlsext_use_srtp(SSL_CTX * x0, char const * x1) +{ + return SSL_CTX_set_tlsext_use_srtp(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_tlsext_use_srtp(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + char const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_tlsext_use_srtp", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_tlsext_use_srtp(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_set_tlsext_use_srtp _cffi_d_SSL_CTX_set_tlsext_use_srtp +#endif + +static unsigned long _cffi_d_SSL_CTX_set_tmp_dh(SSL_CTX * x0, DH * x1) +{ + return SSL_CTX_set_tmp_dh(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_tmp_dh(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + DH * x1; + Py_ssize_t datasize; + unsigned long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_tmp_dh", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DH *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(196), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_tmp_dh(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_CTX_set_tmp_dh _cffi_d_SSL_CTX_set_tmp_dh +#endif + +static unsigned long _cffi_d_SSL_CTX_set_tmp_ecdh(SSL_CTX * x0, EC_KEY * x1) +{ + return SSL_CTX_set_tmp_ecdh(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_tmp_ecdh(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + EC_KEY * x1; + Py_ssize_t datasize; + unsigned long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_tmp_ecdh", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(893), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_set_tmp_ecdh(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_CTX_set_tmp_ecdh _cffi_d_SSL_CTX_set_tmp_ecdh +#endif + +static void _cffi_d_SSL_CTX_set_verify(SSL_CTX * x0, int x1, int(* x2)(int, X509_STORE_CTX *)) +{ + SSL_CTX_set_verify(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_verify(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int x1; + int(* x2)(int, X509_STORE_CTX *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_verify", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = (int(*)(int, X509_STORE_CTX *))_cffi_to_c_pointer(arg2, _cffi_type(2847)); + if (x2 == (int(*)(int, X509_STORE_CTX *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_verify(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_verify _cffi_d_SSL_CTX_set_verify +#endif + +static void _cffi_d_SSL_CTX_set_verify_depth(SSL_CTX * x0, int x1) +{ + SSL_CTX_set_verify_depth(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_set_verify_depth(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + int x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_set_verify_depth", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_CTX_set_verify_depth(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_CTX_set_verify_depth _cffi_d_SSL_CTX_set_verify_depth +#endif + +static int _cffi_d_SSL_CTX_use_PrivateKey(SSL_CTX * x0, EVP_PKEY * x1) +{ + return SSL_CTX_use_PrivateKey(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_use_PrivateKey(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + EVP_PKEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_use_PrivateKey", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_use_PrivateKey(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_use_PrivateKey _cffi_d_SSL_CTX_use_PrivateKey +#endif + +static int _cffi_d_SSL_CTX_use_PrivateKey_file(SSL_CTX * x0, char const * x1, int x2) +{ + return SSL_CTX_use_PrivateKey_file(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_use_PrivateKey_file(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + char const * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_use_PrivateKey_file", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_use_PrivateKey_file(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_use_PrivateKey_file _cffi_d_SSL_CTX_use_PrivateKey_file +#endif + +static int _cffi_d_SSL_CTX_use_certificate(SSL_CTX * x0, X509 * x1) +{ + return SSL_CTX_use_certificate(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_use_certificate(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + X509 * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_use_certificate", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_use_certificate(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_use_certificate _cffi_d_SSL_CTX_use_certificate +#endif + +static int _cffi_d_SSL_CTX_use_certificate_chain_file(SSL_CTX * x0, char const * x1) +{ + return SSL_CTX_use_certificate_chain_file(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_use_certificate_chain_file(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + char const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_use_certificate_chain_file", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_use_certificate_chain_file(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_use_certificate_chain_file _cffi_d_SSL_CTX_use_certificate_chain_file +#endif + +static int _cffi_d_SSL_CTX_use_certificate_file(SSL_CTX * x0, char const * x1, int x2) +{ + return SSL_CTX_use_certificate_file(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_use_certificate_file(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + char const * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_use_certificate_file", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_use_certificate_file(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_use_certificate_file _cffi_d_SSL_CTX_use_certificate_file +#endif + +static int _cffi_d_SSL_CTX_use_psk_identity_hint(SSL_CTX * x0, char const * x1) +{ + return SSL_CTX_use_psk_identity_hint(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_CTX_use_psk_identity_hint(PyObject *self, PyObject *args) +{ + SSL_CTX * x0; + char const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_CTX_use_psk_identity_hint", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_CTX_use_psk_identity_hint(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_CTX_use_psk_identity_hint _cffi_d_SSL_CTX_use_psk_identity_hint +#endif + +static void _cffi_d_SSL_SESSION_free(SSL_SESSION * x0) +{ + SSL_SESSION_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_SESSION_free(PyObject *self, PyObject *arg0) +{ + SSL_SESSION * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1666), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_SESSION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1666), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_SESSION_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_SESSION_free _cffi_d_SSL_SESSION_free +#endif + +static unsigned char const * _cffi_d_SSL_SESSION_get_id(SSL_SESSION const * x0, unsigned int * x1) +{ + return SSL_SESSION_get_id(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_SESSION_get_id(PyObject *self, PyObject *args) +{ + SSL_SESSION const * x0; + unsigned int * x1; + Py_ssize_t datasize; + unsigned char const * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_SESSION_get_id", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1836), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_SESSION const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1836), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1390), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned int *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1390), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_SESSION_get_id(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(103)); +} +#else +# define _cffi_f_SSL_SESSION_get_id _cffi_d_SSL_SESSION_get_id +#endif + +static size_t _cffi_d_SSL_SESSION_get_master_key(SSL_SESSION const * x0, unsigned char * x1, size_t x2) +{ + return SSL_SESSION_get_master_key(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_SESSION_get_master_key(PyObject *self, PyObject *args) +{ + SSL_SESSION const * x0; + unsigned char * x1; + size_t x2; + Py_ssize_t datasize; + size_t result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_SESSION_get_master_key", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1836), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_SESSION const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1836), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_SESSION_get_master_key(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, size_t); +} +#else +# define _cffi_f_SSL_SESSION_get_master_key _cffi_d_SSL_SESSION_get_master_key +#endif + +static uint32_t _cffi_d_SSL_SESSION_get_max_early_data(SSL_SESSION const * x0) +{ + return SSL_SESSION_get_max_early_data(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_SESSION_get_max_early_data(PyObject *self, PyObject *arg0) +{ + SSL_SESSION const * x0; + Py_ssize_t datasize; + uint32_t result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1836), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_SESSION const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1836), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_SESSION_get_max_early_data(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, uint32_t); +} +#else +# define _cffi_f_SSL_SESSION_get_max_early_data _cffi_d_SSL_SESSION_get_max_early_data +#endif + +static long _cffi_d_SSL_SESSION_get_ticket_lifetime_hint(SSL_SESSION const * x0) +{ + return SSL_SESSION_get_ticket_lifetime_hint(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_SESSION_get_ticket_lifetime_hint(PyObject *self, PyObject *arg0) +{ + SSL_SESSION const * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1836), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_SESSION const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1836), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_SESSION_get_ticket_lifetime_hint(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_SESSION_get_ticket_lifetime_hint _cffi_d_SSL_SESSION_get_ticket_lifetime_hint +#endif + +static long _cffi_d_SSL_SESSION_get_time(SSL_SESSION const * x0) +{ + return SSL_SESSION_get_time(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_SESSION_get_time(PyObject *self, PyObject *arg0) +{ + SSL_SESSION const * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1836), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_SESSION const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1836), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_SESSION_get_time(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_SESSION_get_time _cffi_d_SSL_SESSION_get_time +#endif + +static long _cffi_d_SSL_SESSION_get_timeout(SSL_SESSION const * x0) +{ + return SSL_SESSION_get_timeout(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_SESSION_get_timeout(PyObject *self, PyObject *arg0) +{ + SSL_SESSION const * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1836), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_SESSION const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1836), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_SESSION_get_timeout(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_SESSION_get_timeout _cffi_d_SSL_SESSION_get_timeout +#endif + +static int _cffi_d_SSL_SESSION_has_ticket(SSL_SESSION const * x0) +{ + return SSL_SESSION_has_ticket(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_SESSION_has_ticket(PyObject *self, PyObject *arg0) +{ + SSL_SESSION const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1836), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_SESSION const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1836), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_SESSION_has_ticket(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_SESSION_has_ticket _cffi_d_SSL_SESSION_has_ticket +#endif + +static int _cffi_d_SSL_SESSION_set1_id_context(SSL_SESSION * x0, unsigned char const * x1, unsigned int x2) +{ + return SSL_SESSION_set1_id_context(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_SESSION_set1_id_context(PyObject *self, PyObject *args) +{ + SSL_SESSION * x0; + unsigned char const * x1; + unsigned int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_SESSION_set1_id_context", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1666), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_SESSION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1666), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, unsigned int); + if (x2 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_SESSION_set1_id_context(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_SESSION_set1_id_context _cffi_d_SSL_SESSION_set1_id_context +#endif + +static unsigned long _cffi_d_SSL_clear_mode(SSL * x0, unsigned long x1) +{ + return SSL_clear_mode(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_clear_mode(PyObject *self, PyObject *args) +{ + SSL * x0; + unsigned long x1; + Py_ssize_t datasize; + unsigned long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_clear_mode", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_clear_mode(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_clear_mode _cffi_d_SSL_clear_mode +#endif + +static int _cffi_d_SSL_do_handshake(SSL * x0) +{ + return SSL_do_handshake(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_do_handshake(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_do_handshake(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_do_handshake _cffi_d_SSL_do_handshake +#endif + +static int _cffi_d_SSL_export_keying_material(SSL * x0, unsigned char * x1, size_t x2, char const * x3, size_t x4, unsigned char const * x5, size_t x6, int x7) +{ + return SSL_export_keying_material(x0, x1, x2, x3, x4, x5, x6, x7); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_export_keying_material(PyObject *self, PyObject *args) +{ + SSL * x0; + unsigned char * x1; + size_t x2; + char const * x3; + size_t x4; + unsigned char const * x5; + size_t x6; + int x7; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + PyObject *arg7; + + if (!PyArg_UnpackTuple(args, "SSL_export_keying_material", 8, 8, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6, &arg7)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(46), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, size_t); + if (x4 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(103), arg5) < 0) + return NULL; + } + + x6 = _cffi_to_c_int(arg6, size_t); + if (x6 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + x7 = _cffi_to_c_int(arg7, int); + if (x7 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_export_keying_material(x0, x1, x2, x3, x4, x5, x6, x7); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_export_keying_material _cffi_d_SSL_export_keying_material +#endif + +static int _cffi_d_SSL_extension_supported(unsigned int x0) +{ + return SSL_extension_supported(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_extension_supported(PyObject *self, PyObject *arg0) +{ + unsigned int x0; + int result; + + x0 = _cffi_to_c_int(arg0, unsigned int); + if (x0 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_extension_supported(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_extension_supported _cffi_d_SSL_extension_supported +#endif + +static void _cffi_d_SSL_free(SSL * x0) +{ + SSL_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_free(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_free _cffi_d_SSL_free +#endif + +static void _cffi_d_SSL_get0_alpn_selected(SSL const * x0, unsigned char const * * x1, unsigned int * x2) +{ + SSL_get0_alpn_selected(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get0_alpn_selected(PyObject *self, PyObject *args) +{ + SSL const * x0; + unsigned char const * * x1; + unsigned int * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_get0_alpn_selected", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(75), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(75), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1390), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned int *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1390), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_get0_alpn_selected(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_get0_alpn_selected _cffi_d_SSL_get0_alpn_selected +#endif + +static X509_VERIFY_PARAM * _cffi_d_SSL_get0_param(SSL * x0) +{ + return SSL_get0_param(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get0_param(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + X509_VERIFY_PARAM * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get0_param(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2085)); +} +#else +# define _cffi_f_SSL_get0_param _cffi_d_SSL_get0_param +#endif + +static Cryptography_STACK_OF_X509 * _cffi_d_SSL_get0_verified_chain(SSL const * x0) +{ + return SSL_get0_verified_chain(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get0_verified_chain(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + Cryptography_STACK_OF_X509 * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get0_verified_chain(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(413)); +} +#else +# define _cffi_f_SSL_get0_verified_chain _cffi_d_SSL_get0_verified_chain +#endif + +static SSL_SESSION * _cffi_d_SSL_get1_session(SSL * x0) +{ + return SSL_get1_session(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get1_session(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + SSL_SESSION * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get1_session(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1666)); +} +#else +# define _cffi_f_SSL_get1_session _cffi_d_SSL_get1_session +#endif + +static X509 * _cffi_d_SSL_get_certificate(SSL const * x0) +{ + return SSL_get_certificate(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_certificate(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + X509 * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_certificate(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(28)); +} +#else +# define _cffi_f_SSL_get_certificate _cffi_d_SSL_get_certificate +#endif + +static char const * _cffi_d_SSL_get_cipher_list(SSL const * x0, int x1) +{ + return SSL_get_cipher_list(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_cipher_list(PyObject *self, PyObject *args) +{ + SSL const * x0; + int x1; + Py_ssize_t datasize; + char const * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_get_cipher_list", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_cipher_list(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_SSL_get_cipher_list _cffi_d_SSL_get_cipher_list +#endif + +static Cryptography_STACK_OF_X509_NAME * _cffi_d_SSL_get_client_CA_list(SSL const * x0) +{ + return SSL_get_client_CA_list(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_client_CA_list(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + Cryptography_STACK_OF_X509_NAME * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_client_CA_list(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(633)); +} +#else +# define _cffi_f_SSL_get_client_CA_list _cffi_d_SSL_get_client_CA_list +#endif + +static size_t _cffi_d_SSL_get_client_random(SSL const * x0, unsigned char * x1, size_t x2) +{ + return SSL_get_client_random(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_client_random(PyObject *self, PyObject *args) +{ + SSL const * x0; + unsigned char * x1; + size_t x2; + Py_ssize_t datasize; + size_t result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_get_client_random", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_client_random(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, size_t); +} +#else +# define _cffi_f_SSL_get_client_random _cffi_d_SSL_get_client_random +#endif + +static SSL_CIPHER const * _cffi_d_SSL_get_current_cipher(SSL const * x0) +{ + return SSL_get_current_cipher(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_current_cipher(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + SSL_CIPHER const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_current_cipher(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(733)); +} +#else +# define _cffi_f_SSL_get_current_cipher _cffi_d_SSL_get_current_cipher +#endif + +static int _cffi_d_SSL_get_error(SSL const * x0, int x1) +{ + return SSL_get_error(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_error(PyObject *self, PyObject *args) +{ + SSL const * x0; + int x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_get_error", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_error(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_get_error _cffi_d_SSL_get_error +#endif + +static void * _cffi_d_SSL_get_ex_data(SSL const * x0, int x1) +{ + return SSL_get_ex_data(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_ex_data(PyObject *self, PyObject *args) +{ + SSL const * x0; + int x1; + Py_ssize_t datasize; + void * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_get_ex_data", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_ex_data(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(193)); +} +#else +# define _cffi_f_SSL_get_ex_data _cffi_d_SSL_get_ex_data +#endif + +static int _cffi_d_SSL_get_ex_data_X509_STORE_CTX_idx(void) +{ + return SSL_get_ex_data_X509_STORE_CTX_idx(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_ex_data_X509_STORE_CTX_idx(PyObject *self, PyObject *noarg) +{ + int result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_ex_data_X509_STORE_CTX_idx(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_get_ex_data_X509_STORE_CTX_idx _cffi_d_SSL_get_ex_data_X509_STORE_CTX_idx +#endif + +static int _cffi_d_SSL_get_ex_new_index(long x0, void * x1, CRYPTO_EX_new * x2, CRYPTO_EX_dup * x3, CRYPTO_EX_free * x4) +{ + return SSL_get_ex_new_index(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_ex_new_index(PyObject *self, PyObject *args) +{ + long x0; + void * x1; + CRYPTO_EX_new * x2; + CRYPTO_EX_dup * x3; + CRYPTO_EX_free * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "SSL_get_ex_new_index", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + x0 = _cffi_to_c_int(arg0, long); + if (x0 == (long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2237), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (CRYPTO_EX_new *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2237), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2238), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (CRYPTO_EX_dup *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(2238), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2239), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (CRYPTO_EX_free *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(2239), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_ex_new_index(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_get_ex_new_index _cffi_d_SSL_get_ex_new_index +#endif + +static size_t _cffi_d_SSL_get_finished(SSL const * x0, void * x1, size_t x2) +{ + return SSL_get_finished(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_finished(PyObject *self, PyObject *args) +{ + SSL const * x0; + void * x1; + size_t x2; + Py_ssize_t datasize; + size_t result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_get_finished", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_finished(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, size_t); +} +#else +# define _cffi_f_SSL_get_finished _cffi_d_SSL_get_finished +#endif + +static long _cffi_d_SSL_get_max_proto_version(SSL * x0) +{ + return SSL_get_max_proto_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_max_proto_version(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_max_proto_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_get_max_proto_version _cffi_d_SSL_get_max_proto_version +#endif + +static long _cffi_d_SSL_get_min_proto_version(SSL * x0) +{ + return SSL_get_min_proto_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_min_proto_version(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_min_proto_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_get_min_proto_version _cffi_d_SSL_get_min_proto_version +#endif + +static unsigned long _cffi_d_SSL_get_mode(SSL * x0) +{ + return SSL_get_mode(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_mode(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + unsigned long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_mode(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_get_mode _cffi_d_SSL_get_mode +#endif + +static unsigned long _cffi_d_SSL_get_options(SSL * x0) +{ + return SSL_get_options(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_options(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + unsigned long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_options(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_get_options _cffi_d_SSL_get_options +#endif + +static Cryptography_STACK_OF_X509 * _cffi_d_SSL_get_peer_cert_chain(SSL const * x0) +{ + return SSL_get_peer_cert_chain(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_peer_cert_chain(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + Cryptography_STACK_OF_X509 * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_peer_cert_chain(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(413)); +} +#else +# define _cffi_f_SSL_get_peer_cert_chain _cffi_d_SSL_get_peer_cert_chain +#endif + +static X509 * _cffi_d_SSL_get_peer_certificate(SSL const * x0) +{ + return SSL_get_peer_certificate(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_peer_certificate(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + X509 * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_peer_certificate(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(28)); +} +#else +# define _cffi_f_SSL_get_peer_certificate _cffi_d_SSL_get_peer_certificate +#endif + +static size_t _cffi_d_SSL_get_peer_finished(SSL const * x0, void * x1, size_t x2) +{ + return SSL_get_peer_finished(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_peer_finished(PyObject *self, PyObject *args) +{ + SSL const * x0; + void * x1; + size_t x2; + Py_ssize_t datasize; + size_t result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_get_peer_finished", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_peer_finished(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, size_t); +} +#else +# define _cffi_f_SSL_get_peer_finished _cffi_d_SSL_get_peer_finished +#endif + +static long _cffi_d_SSL_get_secure_renegotiation_support(SSL * x0) +{ + return SSL_get_secure_renegotiation_support(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_secure_renegotiation_support(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_secure_renegotiation_support(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_get_secure_renegotiation_support _cffi_d_SSL_get_secure_renegotiation_support +#endif + +static SRTP_PROTECTION_PROFILE * _cffi_d_SSL_get_selected_srtp_profile(SSL * x0) +{ + return SSL_get_selected_srtp_profile(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_selected_srtp_profile(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + SRTP_PROTECTION_PROFILE * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_selected_srtp_profile(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3109)); +} +#else +# define _cffi_f_SSL_get_selected_srtp_profile _cffi_d_SSL_get_selected_srtp_profile +#endif + +static size_t _cffi_d_SSL_get_server_random(SSL const * x0, unsigned char * x1, size_t x2) +{ + return SSL_get_server_random(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_server_random(PyObject *self, PyObject *args) +{ + SSL const * x0; + unsigned char * x1; + size_t x2; + Py_ssize_t datasize; + size_t result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_get_server_random", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_server_random(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, size_t); +} +#else +# define _cffi_f_SSL_get_server_random _cffi_d_SSL_get_server_random +#endif + +static long _cffi_d_SSL_get_server_tmp_key(SSL * x0, EVP_PKEY * * x1) +{ + return SSL_get_server_tmp_key(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_server_tmp_key(PyObject *self, PyObject *args) +{ + SSL * x0; + EVP_PKEY * * x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_get_server_tmp_key", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(273), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(273), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_server_tmp_key(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_get_server_tmp_key _cffi_d_SSL_get_server_tmp_key +#endif + +static char const * _cffi_d_SSL_get_servername(SSL const * x0, int x1) +{ + return SSL_get_servername(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_servername(PyObject *self, PyObject *args) +{ + SSL const * x0; + int x1; + Py_ssize_t datasize; + char const * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_get_servername", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_servername(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_SSL_get_servername _cffi_d_SSL_get_servername +#endif + +static SSL_SESSION * _cffi_d_SSL_get_session(SSL const * x0) +{ + return SSL_get_session(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_session(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + SSL_SESSION * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_session(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1666)); +} +#else +# define _cffi_f_SSL_get_session _cffi_d_SSL_get_session +#endif + +static int _cffi_d_SSL_get_shutdown(SSL const * x0) +{ + return SSL_get_shutdown(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_shutdown(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_shutdown(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_get_shutdown _cffi_d_SSL_get_shutdown +#endif + +static int _cffi_d_SSL_get_sigalgs(SSL * x0, int x1, int * x2, int * x3, int * x4, unsigned char * x5, unsigned char * x6) +{ + return SSL_get_sigalgs(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_sigalgs(PyObject *self, PyObject *args) +{ + SSL * x0; + int x1; + int * x2; + int * x3; + int * x4; + unsigned char * x5; + unsigned char * x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "SSL_get_sigalgs", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (int *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1169), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (int *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(1169), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (int *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(1169), arg4) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg5, (char **)&x5); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x5 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x5, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x5, _cffi_type(752), arg5) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg6, (char **)&x6); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x6 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x6, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x6, _cffi_type(752), arg6) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_sigalgs(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_get_sigalgs _cffi_d_SSL_get_sigalgs +#endif + +static long _cffi_d_SSL_get_tlsext_status_ocsp_resp(SSL * x0, unsigned char const * * x1) +{ + return SSL_get_tlsext_status_ocsp_resp(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_tlsext_status_ocsp_resp(PyObject *self, PyObject *args) +{ + SSL * x0; + unsigned char const * * x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_get_tlsext_status_ocsp_resp", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(75), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(75), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_tlsext_status_ocsp_resp(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_get_tlsext_status_ocsp_resp _cffi_d_SSL_get_tlsext_status_ocsp_resp +#endif + +static long _cffi_d_SSL_get_verify_result(SSL const * x0) +{ + return SSL_get_verify_result(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_verify_result(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_verify_result(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_get_verify_result _cffi_d_SSL_get_verify_result +#endif + +static char const * _cffi_d_SSL_get_version(SSL const * x0) +{ + return SSL_get_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_get_version(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + char const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_get_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_SSL_get_version _cffi_d_SSL_get_version +#endif + +static int _cffi_d_SSL_library_init(void) +{ + return SSL_library_init(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_library_init(PyObject *self, PyObject *noarg) +{ + int result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_library_init(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_library_init _cffi_d_SSL_library_init +#endif + +static Cryptography_STACK_OF_X509_NAME * _cffi_d_SSL_load_client_CA_file(char const * x0) +{ + return SSL_load_client_CA_file(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_load_client_CA_file(PyObject *self, PyObject *arg0) +{ + char const * x0; + Py_ssize_t datasize; + Cryptography_STACK_OF_X509_NAME * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (char const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(46), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_load_client_CA_file(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(633)); +} +#else +# define _cffi_f_SSL_load_client_CA_file _cffi_d_SSL_load_client_CA_file +#endif + +static void _cffi_d_SSL_load_error_strings(void) +{ + SSL_load_error_strings(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_load_error_strings(PyObject *self, PyObject *noarg) +{ + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_load_error_strings(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_load_error_strings _cffi_d_SSL_load_error_strings +#endif + +static SSL * _cffi_d_SSL_new(SSL_CTX * x0) +{ + return SSL_new(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_new(PyObject *self, PyObject *arg0) +{ + SSL_CTX * x0; + Py_ssize_t datasize; + SSL * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(490), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_new(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(487)); +} +#else +# define _cffi_f_SSL_new _cffi_d_SSL_new +#endif + +static int _cffi_d_SSL_peek(SSL * x0, void * x1, int x2) +{ + return SSL_peek(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_peek(PyObject *self, PyObject *args) +{ + SSL * x0; + void * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_peek", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_peek(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_peek _cffi_d_SSL_peek +#endif + +static int _cffi_d_SSL_pending(SSL const * x0) +{ + return SSL_pending(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_pending(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_pending(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_pending _cffi_d_SSL_pending +#endif + +static int _cffi_d_SSL_read(SSL * x0, void * x1, int x2) +{ + return SSL_read(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_read(PyObject *self, PyObject *args) +{ + SSL * x0; + void * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_read", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_read(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_read _cffi_d_SSL_read +#endif + +static int _cffi_d_SSL_read_early_data(SSL * x0, void * x1, size_t x2, size_t * x3) +{ + return SSL_read_early_data(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_read_early_data(PyObject *self, PyObject *args) +{ + SSL * x0; + void * x1; + size_t x2; + size_t * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "SSL_read_early_data", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (size_t *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(1037), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_read_early_data(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_read_early_data _cffi_d_SSL_read_early_data +#endif + +static int _cffi_d_SSL_renegotiate(SSL * x0) +{ + return SSL_renegotiate(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_renegotiate(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_renegotiate(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_renegotiate _cffi_d_SSL_renegotiate +#endif + +static int _cffi_d_SSL_renegotiate_pending(SSL * x0) +{ + return SSL_renegotiate_pending(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_renegotiate_pending(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_renegotiate_pending(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_renegotiate_pending _cffi_d_SSL_renegotiate_pending +#endif + +static int _cffi_d_SSL_select_next_proto(unsigned char * * x0, unsigned char * x1, unsigned char const * x2, unsigned int x3, unsigned char const * x4, unsigned int x5) +{ + return SSL_select_next_proto(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_select_next_proto(PyObject *self, PyObject *args) +{ + unsigned char * * x0; + unsigned char * x1; + unsigned char const * x2; + unsigned int x3; + unsigned char const * x4; + unsigned int x5; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "SSL_select_next_proto", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(802), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(103), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, unsigned int); + if (x3 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(103), arg4) < 0) + return NULL; + } + + x5 = _cffi_to_c_int(arg5, unsigned int); + if (x5 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_select_next_proto(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_select_next_proto _cffi_d_SSL_select_next_proto +#endif + +static long _cffi_d_SSL_session_reused(SSL * x0) +{ + return SSL_session_reused(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_session_reused(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_session_reused(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_session_reused _cffi_d_SSL_session_reused +#endif + +static SSL_CTX * _cffi_d_SSL_set_SSL_CTX(SSL * x0, SSL_CTX * x1) +{ + return SSL_set_SSL_CTX(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_SSL_CTX(PyObject *self, PyObject *args) +{ + SSL * x0; + SSL_CTX * x1; + Py_ssize_t datasize; + SSL_CTX * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_SSL_CTX", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(490), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (SSL_CTX *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(490), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_SSL_CTX(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(490)); +} +#else +# define _cffi_f_SSL_set_SSL_CTX _cffi_d_SSL_set_SSL_CTX +#endif + +static void _cffi_d_SSL_set_accept_state(SSL * x0) +{ + SSL_set_accept_state(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_accept_state(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_set_accept_state(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_set_accept_state _cffi_d_SSL_set_accept_state +#endif + +static int _cffi_d_SSL_set_alpn_protos(SSL * x0, unsigned char const * x1, unsigned int x2) +{ + return SSL_set_alpn_protos(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_alpn_protos(PyObject *self, PyObject *args) +{ + SSL * x0; + unsigned char const * x1; + unsigned int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_set_alpn_protos", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, unsigned int); + if (x2 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_alpn_protos(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_set_alpn_protos _cffi_d_SSL_set_alpn_protos +#endif + +static void _cffi_d_SSL_set_bio(SSL * x0, BIO * x1, BIO * x2) +{ + SSL_set_bio(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_bio(PyObject *self, PyObject *args) +{ + SSL * x0; + BIO * x1; + BIO * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_set_bio", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (BIO *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(186), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (BIO *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(186), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_set_bio(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_set_bio _cffi_d_SSL_set_bio +#endif + +static void _cffi_d_SSL_set_cert_cb(SSL * x0, int(* x1)(SSL *, void *), void * x2) +{ + SSL_set_cert_cb(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_cert_cb(PyObject *self, PyObject *args) +{ + SSL * x0; + int(* x1)(SSL *, void *); + void * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_set_cert_cb", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = (int(*)(SSL *, void *))_cffi_to_c_pointer(arg1, _cffi_type(2337)); + if (x1 == (int(*)(SSL *, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (void *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(193), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_set_cert_cb(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_set_cert_cb _cffi_d_SSL_set_cert_cb +#endif + +static void _cffi_d_SSL_set_connect_state(SSL * x0) +{ + SSL_set_connect_state(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_connect_state(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_set_connect_state(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_set_connect_state _cffi_d_SSL_set_connect_state +#endif + +static int _cffi_d_SSL_set_ex_data(SSL * x0, int x1, void * x2) +{ + return SSL_set_ex_data(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_ex_data(PyObject *self, PyObject *args) +{ + SSL * x0; + int x1; + void * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_set_ex_data", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (void *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(193), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_ex_data(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_set_ex_data _cffi_d_SSL_set_ex_data +#endif + +static int _cffi_d_SSL_set_fd(SSL * x0, int x1) +{ + return SSL_set_fd(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_fd(PyObject *self, PyObject *args) +{ + SSL * x0; + int x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_fd", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_fd(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_set_fd _cffi_d_SSL_set_fd +#endif + +static long _cffi_d_SSL_set_max_proto_version(SSL * x0, int x1) +{ + return SSL_set_max_proto_version(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_max_proto_version(PyObject *self, PyObject *args) +{ + SSL * x0; + int x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_max_proto_version", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_max_proto_version(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_set_max_proto_version _cffi_d_SSL_set_max_proto_version +#endif + +static long _cffi_d_SSL_set_min_proto_version(SSL * x0, int x1) +{ + return SSL_set_min_proto_version(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_min_proto_version(PyObject *self, PyObject *args) +{ + SSL * x0; + int x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_min_proto_version", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_min_proto_version(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_set_min_proto_version _cffi_d_SSL_set_min_proto_version +#endif + +static unsigned long _cffi_d_SSL_set_mode(SSL * x0, unsigned long x1) +{ + return SSL_set_mode(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_mode(PyObject *self, PyObject *args) +{ + SSL * x0; + unsigned long x1; + Py_ssize_t datasize; + unsigned long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_mode", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_mode(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_set_mode _cffi_d_SSL_set_mode +#endif + +static unsigned long _cffi_d_SSL_set_options(SSL * x0, unsigned long x1) +{ + return SSL_set_options(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_options(PyObject *self, PyObject *args) +{ + SSL * x0; + unsigned long x1; + Py_ssize_t datasize; + unsigned long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_options", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_options(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSL_set_options _cffi_d_SSL_set_options +#endif + +static void _cffi_d_SSL_set_post_handshake_auth(SSL * x0, int x1) +{ + SSL_set_post_handshake_auth(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_post_handshake_auth(PyObject *self, PyObject *args) +{ + SSL * x0; + int x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_post_handshake_auth", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_set_post_handshake_auth(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_set_post_handshake_auth _cffi_d_SSL_set_post_handshake_auth +#endif + +static int _cffi_d_SSL_set_session(SSL * x0, SSL_SESSION * x1) +{ + return SSL_set_session(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_session(PyObject *self, PyObject *args) +{ + SSL * x0; + SSL_SESSION * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_session", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1666), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (SSL_SESSION *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1666), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_session(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_set_session _cffi_d_SSL_set_session +#endif + +static void _cffi_d_SSL_set_shutdown(SSL * x0, int x1) +{ + SSL_set_shutdown(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_shutdown(PyObject *self, PyObject *args) +{ + SSL * x0; + int x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_shutdown", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_set_shutdown(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_set_shutdown _cffi_d_SSL_set_shutdown +#endif + +static void _cffi_d_SSL_set_tlsext_host_name(SSL * x0, char * x1) +{ + SSL_set_tlsext_host_name(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_tlsext_host_name(PyObject *self, PyObject *args) +{ + SSL * x0; + char * x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_tlsext_host_name", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(409), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { SSL_set_tlsext_host_name(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_SSL_set_tlsext_host_name _cffi_d_SSL_set_tlsext_host_name +#endif + +static long _cffi_d_SSL_set_tlsext_status_ocsp_resp(SSL * x0, unsigned char * x1, int x2) +{ + return SSL_set_tlsext_status_ocsp_resp(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_tlsext_status_ocsp_resp(PyObject *self, PyObject *args) +{ + SSL * x0; + unsigned char * x1; + int x2; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_set_tlsext_status_ocsp_resp", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(752), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_tlsext_status_ocsp_resp(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_set_tlsext_status_ocsp_resp _cffi_d_SSL_set_tlsext_status_ocsp_resp +#endif + +static long _cffi_d_SSL_set_tlsext_status_type(SSL * x0, long x1) +{ + return SSL_set_tlsext_status_type(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_tlsext_status_type(PyObject *self, PyObject *args) +{ + SSL * x0; + long x1; + Py_ssize_t datasize; + long result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_tlsext_status_type", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_tlsext_status_type(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_set_tlsext_status_type _cffi_d_SSL_set_tlsext_status_type +#endif + +static int _cffi_d_SSL_set_tlsext_use_srtp(SSL * x0, char const * x1) +{ + return SSL_set_tlsext_use_srtp(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_set_tlsext_use_srtp(PyObject *self, PyObject *args) +{ + SSL * x0; + char const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "SSL_set_tlsext_use_srtp", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_set_tlsext_use_srtp(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_set_tlsext_use_srtp _cffi_d_SSL_set_tlsext_use_srtp +#endif + +static int _cffi_d_SSL_shutdown(SSL * x0) +{ + return SSL_shutdown(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_shutdown(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_shutdown(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_shutdown _cffi_d_SSL_shutdown +#endif + +static char const * _cffi_d_SSL_state_string_long(SSL const * x0) +{ + return SSL_state_string_long(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_state_string_long(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + char const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_state_string_long(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_SSL_state_string_long _cffi_d_SSL_state_string_long +#endif + +static long _cffi_d_SSL_total_renegotiations(SSL * x0) +{ + return SSL_total_renegotiations(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_total_renegotiations(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_total_renegotiations(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_SSL_total_renegotiations _cffi_d_SSL_total_renegotiations +#endif + +static int _cffi_d_SSL_verify_client_post_handshake(SSL * x0) +{ + return SSL_verify_client_post_handshake(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_verify_client_post_handshake(PyObject *self, PyObject *arg0) +{ + SSL * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_verify_client_post_handshake(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_verify_client_post_handshake _cffi_d_SSL_verify_client_post_handshake +#endif + +static int _cffi_d_SSL_version(SSL const * x0) +{ + return SSL_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_version(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_version _cffi_d_SSL_version +#endif + +static int _cffi_d_SSL_want_read(SSL const * x0) +{ + return SSL_want_read(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_want_read(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_want_read(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_want_read _cffi_d_SSL_want_read +#endif + +static int _cffi_d_SSL_want_write(SSL const * x0) +{ + return SSL_want_write(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_want_write(PyObject *self, PyObject *arg0) +{ + SSL const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(157), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(157), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_want_write(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_want_write _cffi_d_SSL_want_write +#endif + +static int _cffi_d_SSL_write(SSL * x0, void const * x1, int x2) +{ + return SSL_write(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_write(PyObject *self, PyObject *args) +{ + SSL * x0; + void const * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "SSL_write", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(126), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_write(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_write _cffi_d_SSL_write +#endif + +static int _cffi_d_SSL_write_early_data(SSL * x0, void const * x1, size_t x2, size_t * x3) +{ + return SSL_write_early_data(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSL_write_early_data(PyObject *self, PyObject *args) +{ + SSL * x0; + void const * x1; + size_t x2; + size_t * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "SSL_write_early_data", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(487), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (SSL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(487), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(126), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(126), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1037), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (size_t *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(1037), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSL_write_early_data(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_SSL_write_early_data _cffi_d_SSL_write_early_data +#endif + +static unsigned long _cffi_d_SSLeay(void) +{ + return SSLeay(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSLeay(PyObject *self, PyObject *noarg) +{ + unsigned long result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSLeay(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_SSLeay _cffi_d_SSLeay +#endif + +static char const * _cffi_d_SSLeay_version(int x0) +{ + return SSLeay_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSLeay_version(PyObject *self, PyObject *arg0) +{ + int x0; + char const * result; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSLeay_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_SSLeay_version _cffi_d_SSLeay_version +#endif + +static SSL_METHOD const * _cffi_d_SSLv23_client_method(void) +{ + return SSLv23_client_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSLv23_client_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSLv23_client_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_SSLv23_client_method _cffi_d_SSLv23_client_method +#endif + +static SSL_METHOD const * _cffi_d_SSLv23_method(void) +{ + return SSLv23_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSLv23_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSLv23_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_SSLv23_method _cffi_d_SSLv23_method +#endif + +static SSL_METHOD const * _cffi_d_SSLv23_server_method(void) +{ + return SSLv23_server_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSLv23_server_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSLv23_server_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_SSLv23_server_method _cffi_d_SSLv23_server_method +#endif + +static SSL_METHOD const * _cffi_d_SSLv3_client_method(void) +{ + return SSLv3_client_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSLv3_client_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSLv3_client_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_SSLv3_client_method _cffi_d_SSLv3_client_method +#endif + +static SSL_METHOD const * _cffi_d_SSLv3_method(void) +{ + return SSLv3_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSLv3_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSLv3_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_SSLv3_method _cffi_d_SSLv3_method +#endif + +static SSL_METHOD const * _cffi_d_SSLv3_server_method(void) +{ + return SSLv3_server_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_SSLv3_server_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = SSLv3_server_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_SSLv3_server_method _cffi_d_SSLv3_server_method +#endif + +static SSL_METHOD const * _cffi_d_TLS_client_method(void) +{ + return TLS_client_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLS_client_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLS_client_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLS_client_method _cffi_d_TLS_client_method +#endif + +static SSL_METHOD const * _cffi_d_TLS_method(void) +{ + return TLS_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLS_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLS_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLS_method _cffi_d_TLS_method +#endif + +static SSL_METHOD const * _cffi_d_TLS_server_method(void) +{ + return TLS_server_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLS_server_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLS_server_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLS_server_method _cffi_d_TLS_server_method +#endif + +static SSL_METHOD const * _cffi_d_TLSv1_1_client_method(void) +{ + return TLSv1_1_client_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLSv1_1_client_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLSv1_1_client_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLSv1_1_client_method _cffi_d_TLSv1_1_client_method +#endif + +static SSL_METHOD const * _cffi_d_TLSv1_1_method(void) +{ + return TLSv1_1_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLSv1_1_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLSv1_1_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLSv1_1_method _cffi_d_TLSv1_1_method +#endif + +static SSL_METHOD const * _cffi_d_TLSv1_1_server_method(void) +{ + return TLSv1_1_server_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLSv1_1_server_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLSv1_1_server_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLSv1_1_server_method _cffi_d_TLSv1_1_server_method +#endif + +static SSL_METHOD const * _cffi_d_TLSv1_2_client_method(void) +{ + return TLSv1_2_client_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLSv1_2_client_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLSv1_2_client_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLSv1_2_client_method _cffi_d_TLSv1_2_client_method +#endif + +static SSL_METHOD const * _cffi_d_TLSv1_2_method(void) +{ + return TLSv1_2_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLSv1_2_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLSv1_2_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLSv1_2_method _cffi_d_TLSv1_2_method +#endif + +static SSL_METHOD const * _cffi_d_TLSv1_2_server_method(void) +{ + return TLSv1_2_server_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLSv1_2_server_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLSv1_2_server_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLSv1_2_server_method _cffi_d_TLSv1_2_server_method +#endif + +static SSL_METHOD const * _cffi_d_TLSv1_client_method(void) +{ + return TLSv1_client_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLSv1_client_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLSv1_client_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLSv1_client_method _cffi_d_TLSv1_client_method +#endif + +static SSL_METHOD const * _cffi_d_TLSv1_method(void) +{ + return TLSv1_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLSv1_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLSv1_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLSv1_method _cffi_d_TLSv1_method +#endif + +static SSL_METHOD const * _cffi_d_TLSv1_server_method(void) +{ + return TLSv1_server_method(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_TLSv1_server_method(PyObject *self, PyObject *noarg) +{ + SSL_METHOD const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = TLSv1_server_method(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3114)); +} +#else +# define _cffi_f_TLSv1_server_method _cffi_d_TLSv1_server_method +#endif + +static void _cffi_d_USERNOTICE_free(USERNOTICE * x0) +{ + USERNOTICE_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_USERNOTICE_free(PyObject *self, PyObject *arg0) +{ + USERNOTICE * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2873), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (USERNOTICE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2873), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { USERNOTICE_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_USERNOTICE_free _cffi_d_USERNOTICE_free +#endif + +static USERNOTICE * _cffi_d_USERNOTICE_new(void) +{ + return USERNOTICE_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_USERNOTICE_new(PyObject *self, PyObject *noarg) +{ + USERNOTICE * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = USERNOTICE_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2873)); +} +#else +# define _cffi_f_USERNOTICE_new _cffi_d_USERNOTICE_new +#endif + +static int _cffi_d_X509V3_EXT_add_alias(int x0, int x1) +{ + return X509V3_EXT_add_alias(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509V3_EXT_add_alias(PyObject *self, PyObject *args) +{ + int x0; + int x1; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509V3_EXT_add_alias", 2, 2, &arg0, &arg1)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509V3_EXT_add_alias(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509V3_EXT_add_alias _cffi_d_X509V3_EXT_add_alias +#endif + +static X509_EXTENSION * _cffi_d_X509V3_EXT_conf_nid(Cryptography_LHASH_OF_CONF_VALUE * x0, X509V3_CTX * x1, int x2, char * x3) +{ + return X509V3_EXT_conf_nid(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509V3_EXT_conf_nid(PyObject *self, PyObject *args) +{ + Cryptography_LHASH_OF_CONF_VALUE * x0; + X509V3_CTX * x1; + int x2; + char * x3; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509V3_EXT_conf_nid", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(580), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_LHASH_OF_CONF_VALUE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(580), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(575), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509V3_CTX *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(575), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(409), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509V3_EXT_conf_nid(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_X509V3_EXT_conf_nid _cffi_d_X509V3_EXT_conf_nid +#endif + +static void * _cffi_d_X509V3_EXT_d2i(X509_EXTENSION * x0) +{ + return X509V3_EXT_d2i(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509V3_EXT_d2i(PyObject *self, PyObject *arg0) +{ + X509_EXTENSION * x0; + Py_ssize_t datasize; + void * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(40), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509V3_EXT_d2i(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(193)); +} +#else +# define _cffi_f_X509V3_EXT_d2i _cffi_d_X509V3_EXT_d2i +#endif + +static X509_EXTENSION * _cffi_d_X509V3_EXT_i2d(int x0, int x1, void * x2) +{ + return X509V3_EXT_i2d(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509V3_EXT_i2d(PyObject *self, PyObject *args) +{ + int x0; + int x1; + void * x2; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509V3_EXT_i2d", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + x0 = _cffi_to_c_int(arg0, int); + if (x0 == (int)-1 && PyErr_Occurred()) + return NULL; + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (void *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(193), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509V3_EXT_i2d(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_X509V3_EXT_i2d _cffi_d_X509V3_EXT_i2d +#endif + +static X509_EXTENSION * _cffi_d_X509V3_EXT_nconf(CONF * x0, X509V3_CTX * x1, char * x2, char * x3) +{ + return X509V3_EXT_nconf(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509V3_EXT_nconf(PyObject *self, PyObject *args) +{ + CONF * x0; + X509V3_CTX * x1; + char * x2; + char * x3; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509V3_EXT_nconf", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(574), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (CONF *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(574), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(575), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509V3_CTX *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(575), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (char *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(409), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(409), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509V3_EXT_nconf(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_X509V3_EXT_nconf _cffi_d_X509V3_EXT_nconf +#endif + +static int _cffi_d_X509V3_EXT_print(BIO * x0, X509_EXTENSION * x1, unsigned long x2, int x3) +{ + return X509V3_EXT_print(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509V3_EXT_print(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_EXTENSION * x1; + unsigned long x2; + int x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509V3_EXT_print", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(40), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, unsigned long); + if (x2 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509V3_EXT_print(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509V3_EXT_print _cffi_d_X509V3_EXT_print +#endif + +static void _cffi_d_X509V3_set_ctx(X509V3_CTX * x0, X509 * x1, X509 * x2, X509_REQ * x3, X509_CRL * x4, int x5) +{ + X509V3_set_ctx(x0, x1, x2, x3, x4, x5); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509V3_set_ctx(PyObject *self, PyObject *args) +{ + X509V3_CTX * x0; + X509 * x1; + X509 * x2; + X509_REQ * x3; + X509_CRL * x4; + int x5; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + + if (!PyArg_UnpackTuple(args, "X509V3_set_ctx", 6, 6, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(575), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509V3_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(575), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (X509 *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(28), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(294), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(57), arg4) < 0) + return NULL; + } + + x5 = _cffi_to_c_int(arg5, int); + if (x5 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509V3_set_ctx(x0, x1, x2, x3, x4, x5); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509V3_set_ctx _cffi_d_X509V3_set_ctx +#endif + +static void * _cffi_d_X509V3_set_ctx_nodb(X509V3_CTX * x0) +{ + return X509V3_set_ctx_nodb(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509V3_set_ctx_nodb(PyObject *self, PyObject *arg0) +{ + X509V3_CTX * x0; + Py_ssize_t datasize; + void * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(575), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509V3_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(575), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509V3_set_ctx_nodb(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(193)); +} +#else +# define _cffi_f_X509V3_set_ctx_nodb _cffi_d_X509V3_set_ctx_nodb +#endif + +static int _cffi_d_X509_ATTRIBUTE_count(X509_ATTRIBUTE const * x0) +{ + return X509_ATTRIBUTE_count(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_ATTRIBUTE_count(PyObject *self, PyObject *arg0) +{ + X509_ATTRIBUTE const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1894), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_ATTRIBUTE const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1894), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_ATTRIBUTE_count(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_ATTRIBUTE_count _cffi_d_X509_ATTRIBUTE_count +#endif + +static void * _cffi_d_X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE * x0, int x1, int x2, void * x3) +{ + return X509_ATTRIBUTE_get0_data(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_ATTRIBUTE_get0_data(PyObject *self, PyObject *args) +{ + X509_ATTRIBUTE * x0; + int x1; + int x2; + void * x3; + Py_ssize_t datasize; + void * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509_ATTRIBUTE_get0_data", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(79), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_ATTRIBUTE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(79), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_ATTRIBUTE_get0_data(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(193)); +} +#else +# define _cffi_f_X509_ATTRIBUTE_get0_data _cffi_d_X509_ATTRIBUTE_get0_data +#endif + +static ASN1_TYPE * _cffi_d_X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE * x0, int x1) +{ + return X509_ATTRIBUTE_get0_type(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_ATTRIBUTE_get0_type(PyObject *self, PyObject *args) +{ + X509_ATTRIBUTE * x0; + int x1; + Py_ssize_t datasize; + ASN1_TYPE * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_ATTRIBUTE_get0_type", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(79), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_ATTRIBUTE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(79), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_ATTRIBUTE_get0_type(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(801)); +} +#else +# define _cffi_f_X509_ATTRIBUTE_get0_type _cffi_d_X509_ATTRIBUTE_get0_type +#endif + +static int _cffi_d_X509_CRL_add0_revoked(X509_CRL * x0, X509_REVOKED * x1) +{ + return X509_CRL_add0_revoked(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_add0_revoked(PyObject *self, PyObject *args) +{ + X509_CRL * x0; + X509_REVOKED * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_CRL_add0_revoked", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(619), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(619), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_add0_revoked(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_add0_revoked _cffi_d_X509_CRL_add0_revoked +#endif + +static int _cffi_d_X509_CRL_add_ext(X509_CRL * x0, X509_EXTENSION * x1, int x2) +{ + return X509_CRL_add_ext(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_add_ext(PyObject *self, PyObject *args) +{ + X509_CRL * x0; + X509_EXTENSION * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_CRL_add_ext", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(40), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_add_ext(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_add_ext _cffi_d_X509_CRL_add_ext +#endif + +static int _cffi_d_X509_CRL_cmp(X509_CRL const * x0, X509_CRL const * x1) +{ + return X509_CRL_cmp(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_cmp(PyObject *self, PyObject *args) +{ + X509_CRL const * x0; + X509_CRL const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_CRL_cmp", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1939), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1939), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1939), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_CRL const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1939), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_cmp(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_cmp _cffi_d_X509_CRL_cmp +#endif + +static X509_CRL * _cffi_d_X509_CRL_dup(X509_CRL * x0) +{ + return X509_CRL_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_dup(PyObject *self, PyObject *arg0) +{ + X509_CRL * x0; + Py_ssize_t datasize; + X509_CRL * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(57)); +} +#else +# define _cffi_f_X509_CRL_dup _cffi_d_X509_CRL_dup +#endif + +static void _cffi_d_X509_CRL_free(X509_CRL * x0) +{ + X509_CRL_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_free(PyObject *self, PyObject *arg0) +{ + X509_CRL * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_CRL_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_CRL_free _cffi_d_X509_CRL_free +#endif + +static int _cffi_d_X509_CRL_get0_by_serial(X509_CRL * x0, X509_REVOKED * * x1, ASN1_INTEGER * x2) +{ + return X509_CRL_get0_by_serial(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_get0_by_serial(PyObject *self, PyObject *args) +{ + X509_CRL * x0; + X509_REVOKED * * x1; + ASN1_INTEGER * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_CRL_get0_by_serial", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1923), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_REVOKED * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1923), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(21), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(21), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_get0_by_serial(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_get0_by_serial _cffi_d_X509_CRL_get0_by_serial +#endif + +static void _cffi_d_X509_CRL_get0_signature(X509_CRL const * x0, ASN1_OCTET_STRING const * * x1, X509_ALGOR const * * x2) +{ + X509_CRL_get0_signature(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_get0_signature(PyObject *self, PyObject *args) +{ + X509_CRL const * x0; + ASN1_OCTET_STRING const * * x1; + X509_ALGOR const * * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_CRL_get0_signature", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1939), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1939), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1566), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OCTET_STRING const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1566), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2553), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (X509_ALGOR const * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2553), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_CRL_get0_signature(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_CRL_get0_signature _cffi_d_X509_CRL_get0_signature +#endif + +static Cryptography_STACK_OF_X509_REVOKED * _cffi_d_X509_CRL_get_REVOKED(X509_CRL * x0) +{ + return X509_CRL_get_REVOKED(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_get_REVOKED(PyObject *self, PyObject *arg0) +{ + X509_CRL * x0; + Py_ssize_t datasize; + Cryptography_STACK_OF_X509_REVOKED * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_get_REVOKED(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(682)); +} +#else +# define _cffi_f_X509_CRL_get_REVOKED _cffi_d_X509_CRL_get_REVOKED +#endif + +static X509_EXTENSION * _cffi_d_X509_CRL_get_ext(X509_CRL * x0, int x1) +{ + return X509_CRL_get_ext(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_get_ext(PyObject *self, PyObject *args) +{ + X509_CRL * x0; + int x1; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_CRL_get_ext", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_get_ext(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_X509_CRL_get_ext _cffi_d_X509_CRL_get_ext +#endif + +static int _cffi_d_X509_CRL_get_ext_count(X509_CRL * x0) +{ + return X509_CRL_get_ext_count(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_get_ext_count(PyObject *self, PyObject *arg0) +{ + X509_CRL * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_get_ext_count(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_get_ext_count _cffi_d_X509_CRL_get_ext_count +#endif + +static X509_NAME * _cffi_d_X509_CRL_get_issuer(X509_CRL * x0) +{ + return X509_CRL_get_issuer(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_get_issuer(PyObject *self, PyObject *arg0) +{ + X509_CRL * x0; + Py_ssize_t datasize; + X509_NAME * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_get_issuer(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(643)); +} +#else +# define _cffi_f_X509_CRL_get_issuer _cffi_d_X509_CRL_get_issuer +#endif + +static ASN1_OCTET_STRING * _cffi_d_X509_CRL_get_lastUpdate(X509_CRL * x0) +{ + return X509_CRL_get_lastUpdate(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_get_lastUpdate(PyObject *self, PyObject *arg0) +{ + X509_CRL * x0; + Py_ssize_t datasize; + ASN1_OCTET_STRING * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_get_lastUpdate(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_X509_CRL_get_lastUpdate _cffi_d_X509_CRL_get_lastUpdate +#endif + +static ASN1_OCTET_STRING * _cffi_d_X509_CRL_get_nextUpdate(X509_CRL * x0) +{ + return X509_CRL_get_nextUpdate(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_get_nextUpdate(PyObject *self, PyObject *arg0) +{ + X509_CRL * x0; + Py_ssize_t datasize; + ASN1_OCTET_STRING * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_get_nextUpdate(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_X509_CRL_get_nextUpdate _cffi_d_X509_CRL_get_nextUpdate +#endif + +static long _cffi_d_X509_CRL_get_version(X509_CRL * x0) +{ + return X509_CRL_get_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_get_version(PyObject *self, PyObject *arg0) +{ + X509_CRL * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_get_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_X509_CRL_get_version _cffi_d_X509_CRL_get_version +#endif + +static X509_CRL * _cffi_d_X509_CRL_new(void) +{ + return X509_CRL_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_new(PyObject *self, PyObject *noarg) +{ + X509_CRL * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(57)); +} +#else +# define _cffi_f_X509_CRL_new _cffi_d_X509_CRL_new +#endif + +static int _cffi_d_X509_CRL_print(BIO * x0, X509_CRL * x1) +{ + return X509_CRL_print(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_print(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_CRL * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_CRL_print", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(57), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_print(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_print _cffi_d_X509_CRL_print +#endif + +static int _cffi_d_X509_CRL_set_issuer_name(X509_CRL * x0, X509_NAME * x1) +{ + return X509_CRL_set_issuer_name(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_set_issuer_name(PyObject *self, PyObject *args) +{ + X509_CRL * x0; + X509_NAME * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_CRL_set_issuer_name", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(643), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_set_issuer_name(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_set_issuer_name _cffi_d_X509_CRL_set_issuer_name +#endif + +static int _cffi_d_X509_CRL_set_lastUpdate(X509_CRL * x0, ASN1_OCTET_STRING * x1) +{ + return X509_CRL_set_lastUpdate(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_set_lastUpdate(PyObject *self, PyObject *args) +{ + X509_CRL * x0; + ASN1_OCTET_STRING * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_CRL_set_lastUpdate", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(13), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_set_lastUpdate(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_set_lastUpdate _cffi_d_X509_CRL_set_lastUpdate +#endif + +static int _cffi_d_X509_CRL_set_nextUpdate(X509_CRL * x0, ASN1_OCTET_STRING * x1) +{ + return X509_CRL_set_nextUpdate(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_set_nextUpdate(PyObject *self, PyObject *args) +{ + X509_CRL * x0; + ASN1_OCTET_STRING * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_CRL_set_nextUpdate", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(13), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_set_nextUpdate(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_set_nextUpdate _cffi_d_X509_CRL_set_nextUpdate +#endif + +static int _cffi_d_X509_CRL_set_version(X509_CRL * x0, long x1) +{ + return X509_CRL_set_version(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_set_version(PyObject *self, PyObject *args) +{ + X509_CRL * x0; + long x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_CRL_set_version", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_set_version(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_set_version _cffi_d_X509_CRL_set_version +#endif + +static int _cffi_d_X509_CRL_sign(X509_CRL * x0, EVP_PKEY * x1, EVP_MD const * x2) +{ + return X509_CRL_sign(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_sign(PyObject *self, PyObject *args) +{ + X509_CRL * x0; + EVP_PKEY * x1; + EVP_MD const * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_CRL_sign", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(354), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_sign(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_sign _cffi_d_X509_CRL_sign +#endif + +static int _cffi_d_X509_CRL_sort(X509_CRL * x0) +{ + return X509_CRL_sort(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_sort(PyObject *self, PyObject *arg0) +{ + X509_CRL * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_sort(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_sort _cffi_d_X509_CRL_sort +#endif + +static int _cffi_d_X509_CRL_verify(X509_CRL * x0, EVP_PKEY * x1) +{ + return X509_CRL_verify(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_CRL_verify(PyObject *self, PyObject *args) +{ + X509_CRL * x0; + EVP_PKEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_CRL_verify", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_CRL_verify(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_CRL_verify _cffi_d_X509_CRL_verify +#endif + +static X509_EXTENSION * _cffi_d_X509_EXTENSION_create_by_OBJ(X509_EXTENSION * * x0, ASN1_OBJECT * x1, int x2, ASN1_OCTET_STRING * x3) +{ + return X509_EXTENSION_create_by_OBJ(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_EXTENSION_create_by_OBJ(PyObject *self, PyObject *args) +{ + X509_EXTENSION * * x0; + ASN1_OBJECT * x1; + int x2; + ASN1_OCTET_STRING * x3; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509_EXTENSION_create_by_OBJ", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(606), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSION * *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(606), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(607), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OBJECT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(607), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(13), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_EXTENSION_create_by_OBJ(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_X509_EXTENSION_create_by_OBJ _cffi_d_X509_EXTENSION_create_by_OBJ +#endif + +static X509_EXTENSION * _cffi_d_X509_EXTENSION_dup(X509_EXTENSION * x0) +{ + return X509_EXTENSION_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_EXTENSION_dup(PyObject *self, PyObject *arg0) +{ + X509_EXTENSION * x0; + Py_ssize_t datasize; + X509_EXTENSION * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(40), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_EXTENSION_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_X509_EXTENSION_dup _cffi_d_X509_EXTENSION_dup +#endif + +static void _cffi_d_X509_EXTENSION_free(X509_EXTENSION * x0) +{ + X509_EXTENSION_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_EXTENSION_free(PyObject *self, PyObject *arg0) +{ + X509_EXTENSION * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(40), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_EXTENSION_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_EXTENSION_free _cffi_d_X509_EXTENSION_free +#endif + +static int _cffi_d_X509_EXTENSION_get_critical(X509_EXTENSION * x0) +{ + return X509_EXTENSION_get_critical(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_EXTENSION_get_critical(PyObject *self, PyObject *arg0) +{ + X509_EXTENSION * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(40), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_EXTENSION_get_critical(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_EXTENSION_get_critical _cffi_d_X509_EXTENSION_get_critical +#endif + +static ASN1_OCTET_STRING * _cffi_d_X509_EXTENSION_get_data(X509_EXTENSION * x0) +{ + return X509_EXTENSION_get_data(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_EXTENSION_get_data(PyObject *self, PyObject *arg0) +{ + X509_EXTENSION * x0; + Py_ssize_t datasize; + ASN1_OCTET_STRING * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(40), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_EXTENSION_get_data(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_X509_EXTENSION_get_data _cffi_d_X509_EXTENSION_get_data +#endif + +static ASN1_OBJECT * _cffi_d_X509_EXTENSION_get_object(X509_EXTENSION * x0) +{ + return X509_EXTENSION_get_object(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_EXTENSION_get_object(PyObject *self, PyObject *arg0) +{ + X509_EXTENSION * x0; + Py_ssize_t datasize; + ASN1_OBJECT * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(40), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_EXTENSION_get_object(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(607)); +} +#else +# define _cffi_f_X509_EXTENSION_get_object _cffi_d_X509_EXTENSION_get_object +#endif + +static X509_NAME_ENTRY * _cffi_d_X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY * * x0, ASN1_OBJECT * x1, int x2, unsigned char const * x3, int x4) +{ + return X509_NAME_ENTRY_create_by_OBJ(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_ENTRY_create_by_OBJ(PyObject *self, PyObject *args) +{ + X509_NAME_ENTRY * * x0; + ASN1_OBJECT * x1; + int x2; + unsigned char const * x3; + int x4; + Py_ssize_t datasize; + X509_NAME_ENTRY * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "X509_NAME_ENTRY_create_by_OBJ", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(659), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME_ENTRY * *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(659), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(607), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OBJECT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(607), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_ENTRY_create_by_OBJ(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(43)); +} +#else +# define _cffi_f_X509_NAME_ENTRY_create_by_OBJ _cffi_d_X509_NAME_ENTRY_create_by_OBJ +#endif + +static void _cffi_d_X509_NAME_ENTRY_free(X509_NAME_ENTRY * x0) +{ + X509_NAME_ENTRY_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_ENTRY_free(PyObject *self, PyObject *arg0) +{ + X509_NAME_ENTRY * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(43), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME_ENTRY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(43), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_NAME_ENTRY_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_NAME_ENTRY_free _cffi_d_X509_NAME_ENTRY_free +#endif + +static ASN1_OCTET_STRING * _cffi_d_X509_NAME_ENTRY_get_data(X509_NAME_ENTRY * x0) +{ + return X509_NAME_ENTRY_get_data(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_ENTRY_get_data(PyObject *self, PyObject *arg0) +{ + X509_NAME_ENTRY * x0; + Py_ssize_t datasize; + ASN1_OCTET_STRING * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(43), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME_ENTRY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(43), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_ENTRY_get_data(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_X509_NAME_ENTRY_get_data _cffi_d_X509_NAME_ENTRY_get_data +#endif + +static ASN1_OBJECT * _cffi_d_X509_NAME_ENTRY_get_object(X509_NAME_ENTRY * x0) +{ + return X509_NAME_ENTRY_get_object(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_ENTRY_get_object(PyObject *self, PyObject *arg0) +{ + X509_NAME_ENTRY * x0; + Py_ssize_t datasize; + ASN1_OBJECT * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(43), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME_ENTRY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(43), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_ENTRY_get_object(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(607)); +} +#else +# define _cffi_f_X509_NAME_ENTRY_get_object _cffi_d_X509_NAME_ENTRY_get_object +#endif + +static int _cffi_d_X509_NAME_ENTRY_set(X509_NAME_ENTRY * x0) +{ + return X509_NAME_ENTRY_set(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_ENTRY_set(PyObject *self, PyObject *arg0) +{ + X509_NAME_ENTRY * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(43), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME_ENTRY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(43), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_ENTRY_set(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_NAME_ENTRY_set _cffi_d_X509_NAME_ENTRY_set +#endif + +static int _cffi_d_X509_NAME_add_entry(X509_NAME * x0, X509_NAME_ENTRY * x1, int x2, int x3) +{ + return X509_NAME_add_entry(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_add_entry(PyObject *self, PyObject *args) +{ + X509_NAME * x0; + X509_NAME_ENTRY * x1; + int x2; + int x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509_NAME_add_entry", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(43), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_NAME_ENTRY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(43), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_add_entry(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_NAME_add_entry _cffi_d_X509_NAME_add_entry +#endif + +static int _cffi_d_X509_NAME_add_entry_by_NID(X509_NAME * x0, int x1, int x2, unsigned char * x3, int x4, int x5, int x6) +{ + return X509_NAME_add_entry_by_NID(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_add_entry_by_NID(PyObject *self, PyObject *args) +{ + X509_NAME * x0; + int x1; + int x2; + unsigned char * x3; + int x4; + int x5; + int x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "X509_NAME_add_entry_by_NID", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(752), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + x5 = _cffi_to_c_int(arg5, int); + if (x5 == (int)-1 && PyErr_Occurred()) + return NULL; + + x6 = _cffi_to_c_int(arg6, int); + if (x6 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_add_entry_by_NID(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_NAME_add_entry_by_NID _cffi_d_X509_NAME_add_entry_by_NID +#endif + +static int _cffi_d_X509_NAME_add_entry_by_OBJ(X509_NAME * x0, ASN1_OBJECT * x1, int x2, unsigned char * x3, int x4, int x5, int x6) +{ + return X509_NAME_add_entry_by_OBJ(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_add_entry_by_OBJ(PyObject *self, PyObject *args) +{ + X509_NAME * x0; + ASN1_OBJECT * x1; + int x2; + unsigned char * x3; + int x4; + int x5; + int x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "X509_NAME_add_entry_by_OBJ", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(607), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OBJECT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(607), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(752), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + x5 = _cffi_to_c_int(arg5, int); + if (x5 == (int)-1 && PyErr_Occurred()) + return NULL; + + x6 = _cffi_to_c_int(arg6, int); + if (x6 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_add_entry_by_OBJ(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_NAME_add_entry_by_OBJ _cffi_d_X509_NAME_add_entry_by_OBJ +#endif + +static int _cffi_d_X509_NAME_add_entry_by_txt(X509_NAME * x0, char const * x1, int x2, unsigned char const * x3, int x4, int x5, int x6) +{ + return X509_NAME_add_entry_by_txt(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_add_entry_by_txt(PyObject *self, PyObject *args) +{ + X509_NAME * x0; + char const * x1; + int x2; + unsigned char const * x3; + int x4; + int x5; + int x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "X509_NAME_add_entry_by_txt", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + x5 = _cffi_to_c_int(arg5, int); + if (x5 == (int)-1 && PyErr_Occurred()) + return NULL; + + x6 = _cffi_to_c_int(arg6, int); + if (x6 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_add_entry_by_txt(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_NAME_add_entry_by_txt _cffi_d_X509_NAME_add_entry_by_txt +#endif + +static int _cffi_d_X509_NAME_cmp(X509_NAME const * x0, X509_NAME const * x1) +{ + return X509_NAME_cmp(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_cmp(PyObject *self, PyObject *args) +{ + X509_NAME const * x0; + X509_NAME const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_NAME_cmp", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2003), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2003), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2003), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_NAME const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2003), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_cmp(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_NAME_cmp _cffi_d_X509_NAME_cmp +#endif + +static X509_NAME_ENTRY * _cffi_d_X509_NAME_delete_entry(X509_NAME * x0, int x1) +{ + return X509_NAME_delete_entry(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_delete_entry(PyObject *self, PyObject *args) +{ + X509_NAME * x0; + int x1; + Py_ssize_t datasize; + X509_NAME_ENTRY * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_NAME_delete_entry", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_delete_entry(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(43)); +} +#else +# define _cffi_f_X509_NAME_delete_entry _cffi_d_X509_NAME_delete_entry +#endif + +static X509_NAME * _cffi_d_X509_NAME_dup(X509_NAME * x0) +{ + return X509_NAME_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_dup(PyObject *self, PyObject *arg0) +{ + X509_NAME * x0; + Py_ssize_t datasize; + X509_NAME * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(643)); +} +#else +# define _cffi_f_X509_NAME_dup _cffi_d_X509_NAME_dup +#endif + +static int _cffi_d_X509_NAME_entry_count(X509_NAME * x0) +{ + return X509_NAME_entry_count(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_entry_count(PyObject *self, PyObject *arg0) +{ + X509_NAME * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_entry_count(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_NAME_entry_count _cffi_d_X509_NAME_entry_count +#endif + +static void _cffi_d_X509_NAME_free(X509_NAME * x0) +{ + X509_NAME_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_free(PyObject *self, PyObject *arg0) +{ + X509_NAME * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_NAME_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_NAME_free _cffi_d_X509_NAME_free +#endif + +static X509_NAME_ENTRY * _cffi_d_X509_NAME_get_entry(X509_NAME * x0, int x1) +{ + return X509_NAME_get_entry(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_get_entry(PyObject *self, PyObject *args) +{ + X509_NAME * x0; + int x1; + Py_ssize_t datasize; + X509_NAME_ENTRY * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_NAME_get_entry", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_get_entry(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(43)); +} +#else +# define _cffi_f_X509_NAME_get_entry _cffi_d_X509_NAME_get_entry +#endif + +static int _cffi_d_X509_NAME_get_index_by_NID(X509_NAME * x0, int x1, int x2) +{ + return X509_NAME_get_index_by_NID(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_get_index_by_NID(PyObject *self, PyObject *args) +{ + X509_NAME * x0; + int x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_NAME_get_index_by_NID", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_get_index_by_NID(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_NAME_get_index_by_NID _cffi_d_X509_NAME_get_index_by_NID +#endif + +static unsigned long _cffi_d_X509_NAME_hash(X509_NAME * x0) +{ + return X509_NAME_hash(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_hash(PyObject *self, PyObject *arg0) +{ + X509_NAME * x0; + Py_ssize_t datasize; + unsigned long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_hash(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_X509_NAME_hash _cffi_d_X509_NAME_hash +#endif + +static X509_NAME * _cffi_d_X509_NAME_new(void) +{ + return X509_NAME_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_new(PyObject *self, PyObject *noarg) +{ + X509_NAME * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(643)); +} +#else +# define _cffi_f_X509_NAME_new _cffi_d_X509_NAME_new +#endif + +static char * _cffi_d_X509_NAME_oneline(X509_NAME * x0, char * x1, int x2) +{ + return X509_NAME_oneline(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_oneline(PyObject *self, PyObject *args) +{ + X509_NAME * x0; + char * x1; + int x2; + Py_ssize_t datasize; + char * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_NAME_oneline", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(409), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_oneline(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(409)); +} +#else +# define _cffi_f_X509_NAME_oneline _cffi_d_X509_NAME_oneline +#endif + +static int _cffi_d_X509_NAME_print_ex(BIO * x0, X509_NAME * x1, int x2, unsigned long x3) +{ + return X509_NAME_print_ex(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_NAME_print_ex(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_NAME * x1; + int x2; + unsigned long x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509_NAME_print_ex", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(643), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, unsigned long); + if (x3 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_NAME_print_ex(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_NAME_print_ex _cffi_d_X509_NAME_print_ex +#endif + +static X509 * _cffi_d_X509_OBJECT_get0_X509(X509_OBJECT * x0) +{ + return X509_OBJECT_get0_X509(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_OBJECT_get0_X509(PyObject *self, PyObject *arg0) +{ + X509_OBJECT * x0; + Py_ssize_t datasize; + X509 * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(537), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_OBJECT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(537), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_OBJECT_get0_X509(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(28)); +} +#else +# define _cffi_f_X509_OBJECT_get0_X509 _cffi_d_X509_OBJECT_get0_X509 +#endif + +static int _cffi_d_X509_OBJECT_get_type(X509_OBJECT const * x0) +{ + return X509_OBJECT_get_type(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_OBJECT_get_type(PyObject *self, PyObject *arg0) +{ + X509_OBJECT const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2010), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_OBJECT const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2010), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_OBJECT_get_type(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_OBJECT_get_type _cffi_d_X509_OBJECT_get_type +#endif + +static int _cffi_d_X509_REQ_add1_attr_by_OBJ(X509_REQ * x0, ASN1_OBJECT const * x1, int x2, unsigned char const * x3, int x4) +{ + return X509_REQ_add1_attr_by_OBJ(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_add1_attr_by_OBJ(PyObject *self, PyObject *args) +{ + X509_REQ * x0; + ASN1_OBJECT const * x1; + int x2; + unsigned char const * x3; + int x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "X509_REQ_add1_attr_by_OBJ", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(765), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OBJECT const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(765), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(103), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_add1_attr_by_OBJ(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REQ_add1_attr_by_OBJ _cffi_d_X509_REQ_add1_attr_by_OBJ +#endif + +static int _cffi_d_X509_REQ_add_extensions(X509_REQ * x0, X509_EXTENSIONS * x1) +{ + return X509_REQ_add_extensions(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_add_extensions(PyObject *self, PyObject *args) +{ + X509_REQ * x0; + X509_EXTENSIONS * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_REQ_add_extensions", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(615), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_EXTENSIONS *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(615), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_add_extensions(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REQ_add_extensions _cffi_d_X509_REQ_add_extensions +#endif + +static void _cffi_d_X509_REQ_free(X509_REQ * x0) +{ + X509_REQ_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_free(PyObject *self, PyObject *arg0) +{ + X509_REQ * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_REQ_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_REQ_free _cffi_d_X509_REQ_free +#endif + +static void _cffi_d_X509_REQ_get0_signature(X509_REQ const * x0, ASN1_OCTET_STRING const * * x1, X509_ALGOR const * * x2) +{ + X509_REQ_get0_signature(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_get0_signature(PyObject *self, PyObject *args) +{ + X509_REQ const * x0; + ASN1_OCTET_STRING const * * x1; + X509_ALGOR const * * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_REQ_get0_signature", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(551), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(551), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1566), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OCTET_STRING const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1566), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2553), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (X509_ALGOR const * *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2553), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_REQ_get0_signature(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_REQ_get0_signature _cffi_d_X509_REQ_get0_signature +#endif + +static X509_ATTRIBUTE * _cffi_d_X509_REQ_get_attr(X509_REQ const * x0, int x1) +{ + return X509_REQ_get_attr(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_get_attr(PyObject *self, PyObject *args) +{ + X509_REQ const * x0; + int x1; + Py_ssize_t datasize; + X509_ATTRIBUTE * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_REQ_get_attr", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(551), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(551), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_get_attr(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(79)); +} +#else +# define _cffi_f_X509_REQ_get_attr _cffi_d_X509_REQ_get_attr +#endif + +static int _cffi_d_X509_REQ_get_attr_by_OBJ(X509_REQ const * x0, ASN1_OBJECT const * x1, int x2) +{ + return X509_REQ_get_attr_by_OBJ(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_get_attr_by_OBJ(PyObject *self, PyObject *args) +{ + X509_REQ const * x0; + ASN1_OBJECT const * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_REQ_get_attr_by_OBJ", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(551), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(551), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(765), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OBJECT const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(765), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_get_attr_by_OBJ(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REQ_get_attr_by_OBJ _cffi_d_X509_REQ_get_attr_by_OBJ +#endif + +static X509_EXTENSIONS * _cffi_d_X509_REQ_get_extensions(X509_REQ * x0) +{ + return X509_REQ_get_extensions(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_get_extensions(PyObject *self, PyObject *arg0) +{ + X509_REQ * x0; + Py_ssize_t datasize; + X509_EXTENSIONS * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_get_extensions(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(615)); +} +#else +# define _cffi_f_X509_REQ_get_extensions _cffi_d_X509_REQ_get_extensions +#endif + +static EVP_PKEY * _cffi_d_X509_REQ_get_pubkey(X509_REQ * x0) +{ + return X509_REQ_get_pubkey(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_get_pubkey(PyObject *self, PyObject *arg0) +{ + X509_REQ * x0; + Py_ssize_t datasize; + EVP_PKEY * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_get_pubkey(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_X509_REQ_get_pubkey _cffi_d_X509_REQ_get_pubkey +#endif + +static X509_NAME * _cffi_d_X509_REQ_get_subject_name(X509_REQ * x0) +{ + return X509_REQ_get_subject_name(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_get_subject_name(PyObject *self, PyObject *arg0) +{ + X509_REQ * x0; + Py_ssize_t datasize; + X509_NAME * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_get_subject_name(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(643)); +} +#else +# define _cffi_f_X509_REQ_get_subject_name _cffi_d_X509_REQ_get_subject_name +#endif + +static long _cffi_d_X509_REQ_get_version(X509_REQ * x0) +{ + return X509_REQ_get_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_get_version(PyObject *self, PyObject *arg0) +{ + X509_REQ * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_get_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_X509_REQ_get_version _cffi_d_X509_REQ_get_version +#endif + +static X509_REQ * _cffi_d_X509_REQ_new(void) +{ + return X509_REQ_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_new(PyObject *self, PyObject *noarg) +{ + X509_REQ * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(294)); +} +#else +# define _cffi_f_X509_REQ_new _cffi_d_X509_REQ_new +#endif + +static int _cffi_d_X509_REQ_print_ex(BIO * x0, X509_REQ * x1, unsigned long x2, unsigned long x3) +{ + return X509_REQ_print_ex(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_print_ex(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_REQ * x1; + unsigned long x2; + unsigned long x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509_REQ_print_ex", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(294), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, unsigned long); + if (x2 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, unsigned long); + if (x3 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_print_ex(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REQ_print_ex _cffi_d_X509_REQ_print_ex +#endif + +static int _cffi_d_X509_REQ_set_pubkey(X509_REQ * x0, EVP_PKEY * x1) +{ + return X509_REQ_set_pubkey(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_set_pubkey(PyObject *self, PyObject *args) +{ + X509_REQ * x0; + EVP_PKEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_REQ_set_pubkey", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_set_pubkey(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REQ_set_pubkey _cffi_d_X509_REQ_set_pubkey +#endif + +static int _cffi_d_X509_REQ_set_subject_name(X509_REQ * x0, X509_NAME * x1) +{ + return X509_REQ_set_subject_name(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_set_subject_name(PyObject *self, PyObject *args) +{ + X509_REQ * x0; + X509_NAME * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_REQ_set_subject_name", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(643), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_set_subject_name(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REQ_set_subject_name _cffi_d_X509_REQ_set_subject_name +#endif + +static int _cffi_d_X509_REQ_set_version(X509_REQ * x0, long x1) +{ + return X509_REQ_set_version(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_set_version(PyObject *self, PyObject *args) +{ + X509_REQ * x0; + long x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_REQ_set_version", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_set_version(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REQ_set_version _cffi_d_X509_REQ_set_version +#endif + +static int _cffi_d_X509_REQ_sign(X509_REQ * x0, EVP_PKEY * x1, EVP_MD const * x2) +{ + return X509_REQ_sign(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_sign(PyObject *self, PyObject *args) +{ + X509_REQ * x0; + EVP_PKEY * x1; + EVP_MD const * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_REQ_sign", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(354), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_sign(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REQ_sign _cffi_d_X509_REQ_sign +#endif + +static int _cffi_d_X509_REQ_verify(X509_REQ * x0, EVP_PKEY * x1) +{ + return X509_REQ_verify(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REQ_verify(PyObject *self, PyObject *args) +{ + X509_REQ * x0; + EVP_PKEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_REQ_verify", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REQ_verify(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REQ_verify _cffi_d_X509_REQ_verify +#endif + +static int _cffi_d_X509_REVOKED_add1_ext_i2d(X509_REVOKED * x0, int x1, void * x2, int x3, unsigned long x4) +{ + return X509_REVOKED_add1_ext_i2d(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_add1_ext_i2d(PyObject *self, PyObject *args) +{ + X509_REVOKED * x0; + int x1; + void * x2; + int x3; + unsigned long x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "X509_REVOKED_add1_ext_i2d", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(619), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(619), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (void *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(193), arg2) < 0) + return NULL; + } + + x3 = _cffi_to_c_int(arg3, int); + if (x3 == (int)-1 && PyErr_Occurred()) + return NULL; + + x4 = _cffi_to_c_int(arg4, unsigned long); + if (x4 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REVOKED_add1_ext_i2d(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REVOKED_add1_ext_i2d _cffi_d_X509_REVOKED_add1_ext_i2d +#endif + +static int _cffi_d_X509_REVOKED_add_ext(X509_REVOKED * x0, X509_EXTENSION * x1, int x2) +{ + return X509_REVOKED_add_ext(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_add_ext(PyObject *self, PyObject *args) +{ + X509_REVOKED * x0; + X509_EXTENSION * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_REVOKED_add_ext", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(619), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(619), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(40), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REVOKED_add_ext(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REVOKED_add_ext _cffi_d_X509_REVOKED_add_ext +#endif + +static X509_EXTENSION * _cffi_d_X509_REVOKED_delete_ext(X509_REVOKED * x0, int x1) +{ + return X509_REVOKED_delete_ext(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_delete_ext(PyObject *self, PyObject *args) +{ + X509_REVOKED * x0; + int x1; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_REVOKED_delete_ext", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(619), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(619), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REVOKED_delete_ext(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_X509_REVOKED_delete_ext _cffi_d_X509_REVOKED_delete_ext +#endif + +static X509_REVOKED * _cffi_d_X509_REVOKED_dup(X509_REVOKED * x0) +{ + return X509_REVOKED_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_dup(PyObject *self, PyObject *arg0) +{ + X509_REVOKED * x0; + Py_ssize_t datasize; + X509_REVOKED * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(619), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(619), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REVOKED_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(619)); +} +#else +# define _cffi_f_X509_REVOKED_dup _cffi_d_X509_REVOKED_dup +#endif + +static void _cffi_d_X509_REVOKED_free(X509_REVOKED * x0) +{ + X509_REVOKED_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_free(PyObject *self, PyObject *arg0) +{ + X509_REVOKED * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(619), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(619), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_REVOKED_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_REVOKED_free _cffi_d_X509_REVOKED_free +#endif + +static ASN1_OCTET_STRING const * _cffi_d_X509_REVOKED_get0_revocationDate(X509_REVOKED const * x0) +{ + return X509_REVOKED_get0_revocationDate(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_get0_revocationDate(PyObject *self, PyObject *arg0) +{ + X509_REVOKED const * x0; + Py_ssize_t datasize; + ASN1_OCTET_STRING const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(31), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(31), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REVOKED_get0_revocationDate(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3016)); +} +#else +# define _cffi_f_X509_REVOKED_get0_revocationDate _cffi_d_X509_REVOKED_get0_revocationDate +#endif + +static ASN1_INTEGER const * _cffi_d_X509_REVOKED_get0_serialNumber(X509_REVOKED const * x0) +{ + return X509_REVOKED_get0_serialNumber(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_get0_serialNumber(PyObject *self, PyObject *arg0) +{ + X509_REVOKED const * x0; + Py_ssize_t datasize; + ASN1_INTEGER const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(31), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(31), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REVOKED_get0_serialNumber(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3011)); +} +#else +# define _cffi_f_X509_REVOKED_get0_serialNumber _cffi_d_X509_REVOKED_get0_serialNumber +#endif + +static X509_EXTENSION * _cffi_d_X509_REVOKED_get_ext(X509_REVOKED * x0, int x1) +{ + return X509_REVOKED_get_ext(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_get_ext(PyObject *self, PyObject *args) +{ + X509_REVOKED * x0; + int x1; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_REVOKED_get_ext", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(619), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(619), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REVOKED_get_ext(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_X509_REVOKED_get_ext _cffi_d_X509_REVOKED_get_ext +#endif + +static int _cffi_d_X509_REVOKED_get_ext_count(X509_REVOKED * x0) +{ + return X509_REVOKED_get_ext_count(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_get_ext_count(PyObject *self, PyObject *arg0) +{ + X509_REVOKED * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(619), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(619), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REVOKED_get_ext_count(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REVOKED_get_ext_count _cffi_d_X509_REVOKED_get_ext_count +#endif + +static X509_REVOKED * _cffi_d_X509_REVOKED_new(void) +{ + return X509_REVOKED_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_new(PyObject *self, PyObject *noarg) +{ + X509_REVOKED * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REVOKED_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(619)); +} +#else +# define _cffi_f_X509_REVOKED_new _cffi_d_X509_REVOKED_new +#endif + +static int _cffi_d_X509_REVOKED_set_revocationDate(X509_REVOKED * x0, ASN1_OCTET_STRING * x1) +{ + return X509_REVOKED_set_revocationDate(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_set_revocationDate(PyObject *self, PyObject *args) +{ + X509_REVOKED * x0; + ASN1_OCTET_STRING * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_REVOKED_set_revocationDate", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(619), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(619), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(13), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REVOKED_set_revocationDate(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REVOKED_set_revocationDate _cffi_d_X509_REVOKED_set_revocationDate +#endif + +static int _cffi_d_X509_REVOKED_set_serialNumber(X509_REVOKED * x0, ASN1_INTEGER * x1) +{ + return X509_REVOKED_set_serialNumber(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_REVOKED_set_serialNumber(PyObject *self, PyObject *args) +{ + X509_REVOKED * x0; + ASN1_INTEGER * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_REVOKED_set_serialNumber", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(619), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(619), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(21), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(21), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_REVOKED_set_serialNumber(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_REVOKED_set_serialNumber _cffi_d_X509_REVOKED_set_serialNumber +#endif + +static void _cffi_d_X509_STORE_CTX_cleanup(X509_STORE_CTX * x0) +{ + X509_STORE_CTX_cleanup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_cleanup(PyObject *self, PyObject *arg0) +{ + X509_STORE_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_STORE_CTX_cleanup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_STORE_CTX_cleanup _cffi_d_X509_STORE_CTX_cleanup +#endif + +static void _cffi_d_X509_STORE_CTX_free(X509_STORE_CTX * x0) +{ + X509_STORE_CTX_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_free(PyObject *self, PyObject *arg0) +{ + X509_STORE_CTX * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_STORE_CTX_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_STORE_CTX_free _cffi_d_X509_STORE_CTX_free +#endif + +static X509 * _cffi_d_X509_STORE_CTX_get0_cert(X509_STORE_CTX * x0) +{ + return X509_STORE_CTX_get0_cert(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_get0_cert(PyObject *self, PyObject *arg0) +{ + X509_STORE_CTX * x0; + Py_ssize_t datasize; + X509 * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_get0_cert(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(28)); +} +#else +# define _cffi_f_X509_STORE_CTX_get0_cert _cffi_d_X509_STORE_CTX_get0_cert +#endif + +static X509_VERIFY_PARAM * _cffi_d_X509_STORE_CTX_get0_param(X509_STORE_CTX * x0) +{ + return X509_STORE_CTX_get0_param(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_get0_param(PyObject *self, PyObject *arg0) +{ + X509_STORE_CTX * x0; + Py_ssize_t datasize; + X509_VERIFY_PARAM * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_get0_param(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2085)); +} +#else +# define _cffi_f_X509_STORE_CTX_get0_param _cffi_d_X509_STORE_CTX_get0_param +#endif + +static Cryptography_STACK_OF_X509 * _cffi_d_X509_STORE_CTX_get1_chain(X509_STORE_CTX * x0) +{ + return X509_STORE_CTX_get1_chain(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_get1_chain(PyObject *self, PyObject *arg0) +{ + X509_STORE_CTX * x0; + Py_ssize_t datasize; + Cryptography_STACK_OF_X509 * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_get1_chain(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(413)); +} +#else +# define _cffi_f_X509_STORE_CTX_get1_chain _cffi_d_X509_STORE_CTX_get1_chain +#endif + +static int _cffi_d_X509_STORE_CTX_get1_issuer(X509 * * x0, X509_STORE_CTX * x1, X509 * x2) +{ + return X509_STORE_CTX_get1_issuer(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_get1_issuer(PyObject *self, PyObject *args) +{ + X509 * * x0; + X509_STORE_CTX * x1; + X509 * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_get1_issuer", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(518), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 * *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(518), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(160), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (X509 *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(28), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_get1_issuer(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_CTX_get1_issuer _cffi_d_X509_STORE_CTX_get1_issuer +#endif + +static Cryptography_STACK_OF_X509 * _cffi_d_X509_STORE_CTX_get_chain(X509_STORE_CTX * x0) +{ + return X509_STORE_CTX_get_chain(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_get_chain(PyObject *self, PyObject *arg0) +{ + X509_STORE_CTX * x0; + Py_ssize_t datasize; + Cryptography_STACK_OF_X509 * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_get_chain(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(413)); +} +#else +# define _cffi_f_X509_STORE_CTX_get_chain _cffi_d_X509_STORE_CTX_get_chain +#endif + +static X509 * _cffi_d_X509_STORE_CTX_get_current_cert(X509_STORE_CTX * x0) +{ + return X509_STORE_CTX_get_current_cert(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_get_current_cert(PyObject *self, PyObject *arg0) +{ + X509_STORE_CTX * x0; + Py_ssize_t datasize; + X509 * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_get_current_cert(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(28)); +} +#else +# define _cffi_f_X509_STORE_CTX_get_current_cert _cffi_d_X509_STORE_CTX_get_current_cert +#endif + +static int _cffi_d_X509_STORE_CTX_get_error(X509_STORE_CTX * x0) +{ + return X509_STORE_CTX_get_error(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_get_error(PyObject *self, PyObject *arg0) +{ + X509_STORE_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_get_error(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_CTX_get_error _cffi_d_X509_STORE_CTX_get_error +#endif + +static int _cffi_d_X509_STORE_CTX_get_error_depth(X509_STORE_CTX * x0) +{ + return X509_STORE_CTX_get_error_depth(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_get_error_depth(PyObject *self, PyObject *arg0) +{ + X509_STORE_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_get_error_depth(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_CTX_get_error_depth _cffi_d_X509_STORE_CTX_get_error_depth +#endif + +static void * _cffi_d_X509_STORE_CTX_get_ex_data(X509_STORE_CTX * x0, int x1) +{ + return X509_STORE_CTX_get_ex_data(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_get_ex_data(PyObject *self, PyObject *args) +{ + X509_STORE_CTX * x0; + int x1; + Py_ssize_t datasize; + void * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_get_ex_data", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_get_ex_data(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(193)); +} +#else +# define _cffi_f_X509_STORE_CTX_get_ex_data _cffi_d_X509_STORE_CTX_get_ex_data +#endif + +static int _cffi_d_X509_STORE_CTX_get_ex_new_index(long x0, void * x1, CRYPTO_EX_new * x2, CRYPTO_EX_dup * x3, CRYPTO_EX_free * x4) +{ + return X509_STORE_CTX_get_ex_new_index(x0, x1, x2, x3, x4); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_get_ex_new_index(PyObject *self, PyObject *args) +{ + long x0; + void * x1; + CRYPTO_EX_new * x2; + CRYPTO_EX_dup * x3; + CRYPTO_EX_free * x4; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_get_ex_new_index", 5, 5, &arg0, &arg1, &arg2, &arg3, &arg4)) + return NULL; + + x0 = _cffi_to_c_int(arg0, long); + if (x0 == (long)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (void *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(193), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2237), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (CRYPTO_EX_new *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(2237), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2238), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (CRYPTO_EX_dup *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(2238), arg3) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2239), arg4, (char **)&x4); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x4 = (CRYPTO_EX_free *)alloca((size_t)datasize); + memset((void *)x4, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x4, _cffi_type(2239), arg4) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_get_ex_new_index(x0, x1, x2, x3, x4); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_CTX_get_ex_new_index _cffi_d_X509_STORE_CTX_get_ex_new_index +#endif + +static int _cffi_d_X509_STORE_CTX_init(X509_STORE_CTX * x0, X509_STORE * x1, X509 * x2, Cryptography_STACK_OF_X509 * x3) +{ + return X509_STORE_CTX_init(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_init(PyObject *self, PyObject *args) +{ + X509_STORE_CTX * x0; + X509_STORE * x1; + X509 * x2; + Cryptography_STACK_OF_X509 * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_init", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(180), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (X509 *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(28), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(413), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (Cryptography_STACK_OF_X509 *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(413), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_init(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_CTX_init _cffi_d_X509_STORE_CTX_init +#endif + +static X509_STORE_CTX * _cffi_d_X509_STORE_CTX_new(void) +{ + return X509_STORE_CTX_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_new(PyObject *self, PyObject *noarg) +{ + X509_STORE_CTX * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(160)); +} +#else +# define _cffi_f_X509_STORE_CTX_new _cffi_d_X509_STORE_CTX_new +#endif + +static void _cffi_d_X509_STORE_CTX_set0_crls(X509_STORE_CTX * x0, Cryptography_STACK_OF_X509_CRL * x1) +{ + X509_STORE_CTX_set0_crls(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_set0_crls(PyObject *self, PyObject *args) +{ + X509_STORE_CTX * x0; + Cryptography_STACK_OF_X509_CRL * x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_set0_crls", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(565), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (Cryptography_STACK_OF_X509_CRL *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(565), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_STORE_CTX_set0_crls(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_STORE_CTX_set0_crls _cffi_d_X509_STORE_CTX_set0_crls +#endif + +static void _cffi_d_X509_STORE_CTX_set0_param(X509_STORE_CTX * x0, X509_VERIFY_PARAM * x1) +{ + X509_STORE_CTX_set0_param(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_set0_param(PyObject *self, PyObject *args) +{ + X509_STORE_CTX * x0; + X509_VERIFY_PARAM * x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_set0_param", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2085), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_STORE_CTX_set0_param(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_STORE_CTX_set0_param _cffi_d_X509_STORE_CTX_set0_param +#endif + +static void _cffi_d_X509_STORE_CTX_set_cert(X509_STORE_CTX * x0, X509 * x1) +{ + X509_STORE_CTX_set_cert(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_set_cert(PyObject *self, PyObject *args) +{ + X509_STORE_CTX * x0; + X509 * x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_set_cert", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_STORE_CTX_set_cert(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_STORE_CTX_set_cert _cffi_d_X509_STORE_CTX_set_cert +#endif + +static void _cffi_d_X509_STORE_CTX_set_chain(X509_STORE_CTX * x0, Cryptography_STACK_OF_X509 * x1) +{ + X509_STORE_CTX_set_chain(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_set_chain(PyObject *self, PyObject *args) +{ + X509_STORE_CTX * x0; + Cryptography_STACK_OF_X509 * x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_set_chain", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(413), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (Cryptography_STACK_OF_X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(413), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_STORE_CTX_set_chain(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_STORE_CTX_set_chain _cffi_d_X509_STORE_CTX_set_chain +#endif + +static int _cffi_d_X509_STORE_CTX_set_default(X509_STORE_CTX * x0, char const * x1) +{ + return X509_STORE_CTX_set_default(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_set_default(PyObject *self, PyObject *args) +{ + X509_STORE_CTX * x0; + char const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_set_default", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_set_default(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_CTX_set_default _cffi_d_X509_STORE_CTX_set_default +#endif + +static void _cffi_d_X509_STORE_CTX_set_error(X509_STORE_CTX * x0, int x1) +{ + X509_STORE_CTX_set_error(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_set_error(PyObject *self, PyObject *args) +{ + X509_STORE_CTX * x0; + int x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_set_error", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_STORE_CTX_set_error(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_STORE_CTX_set_error _cffi_d_X509_STORE_CTX_set_error +#endif + +static int _cffi_d_X509_STORE_CTX_set_ex_data(X509_STORE_CTX * x0, int x1, void * x2) +{ + return X509_STORE_CTX_set_ex_data(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_set_ex_data(PyObject *self, PyObject *args) +{ + X509_STORE_CTX * x0; + int x1; + void * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_set_ex_data", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (void *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(193), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_CTX_set_ex_data(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_CTX_set_ex_data _cffi_d_X509_STORE_CTX_set_ex_data +#endif + +static void _cffi_d_X509_STORE_CTX_set_verify_cb(X509_STORE_CTX * x0, int(* x1)(int, X509_STORE_CTX *)) +{ + X509_STORE_CTX_set_verify_cb(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_set_verify_cb(PyObject *self, PyObject *args) +{ + X509_STORE_CTX * x0; + int(* x1)(int, X509_STORE_CTX *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_set_verify_cb", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + x1 = (int(*)(int, X509_STORE_CTX *))_cffi_to_c_pointer(arg1, _cffi_type(2847)); + if (x1 == (int(*)(int, X509_STORE_CTX *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_STORE_CTX_set_verify_cb(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_STORE_CTX_set_verify_cb _cffi_d_X509_STORE_CTX_set_verify_cb +#endif + +static void _cffi_d_X509_STORE_CTX_trusted_stack(X509_STORE_CTX * x0, Cryptography_STACK_OF_X509 * x1) +{ + X509_STORE_CTX_trusted_stack(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_CTX_trusted_stack(PyObject *self, PyObject *args) +{ + X509_STORE_CTX * x0; + Cryptography_STACK_OF_X509 * x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_CTX_trusted_stack", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(413), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (Cryptography_STACK_OF_X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(413), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_STORE_CTX_trusted_stack(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_STORE_CTX_trusted_stack _cffi_d_X509_STORE_CTX_trusted_stack +#endif + +static int _cffi_d_X509_STORE_add_cert(X509_STORE * x0, X509 * x1) +{ + return X509_STORE_add_cert(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_add_cert(PyObject *self, PyObject *args) +{ + X509_STORE * x0; + X509 * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_add_cert", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(180), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_add_cert(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_add_cert _cffi_d_X509_STORE_add_cert +#endif + +static int _cffi_d_X509_STORE_add_crl(X509_STORE * x0, X509_CRL * x1) +{ + return X509_STORE_add_crl(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_add_crl(PyObject *self, PyObject *args) +{ + X509_STORE * x0; + X509_CRL * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_add_crl", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(180), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(57), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_add_crl(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_add_crl _cffi_d_X509_STORE_add_crl +#endif + +static void _cffi_d_X509_STORE_free(X509_STORE * x0) +{ + X509_STORE_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_free(PyObject *self, PyObject *arg0) +{ + X509_STORE * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(180), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_STORE_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_STORE_free _cffi_d_X509_STORE_free +#endif + +static Cryptography_STACK_OF_X509_OBJECT * _cffi_d_X509_STORE_get0_objects(X509_STORE * x0) +{ + return X509_STORE_get0_objects(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_get0_objects(PyObject *self, PyObject *arg0) +{ + X509_STORE * x0; + Py_ssize_t datasize; + Cryptography_STACK_OF_X509_OBJECT * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(180), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_get0_objects(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(666)); +} +#else +# define _cffi_f_X509_STORE_get0_objects _cffi_d_X509_STORE_get0_objects +#endif + +static X509_VERIFY_PARAM * _cffi_d_X509_STORE_get0_param(X509_STORE * x0) +{ + return X509_STORE_get0_param(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_get0_param(PyObject *self, PyObject *arg0) +{ + X509_STORE * x0; + Py_ssize_t datasize; + X509_VERIFY_PARAM * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(180), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_get0_param(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2085)); +} +#else +# define _cffi_f_X509_STORE_get0_param _cffi_d_X509_STORE_get0_param +#endif + +static int(* _cffi_d_X509_STORE_get_get_issuer(X509_STORE * x0))(X509 * *, X509_STORE_CTX *, X509 *) +{ + return X509_STORE_get_get_issuer(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_get_get_issuer(PyObject *self, PyObject *arg0) +{ + X509_STORE * x0; + Py_ssize_t datasize; + int(* result)(X509 * *, X509_STORE_CTX *, X509 *); + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(180), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_get_get_issuer(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2926)); +} +#else +# define _cffi_f_X509_STORE_get_get_issuer _cffi_d_X509_STORE_get_get_issuer +#endif + +static int _cffi_d_X509_STORE_load_locations(X509_STORE * x0, char const * x1, char const * x2) +{ + return X509_STORE_load_locations(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_load_locations(PyObject *self, PyObject *args) +{ + X509_STORE * x0; + char const * x1; + char const * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_STORE_load_locations", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(180), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (char const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(46), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_load_locations(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_load_locations _cffi_d_X509_STORE_load_locations +#endif + +static X509_STORE * _cffi_d_X509_STORE_new(void) +{ + return X509_STORE_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_new(PyObject *self, PyObject *noarg) +{ + X509_STORE * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(180)); +} +#else +# define _cffi_f_X509_STORE_new _cffi_d_X509_STORE_new +#endif + +static int _cffi_d_X509_STORE_set1_param(X509_STORE * x0, X509_VERIFY_PARAM * x1) +{ + return X509_STORE_set1_param(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_set1_param(PyObject *self, PyObject *args) +{ + X509_STORE * x0; + X509_VERIFY_PARAM * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_set1_param", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(180), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2085), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_set1_param(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_set1_param _cffi_d_X509_STORE_set1_param +#endif + +static int _cffi_d_X509_STORE_set_default_paths(X509_STORE * x0) +{ + return X509_STORE_set_default_paths(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_set_default_paths(PyObject *self, PyObject *arg0) +{ + X509_STORE * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(180), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_set_default_paths(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_set_default_paths _cffi_d_X509_STORE_set_default_paths +#endif + +static int _cffi_d_X509_STORE_set_flags(X509_STORE * x0, unsigned long x1) +{ + return X509_STORE_set_flags(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_set_flags(PyObject *self, PyObject *args) +{ + X509_STORE * x0; + unsigned long x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_set_flags", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(180), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_STORE_set_flags(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_STORE_set_flags _cffi_d_X509_STORE_set_flags +#endif + +static void _cffi_d_X509_STORE_set_get_issuer(X509_STORE * x0, int(* x1)(X509 * *, X509_STORE_CTX *, X509 *)) +{ + X509_STORE_set_get_issuer(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_STORE_set_get_issuer(PyObject *self, PyObject *args) +{ + X509_STORE * x0; + int(* x1)(X509 * *, X509_STORE_CTX *, X509 *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_STORE_set_get_issuer", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(180), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(180), arg0) < 0) + return NULL; + } + + x1 = (int(*)(X509 * *, X509_STORE_CTX *, X509 *))_cffi_to_c_pointer(arg1, _cffi_type(2926)); + if (x1 == (int(*)(X509 * *, X509_STORE_CTX *, X509 *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_STORE_set_get_issuer(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_STORE_set_get_issuer _cffi_d_X509_STORE_set_get_issuer +#endif + +static int _cffi_d_X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM * x0, ASN1_OBJECT * x1) +{ + return X509_VERIFY_PARAM_add0_policy(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_add0_policy(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + ASN1_OBJECT * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_add0_policy", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(607), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OBJECT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(607), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_add0_policy(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_add0_policy _cffi_d_X509_VERIFY_PARAM_add0_policy +#endif + +static int _cffi_d_X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM * x0, unsigned long x1) +{ + return X509_VERIFY_PARAM_clear_flags(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_clear_flags(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + unsigned long x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_clear_flags", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_clear_flags(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_clear_flags _cffi_d_X509_VERIFY_PARAM_clear_flags +#endif + +static void _cffi_d_X509_VERIFY_PARAM_free(X509_VERIFY_PARAM * x0) +{ + X509_VERIFY_PARAM_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_free(PyObject *self, PyObject *arg0) +{ + X509_VERIFY_PARAM * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_VERIFY_PARAM_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_VERIFY_PARAM_free _cffi_d_X509_VERIFY_PARAM_free +#endif + +static int _cffi_d_X509_VERIFY_PARAM_get_depth(X509_VERIFY_PARAM const * x0) +{ + return X509_VERIFY_PARAM_get_depth(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_get_depth(PyObject *self, PyObject *arg0) +{ + X509_VERIFY_PARAM const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2149), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2149), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_get_depth(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_get_depth _cffi_d_X509_VERIFY_PARAM_get_depth +#endif + +static unsigned long _cffi_d_X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM * x0) +{ + return X509_VERIFY_PARAM_get_flags(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_get_flags(PyObject *self, PyObject *arg0) +{ + X509_VERIFY_PARAM * x0; + Py_ssize_t datasize; + unsigned long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_get_flags(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_get_flags _cffi_d_X509_VERIFY_PARAM_get_flags +#endif + +static X509_VERIFY_PARAM * _cffi_d_X509_VERIFY_PARAM_new(void) +{ + return X509_VERIFY_PARAM_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_new(PyObject *self, PyObject *noarg) +{ + X509_VERIFY_PARAM * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(2085)); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_new _cffi_d_X509_VERIFY_PARAM_new +#endif + +static int _cffi_d_X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM * x0, char const * x1, size_t x2) +{ + return X509_VERIFY_PARAM_set1_email(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_set1_email(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + char const * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_set1_email", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_set1_email(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_set1_email _cffi_d_X509_VERIFY_PARAM_set1_email +#endif + +static int _cffi_d_X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM * x0, char const * x1, size_t x2) +{ + return X509_VERIFY_PARAM_set1_host(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_set1_host(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + char const * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_set1_host", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_set1_host(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_set1_host _cffi_d_X509_VERIFY_PARAM_set1_host +#endif + +static int _cffi_d_X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM * x0, unsigned char const * x1, size_t x2) +{ + return X509_VERIFY_PARAM_set1_ip(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_set1_ip(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + unsigned char const * x1; + size_t x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_set1_ip", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(103), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(103), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, size_t); + if (x2 == (size_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_set1_ip(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_set1_ip _cffi_d_X509_VERIFY_PARAM_set1_ip +#endif + +static int _cffi_d_X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM * x0, char const * x1) +{ + return X509_VERIFY_PARAM_set1_ip_asc(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_set1_ip_asc(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + char const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_set1_ip_asc", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(46), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (char const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(46), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_set1_ip_asc(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_set1_ip_asc _cffi_d_X509_VERIFY_PARAM_set1_ip_asc +#endif + +static int _cffi_d_X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM * x0, Cryptography_STACK_OF_ASN1_OBJECT * x1) +{ + return X509_VERIFY_PARAM_set1_policies(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_set1_policies(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + Cryptography_STACK_OF_ASN1_OBJECT * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_set1_policies", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(36), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (Cryptography_STACK_OF_ASN1_OBJECT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(36), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_set1_policies(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_set1_policies _cffi_d_X509_VERIFY_PARAM_set1_policies +#endif + +static void _cffi_d_X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM * x0, int x1) +{ + X509_VERIFY_PARAM_set_depth(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_set_depth(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + int x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_set_depth", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_VERIFY_PARAM_set_depth(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_VERIFY_PARAM_set_depth _cffi_d_X509_VERIFY_PARAM_set_depth +#endif + +static int _cffi_d_X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM * x0, unsigned long x1) +{ + return X509_VERIFY_PARAM_set_flags(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_set_flags(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + unsigned long x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_set_flags", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned long); + if (x1 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_set_flags(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_set_flags _cffi_d_X509_VERIFY_PARAM_set_flags +#endif + +static void _cffi_d_X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM * x0, unsigned int x1) +{ + X509_VERIFY_PARAM_set_hostflags(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_set_hostflags(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + unsigned int x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_set_hostflags", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, unsigned int); + if (x1 == (unsigned int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_VERIFY_PARAM_set_hostflags(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_VERIFY_PARAM_set_hostflags _cffi_d_X509_VERIFY_PARAM_set_hostflags +#endif + +static int _cffi_d_X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM * x0, int x1) +{ + return X509_VERIFY_PARAM_set_purpose(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_set_purpose(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + int x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_set_purpose", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_set_purpose(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_set_purpose _cffi_d_X509_VERIFY_PARAM_set_purpose +#endif + +static void _cffi_d_X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM * x0, time_t x1) +{ + X509_VERIFY_PARAM_set_time(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_set_time(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + time_t x1; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_set_time", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, time_t); + if (x1 == (time_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_VERIFY_PARAM_set_time(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_VERIFY_PARAM_set_time _cffi_d_X509_VERIFY_PARAM_set_time +#endif + +static int _cffi_d_X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM * x0, int x1) +{ + return X509_VERIFY_PARAM_set_trust(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_VERIFY_PARAM_set_trust(PyObject *self, PyObject *args) +{ + X509_VERIFY_PARAM * x0; + int x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_VERIFY_PARAM_set_trust", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2085), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_VERIFY_PARAM *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(2085), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_VERIFY_PARAM_set_trust(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_VERIFY_PARAM_set_trust _cffi_d_X509_VERIFY_PARAM_set_trust +#endif + +static int _cffi_d_X509_add_ext(X509 * x0, X509_EXTENSION * x1, int x2) +{ + return X509_add_ext(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_add_ext(PyObject *self, PyObject *args) +{ + X509 * x0; + X509_EXTENSION * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_add_ext", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(40), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_add_ext(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_add_ext _cffi_d_X509_add_ext +#endif + +static unsigned char * _cffi_d_X509_alias_get0(X509 * x0, int * x1) +{ + return X509_alias_get0(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_alias_get0(PyObject *self, PyObject *args) +{ + X509 * x0; + int * x1; + Py_ssize_t datasize; + unsigned char * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_alias_get0", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (int *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1169), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_alias_get0(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(752)); +} +#else +# define _cffi_f_X509_alias_get0 _cffi_d_X509_alias_get0 +#endif + +static int _cffi_d_X509_check_ca(X509 * x0) +{ + return X509_check_ca(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_check_ca(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_check_ca(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_check_ca _cffi_d_X509_check_ca +#endif + +static int _cffi_d_X509_cmp(X509 const * x0, X509 const * x1) +{ + return X509_cmp(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_cmp(PyObject *self, PyObject *args) +{ + X509 const * x0; + X509 const * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_cmp", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(355), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(355), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(355), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(355), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_cmp(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_cmp _cffi_d_X509_cmp +#endif + +static int _cffi_d_X509_digest(X509 const * x0, EVP_MD const * x1, unsigned char * x2, unsigned int * x3) +{ + return X509_digest(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_digest(PyObject *self, PyObject *args) +{ + X509 const * x0; + EVP_MD const * x1; + unsigned char * x2; + unsigned int * x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509_digest", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(355), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(355), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(354), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(752), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (unsigned char *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(752), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1390), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (unsigned int *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(1390), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_digest(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_digest _cffi_d_X509_digest +#endif + +static X509 * _cffi_d_X509_dup(X509 * x0) +{ + return X509_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_dup(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + X509 * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(28)); +} +#else +# define _cffi_f_X509_dup _cffi_d_X509_dup +#endif + +static void _cffi_d_X509_free(X509 * x0) +{ + X509_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_free(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_free _cffi_d_X509_free +#endif + +static void _cffi_d_X509_get0_signature(ASN1_OCTET_STRING const * * x0, X509_ALGOR const * * x1, X509 const * x2) +{ + X509_get0_signature(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get0_signature(PyObject *self, PyObject *args) +{ + ASN1_OCTET_STRING const * * x0; + X509_ALGOR const * * x1; + X509 const * x2; + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_get0_signature", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1566), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING const * *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1566), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(2553), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_ALGOR const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(2553), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(355), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (X509 const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(355), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { X509_get0_signature(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_X509_get0_signature _cffi_d_X509_get0_signature +#endif + +static X509_ALGOR const * _cffi_d_X509_get0_tbs_sigalg(X509 const * x0) +{ + return X509_get0_tbs_sigalg(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get0_tbs_sigalg(PyObject *self, PyObject *arg0) +{ + X509 const * x0; + Py_ssize_t datasize; + X509_ALGOR const * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(355), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(355), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get0_tbs_sigalg(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(3121)); +} +#else +# define _cffi_f_X509_get0_tbs_sigalg _cffi_d_X509_get0_tbs_sigalg +#endif + +static char const * _cffi_d_X509_get_default_cert_dir(void) +{ + return X509_get_default_cert_dir(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_default_cert_dir(PyObject *self, PyObject *noarg) +{ + char const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_default_cert_dir(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_X509_get_default_cert_dir _cffi_d_X509_get_default_cert_dir +#endif + +static char const * _cffi_d_X509_get_default_cert_dir_env(void) +{ + return X509_get_default_cert_dir_env(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_default_cert_dir_env(PyObject *self, PyObject *noarg) +{ + char const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_default_cert_dir_env(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_X509_get_default_cert_dir_env _cffi_d_X509_get_default_cert_dir_env +#endif + +static char const * _cffi_d_X509_get_default_cert_file(void) +{ + return X509_get_default_cert_file(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_default_cert_file(PyObject *self, PyObject *noarg) +{ + char const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_default_cert_file(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_X509_get_default_cert_file _cffi_d_X509_get_default_cert_file +#endif + +static char const * _cffi_d_X509_get_default_cert_file_env(void) +{ + return X509_get_default_cert_file_env(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_default_cert_file_env(PyObject *self, PyObject *noarg) +{ + char const * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_default_cert_file_env(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_X509_get_default_cert_file_env _cffi_d_X509_get_default_cert_file_env +#endif + +static X509_EXTENSION * _cffi_d_X509_get_ext(X509 * x0, int x1) +{ + return X509_get_ext(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_ext(PyObject *self, PyObject *args) +{ + X509 * x0; + int x1; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_get_ext", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_ext(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_X509_get_ext _cffi_d_X509_get_ext +#endif + +static int _cffi_d_X509_get_ext_count(X509 * x0) +{ + return X509_get_ext_count(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_ext_count(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_ext_count(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_get_ext_count _cffi_d_X509_get_ext_count +#endif + +static void * _cffi_d_X509_get_ext_d2i(X509 * x0, int x1, int * x2, int * x3) +{ + return X509_get_ext_d2i(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_ext_d2i(PyObject *self, PyObject *args) +{ + X509 * x0; + int x1; + int * x2; + int * x3; + Py_ssize_t datasize; + void * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509_get_ext_d2i", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (int *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(1169), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1169), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (int *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(1169), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_ext_d2i(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(193)); +} +#else +# define _cffi_f_X509_get_ext_d2i _cffi_d_X509_get_ext_d2i +#endif + +static X509_NAME * _cffi_d_X509_get_issuer_name(X509 * x0) +{ + return X509_get_issuer_name(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_issuer_name(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + X509_NAME * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_issuer_name(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(643)); +} +#else +# define _cffi_f_X509_get_issuer_name _cffi_d_X509_get_issuer_name +#endif + +static ASN1_OCTET_STRING * _cffi_d_X509_get_notAfter(X509 * x0) +{ + return X509_get_notAfter(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_notAfter(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + ASN1_OCTET_STRING * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_notAfter(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_X509_get_notAfter _cffi_d_X509_get_notAfter +#endif + +static ASN1_OCTET_STRING * _cffi_d_X509_get_notBefore(X509 * x0) +{ + return X509_get_notBefore(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_notBefore(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + ASN1_OCTET_STRING * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_notBefore(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_X509_get_notBefore _cffi_d_X509_get_notBefore +#endif + +static EVP_PKEY * _cffi_d_X509_get_pubkey(X509 * x0) +{ + return X509_get_pubkey(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_pubkey(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + EVP_PKEY * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_pubkey(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_X509_get_pubkey _cffi_d_X509_get_pubkey +#endif + +static ASN1_INTEGER * _cffi_d_X509_get_serialNumber(X509 * x0) +{ + return X509_get_serialNumber(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_serialNumber(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + ASN1_INTEGER * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_serialNumber(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(21)); +} +#else +# define _cffi_f_X509_get_serialNumber _cffi_d_X509_get_serialNumber +#endif + +static int _cffi_d_X509_get_signature_nid(X509 const * x0) +{ + return X509_get_signature_nid(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_signature_nid(PyObject *self, PyObject *arg0) +{ + X509 const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(355), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(355), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_signature_nid(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_get_signature_nid _cffi_d_X509_get_signature_nid +#endif + +static X509_NAME * _cffi_d_X509_get_subject_name(X509 * x0) +{ + return X509_get_subject_name(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_subject_name(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + X509_NAME * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_subject_name(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(643)); +} +#else +# define _cffi_f_X509_get_subject_name _cffi_d_X509_get_subject_name +#endif + +static long _cffi_d_X509_get_version(X509 * x0) +{ + return X509_get_version(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_get_version(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_get_version(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, long); +} +#else +# define _cffi_f_X509_get_version _cffi_d_X509_get_version +#endif + +static ASN1_OCTET_STRING * _cffi_d_X509_getm_notAfter(X509 * x0) +{ + return X509_getm_notAfter(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_getm_notAfter(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + ASN1_OCTET_STRING * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_getm_notAfter(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_X509_getm_notAfter _cffi_d_X509_getm_notAfter +#endif + +static ASN1_OCTET_STRING * _cffi_d_X509_getm_notBefore(X509 * x0) +{ + return X509_getm_notBefore(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_getm_notBefore(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + ASN1_OCTET_STRING * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_getm_notBefore(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_X509_getm_notBefore _cffi_d_X509_getm_notBefore +#endif + +static ASN1_OCTET_STRING * _cffi_d_X509_gmtime_adj(ASN1_OCTET_STRING * x0, long x1) +{ + return X509_gmtime_adj(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_gmtime_adj(PyObject *self, PyObject *args) +{ + ASN1_OCTET_STRING * x0; + long x1; + Py_ssize_t datasize; + ASN1_OCTET_STRING * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_gmtime_adj", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(13), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_gmtime_adj(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(13)); +} +#else +# define _cffi_f_X509_gmtime_adj _cffi_d_X509_gmtime_adj +#endif + +static X509 * _cffi_d_X509_new(void) +{ + return X509_new(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_new(PyObject *self, PyObject *noarg) +{ + X509 * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_new(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(28)); +} +#else +# define _cffi_f_X509_new _cffi_d_X509_new +#endif + +static int _cffi_d_X509_print_ex(BIO * x0, X509 * x1, unsigned long x2, unsigned long x3) +{ + return X509_print_ex(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_print_ex(PyObject *self, PyObject *args) +{ + BIO * x0; + X509 * x1; + unsigned long x2; + unsigned long x3; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "X509_print_ex", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, unsigned long); + if (x2 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + x3 = _cffi_to_c_int(arg3, unsigned long); + if (x3 == (unsigned long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_print_ex(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_print_ex _cffi_d_X509_print_ex +#endif + +static int _cffi_d_X509_set1_notAfter(X509 * x0, ASN1_OCTET_STRING * x1) +{ + return X509_set1_notAfter(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_set1_notAfter(PyObject *self, PyObject *args) +{ + X509 * x0; + ASN1_OCTET_STRING * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_set1_notAfter", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(13), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_set1_notAfter(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_set1_notAfter _cffi_d_X509_set1_notAfter +#endif + +static int _cffi_d_X509_set1_notBefore(X509 * x0, ASN1_OCTET_STRING * x1) +{ + return X509_set1_notBefore(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_set1_notBefore(PyObject *self, PyObject *args) +{ + X509 * x0; + ASN1_OCTET_STRING * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_set1_notBefore", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(13), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_set1_notBefore(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_set1_notBefore _cffi_d_X509_set1_notBefore +#endif + +static int _cffi_d_X509_set_issuer_name(X509 * x0, X509_NAME * x1) +{ + return X509_set_issuer_name(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_set_issuer_name(PyObject *self, PyObject *args) +{ + X509 * x0; + X509_NAME * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_set_issuer_name", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(643), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_set_issuer_name(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_set_issuer_name _cffi_d_X509_set_issuer_name +#endif + +static int _cffi_d_X509_set_notAfter(X509 * x0, ASN1_OCTET_STRING * x1) +{ + return X509_set_notAfter(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_set_notAfter(PyObject *self, PyObject *args) +{ + X509 * x0; + ASN1_OCTET_STRING * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_set_notAfter", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(13), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_set_notAfter(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_set_notAfter _cffi_d_X509_set_notAfter +#endif + +static int _cffi_d_X509_set_notBefore(X509 * x0, ASN1_OCTET_STRING * x1) +{ + return X509_set_notBefore(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_set_notBefore(PyObject *self, PyObject *args) +{ + X509 * x0; + ASN1_OCTET_STRING * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_set_notBefore", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(13), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OCTET_STRING *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(13), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_set_notBefore(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_set_notBefore _cffi_d_X509_set_notBefore +#endif + +static int _cffi_d_X509_set_pubkey(X509 * x0, EVP_PKEY * x1) +{ + return X509_set_pubkey(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_set_pubkey(PyObject *self, PyObject *args) +{ + X509 * x0; + EVP_PKEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_set_pubkey", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_set_pubkey(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_set_pubkey _cffi_d_X509_set_pubkey +#endif + +static int _cffi_d_X509_set_serialNumber(X509 * x0, ASN1_INTEGER * x1) +{ + return X509_set_serialNumber(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_set_serialNumber(PyObject *self, PyObject *args) +{ + X509 * x0; + ASN1_INTEGER * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_set_serialNumber", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(21), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(21), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_set_serialNumber(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_set_serialNumber _cffi_d_X509_set_serialNumber +#endif + +static int _cffi_d_X509_set_subject_name(X509 * x0, X509_NAME * x1) +{ + return X509_set_subject_name(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_set_subject_name(PyObject *self, PyObject *args) +{ + X509 * x0; + X509_NAME * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_set_subject_name", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(643), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_set_subject_name(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_set_subject_name _cffi_d_X509_set_subject_name +#endif + +static int _cffi_d_X509_set_version(X509 * x0, long x1) +{ + return X509_set_version(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_set_version(PyObject *self, PyObject *args) +{ + X509 * x0; + long x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "X509_set_version", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, long); + if (x1 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_set_version(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_set_version _cffi_d_X509_set_version +#endif + +static int _cffi_d_X509_sign(X509 * x0, EVP_PKEY * x1, EVP_MD const * x2) +{ + return X509_sign(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_sign(PyObject *self, PyObject *args) +{ + X509 * x0; + EVP_PKEY * x1; + EVP_MD const * x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "X509_sign", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(354), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_MD const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(354), arg2) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_sign(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_sign _cffi_d_X509_sign +#endif + +static unsigned long _cffi_d_X509_subject_name_hash(X509 * x0) +{ + return X509_subject_name_hash(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_subject_name_hash(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + unsigned long result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_subject_name_hash(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, unsigned long); +} +#else +# define _cffi_f_X509_subject_name_hash _cffi_d_X509_subject_name_hash +#endif + +static int _cffi_d_X509_up_ref(X509 * x0) +{ + return X509_up_ref(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_up_ref(PyObject *self, PyObject *arg0) +{ + X509 * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_up_ref(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_up_ref _cffi_d_X509_up_ref +#endif + +static int _cffi_d_X509_verify_cert(X509_STORE_CTX * x0) +{ + return X509_verify_cert(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_verify_cert(PyObject *self, PyObject *arg0) +{ + X509_STORE_CTX * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(160), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_STORE_CTX *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(160), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_verify_cert(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_X509_verify_cert _cffi_d_X509_verify_cert +#endif + +static char const * _cffi_d_X509_verify_cert_error_string(long x0) +{ + return X509_verify_cert_error_string(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_X509_verify_cert_error_string(PyObject *self, PyObject *arg0) +{ + long x0; + char const * result; + + x0 = _cffi_to_c_int(arg0, long); + if (x0 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = X509_verify_cert_error_string(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(46)); +} +#else +# define _cffi_f_X509_verify_cert_error_string _cffi_d_X509_verify_cert_error_string +#endif + +static ASN1_TYPE * _cffi_d_d2i_ASN1_TYPE(ASN1_TYPE * * x0, unsigned char const * * x1, long x2) +{ + return d2i_ASN1_TYPE(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_ASN1_TYPE(PyObject *self, PyObject *args) +{ + ASN1_TYPE * * x0; + unsigned char const * * x1; + long x2; + Py_ssize_t datasize; + ASN1_TYPE * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "d2i_ASN1_TYPE", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(74), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_TYPE * *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(74), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(75), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(75), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, long); + if (x2 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_ASN1_TYPE(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(801)); +} +#else +# define _cffi_f_d2i_ASN1_TYPE _cffi_d_d2i_ASN1_TYPE +#endif + +static DH * _cffi_d_d2i_DHparams_bio(BIO * x0, DH * * x1) +{ + return d2i_DHparams_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_DHparams_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + DH * * x1; + Py_ssize_t datasize; + DH * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_DHparams_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(187), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DH * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(187), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_DHparams_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(196)); +} +#else +# define _cffi_f_d2i_DHparams_bio _cffi_d_d2i_DHparams_bio +#endif + +static EC_KEY * _cffi_d_d2i_ECPrivateKey_bio(BIO * x0, EC_KEY * * x1) +{ + return d2i_ECPrivateKey_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_ECPrivateKey_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + EC_KEY * * x1; + Py_ssize_t datasize; + EC_KEY * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_ECPrivateKey_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(227), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_KEY * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(227), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_ECPrivateKey_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(893)); +} +#else +# define _cffi_f_d2i_ECPrivateKey_bio _cffi_d_d2i_ECPrivateKey_bio +#endif + +static EC_KEY * _cffi_d_d2i_EC_PUBKEY_bio(BIO * x0, EC_KEY * * x1) +{ + return d2i_EC_PUBKEY_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_EC_PUBKEY_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + EC_KEY * * x1; + Py_ssize_t datasize; + EC_KEY * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_EC_PUBKEY_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(227), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_KEY * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(227), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_EC_PUBKEY_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(893)); +} +#else +# define _cffi_f_d2i_EC_PUBKEY_bio _cffi_d_d2i_EC_PUBKEY_bio +#endif + +static GENERAL_NAMES * _cffi_d_d2i_GENERAL_NAMES(GENERAL_NAMES * * x0, unsigned char const * * x1, long x2) +{ + return d2i_GENERAL_NAMES(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_GENERAL_NAMES(PyObject *self, PyObject *args) +{ + GENERAL_NAMES * * x0; + unsigned char const * * x1; + long x2; + Py_ssize_t datasize; + GENERAL_NAMES * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "d2i_GENERAL_NAMES", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(322), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (GENERAL_NAMES * *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(322), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(75), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char const * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(75), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, long); + if (x2 == (long)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_GENERAL_NAMES(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(316)); +} +#else +# define _cffi_f_d2i_GENERAL_NAMES _cffi_d_d2i_GENERAL_NAMES +#endif + +static OCSP_REQUEST * _cffi_d_d2i_OCSP_REQUEST_bio(BIO * x0, OCSP_REQUEST * * x1) +{ + return d2i_OCSP_REQUEST_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_OCSP_REQUEST_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + OCSP_REQUEST * * x1; + Py_ssize_t datasize; + OCSP_REQUEST * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_OCSP_REQUEST_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(374), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (OCSP_REQUEST * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(374), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_OCSP_REQUEST_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(365)); +} +#else +# define _cffi_f_d2i_OCSP_REQUEST_bio _cffi_d_d2i_OCSP_REQUEST_bio +#endif + +static OCSP_RESPONSE * _cffi_d_d2i_OCSP_RESPONSE_bio(BIO * x0, OCSP_RESPONSE * * x1) +{ + return d2i_OCSP_RESPONSE_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_OCSP_RESPONSE_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + OCSP_RESPONSE * * x1; + Py_ssize_t datasize; + OCSP_RESPONSE * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_OCSP_RESPONSE_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(383), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (OCSP_RESPONSE * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(383), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_OCSP_RESPONSE_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(349)); +} +#else +# define _cffi_f_d2i_OCSP_RESPONSE_bio _cffi_d_d2i_OCSP_RESPONSE_bio +#endif + +static PKCS12 * _cffi_d_d2i_PKCS12_bio(BIO * x0, PKCS12 * * x1) +{ + return d2i_PKCS12_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_PKCS12_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + PKCS12 * * x1; + Py_ssize_t datasize; + PKCS12 * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_PKCS12_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(406), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (PKCS12 * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(406), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_PKCS12_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(940)); +} +#else +# define _cffi_f_d2i_PKCS12_bio _cffi_d_d2i_PKCS12_bio +#endif + +static PKCS7 * _cffi_d_d2i_PKCS7_bio(BIO * x0, PKCS7 * * x1) +{ + return d2i_PKCS7_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_PKCS7_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + PKCS7 * * x1; + Py_ssize_t datasize; + PKCS7 * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_PKCS7_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(426), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (PKCS7 * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(426), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_PKCS7_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(442)); +} +#else +# define _cffi_f_d2i_PKCS7_bio _cffi_d_d2i_PKCS7_bio +#endif + +static EVP_PKEY * _cffi_d_d2i_PKCS8PrivateKey_bio(BIO * x0, EVP_PKEY * * x1, int(* x2)(char *, int, int, void *), void * x3) +{ + return d2i_PKCS8PrivateKey_bio(x0, x1, x2, x3); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_PKCS8PrivateKey_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + EVP_PKEY * * x1; + int(* x2)(char *, int, int, void *); + void * x3; + Py_ssize_t datasize; + EVP_PKEY * result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + + if (!PyArg_UnpackTuple(args, "d2i_PKCS8PrivateKey_bio", 4, 4, &arg0, &arg1, &arg2, &arg3)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(273), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(273), arg1) < 0) + return NULL; + } + + x2 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg2, _cffi_type(192)); + if (x2 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (void *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(193), arg3) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_PKCS8PrivateKey_bio(x0, x1, x2, x3); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_d2i_PKCS8PrivateKey_bio _cffi_d_d2i_PKCS8PrivateKey_bio +#endif + +static EVP_PKEY * _cffi_d_d2i_PUBKEY_bio(BIO * x0, EVP_PKEY * * x1) +{ + return d2i_PUBKEY_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_PUBKEY_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + EVP_PKEY * * x1; + Py_ssize_t datasize; + EVP_PKEY * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_PUBKEY_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(273), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(273), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_PUBKEY_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_d2i_PUBKEY_bio _cffi_d_d2i_PUBKEY_bio +#endif + +static EVP_PKEY * _cffi_d_d2i_PrivateKey_bio(BIO * x0, EVP_PKEY * * x1) +{ + return d2i_PrivateKey_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_PrivateKey_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + EVP_PKEY * * x1; + Py_ssize_t datasize; + EVP_PKEY * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_PrivateKey_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(273), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(273), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_PrivateKey_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(199)); +} +#else +# define _cffi_f_d2i_PrivateKey_bio _cffi_d_d2i_PrivateKey_bio +#endif + +static RSA * _cffi_d_d2i_RSAPublicKey_bio(BIO * x0, RSA * * x1) +{ + return d2i_RSAPublicKey_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_RSAPublicKey_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + RSA * * x1; + Py_ssize_t datasize; + RSA * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_RSAPublicKey_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(464), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (RSA * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(464), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_RSAPublicKey_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(476)); +} +#else +# define _cffi_f_d2i_RSAPublicKey_bio _cffi_d_d2i_RSAPublicKey_bio +#endif + +static X509_CRL * _cffi_d_d2i_X509_CRL_bio(BIO * x0, X509_CRL * * x1) +{ + return d2i_X509_CRL_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_X509_CRL_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_CRL * * x1; + Py_ssize_t datasize; + X509_CRL * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_X509_CRL_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(556), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_CRL * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(556), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_X509_CRL_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(57)); +} +#else +# define _cffi_f_d2i_X509_CRL_bio _cffi_d_d2i_X509_CRL_bio +#endif + +static X509_REQ * _cffi_d_d2i_X509_REQ_bio(BIO * x0, X509_REQ * * x1) +{ + return d2i_X509_REQ_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_X509_REQ_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_REQ * * x1; + Py_ssize_t datasize; + X509_REQ * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_X509_REQ_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(671), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_REQ * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(671), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_X509_REQ_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(294)); +} +#else +# define _cffi_f_d2i_X509_REQ_bio _cffi_d_d2i_X509_REQ_bio +#endif + +static X509 * _cffi_d_d2i_X509_bio(BIO * x0, X509 * * x1) +{ + return d2i_X509_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_d2i_X509_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + X509 * * x1; + Py_ssize_t datasize; + X509 * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "d2i_X509_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(518), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(518), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = d2i_X509_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(28)); +} +#else +# define _cffi_f_d2i_X509_bio _cffi_d_d2i_X509_bio +#endif + +static int _cffi_d_i2a_ASN1_INTEGER(BIO * x0, ASN1_INTEGER * x1) +{ + return i2a_ASN1_INTEGER(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2a_ASN1_INTEGER(PyObject *self, PyObject *args) +{ + BIO * x0; + ASN1_INTEGER * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2a_ASN1_INTEGER", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(21), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(21), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2a_ASN1_INTEGER(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2a_ASN1_INTEGER _cffi_d_i2a_ASN1_INTEGER +#endif + +static int _cffi_d_i2d_ASN1_TYPE(ASN1_TYPE * x0, unsigned char * * x1) +{ + return i2d_ASN1_TYPE(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_ASN1_TYPE(PyObject *self, PyObject *args) +{ + ASN1_TYPE * x0; + unsigned char * * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_ASN1_TYPE", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(801), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (ASN1_TYPE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(801), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(802), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_ASN1_TYPE(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_ASN1_TYPE _cffi_d_i2d_ASN1_TYPE +#endif + +static int _cffi_d_i2d_DHparams_bio(BIO * x0, DH * x1) +{ + return i2d_DHparams_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_DHparams_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + DH * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_DHparams_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(196), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DH *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(196), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_DHparams_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_DHparams_bio _cffi_d_i2d_DHparams_bio +#endif + +static int _cffi_d_i2d_DSAPrivateKey_bio(BIO * x0, DSA * x1) +{ + return i2d_DSAPrivateKey_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_DSAPrivateKey_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + DSA * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_DSAPrivateKey_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(212), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DSA *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(212), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_DSAPrivateKey_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_DSAPrivateKey_bio _cffi_d_i2d_DSAPrivateKey_bio +#endif + +static int _cffi_d_i2d_ECPrivateKey_bio(BIO * x0, EC_KEY * x1) +{ + return i2d_ECPrivateKey_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_ECPrivateKey_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + EC_KEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_ECPrivateKey_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(893), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_ECPrivateKey_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_ECPrivateKey_bio _cffi_d_i2d_ECPrivateKey_bio +#endif + +static int _cffi_d_i2d_EC_PUBKEY_bio(BIO * x0, EC_KEY * x1) +{ + return i2d_EC_PUBKEY_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_EC_PUBKEY_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + EC_KEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_EC_PUBKEY_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(893), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EC_KEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(893), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_EC_PUBKEY_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_EC_PUBKEY_bio _cffi_d_i2d_EC_PUBKEY_bio +#endif + +static int _cffi_d_i2d_GENERAL_NAMES(GENERAL_NAMES * x0, unsigned char * * x1) +{ + return i2d_GENERAL_NAMES(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_GENERAL_NAMES(PyObject *self, PyObject *args) +{ + GENERAL_NAMES * x0; + unsigned char * * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_GENERAL_NAMES", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(316), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (GENERAL_NAMES *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(316), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(802), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_GENERAL_NAMES(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_GENERAL_NAMES _cffi_d_i2d_GENERAL_NAMES +#endif + +static int _cffi_d_i2d_OCSP_REQUEST_bio(BIO * x0, OCSP_REQUEST * x1) +{ + return i2d_OCSP_REQUEST_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_OCSP_REQUEST_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + OCSP_REQUEST * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_OCSP_REQUEST_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(365), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (OCSP_REQUEST *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(365), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_OCSP_REQUEST_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_OCSP_REQUEST_bio _cffi_d_i2d_OCSP_REQUEST_bio +#endif + +static int _cffi_d_i2d_OCSP_RESPDATA(OCSP_RESPDATA * x0, unsigned char * * x1) +{ + return i2d_OCSP_RESPDATA(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_OCSP_RESPDATA(PyObject *self, PyObject *args) +{ + OCSP_RESPDATA * x0; + unsigned char * * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_OCSP_RESPDATA", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1578), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (OCSP_RESPDATA *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1578), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(802), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_OCSP_RESPDATA(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_OCSP_RESPDATA _cffi_d_i2d_OCSP_RESPDATA +#endif + +static int _cffi_d_i2d_OCSP_RESPONSE_bio(BIO * x0, OCSP_RESPONSE * x1) +{ + return i2d_OCSP_RESPONSE_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_OCSP_RESPONSE_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + OCSP_RESPONSE * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_OCSP_RESPONSE_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(349), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (OCSP_RESPONSE *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(349), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_OCSP_RESPONSE_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_OCSP_RESPONSE_bio _cffi_d_i2d_OCSP_RESPONSE_bio +#endif + +static int _cffi_d_i2d_PKCS12_bio(BIO * x0, PKCS12 * x1) +{ + return i2d_PKCS12_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_PKCS12_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + PKCS12 * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_PKCS12_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(940), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (PKCS12 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(940), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_PKCS12_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_PKCS12_bio _cffi_d_i2d_PKCS12_bio +#endif + +static int _cffi_d_i2d_PKCS7_bio(BIO * x0, PKCS7 * x1) +{ + return i2d_PKCS7_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_PKCS7_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + PKCS7 * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_PKCS7_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(442), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (PKCS7 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(442), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_PKCS7_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_PKCS7_bio _cffi_d_i2d_PKCS7_bio +#endif + +static int _cffi_d_i2d_PKCS8PrivateKey_bio(BIO * x0, EVP_PKEY * x1, EVP_CIPHER const * x2, char * x3, int x4, int(* x5)(char *, int, int, void *), void * x6) +{ + return i2d_PKCS8PrivateKey_bio(x0, x1, x2, x3, x4, x5, x6); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_PKCS8PrivateKey_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + EVP_PKEY * x1; + EVP_CIPHER const * x2; + char * x3; + int x4; + int(* x5)(char *, int, int, void *); + void * x6; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + PyObject *arg3; + PyObject *arg4; + PyObject *arg5; + PyObject *arg6; + + if (!PyArg_UnpackTuple(args, "i2d_PKCS8PrivateKey_bio", 7, 7, &arg0, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(885), arg2, (char **)&x2); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x2 = (EVP_CIPHER const *)alloca((size_t)datasize); + memset((void *)x2, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x2, _cffi_type(885), arg2) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(409), arg3, (char **)&x3); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x3 = (char *)alloca((size_t)datasize); + memset((void *)x3, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x3, _cffi_type(409), arg3) < 0) + return NULL; + } + + x4 = _cffi_to_c_int(arg4, int); + if (x4 == (int)-1 && PyErr_Occurred()) + return NULL; + + x5 = (int(*)(char *, int, int, void *))_cffi_to_c_pointer(arg5, _cffi_type(192)); + if (x5 == (int(*)(char *, int, int, void *))NULL && PyErr_Occurred()) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(193), arg6, (char **)&x6); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x6 = (void *)alloca((size_t)datasize); + memset((void *)x6, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x6, _cffi_type(193), arg6) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_PKCS8PrivateKey_bio(x0, x1, x2, x3, x4, x5, x6); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_PKCS8PrivateKey_bio _cffi_d_i2d_PKCS8PrivateKey_bio +#endif + +static int _cffi_d_i2d_PUBKEY_bio(BIO * x0, EVP_PKEY * x1) +{ + return i2d_PUBKEY_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_PUBKEY_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + EVP_PKEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_PUBKEY_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_PUBKEY_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_PUBKEY_bio _cffi_d_i2d_PUBKEY_bio +#endif + +static int _cffi_d_i2d_PrivateKey_bio(BIO * x0, EVP_PKEY * x1) +{ + return i2d_PrivateKey_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_PrivateKey_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + EVP_PKEY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_PrivateKey_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(199), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (EVP_PKEY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(199), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_PrivateKey_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_PrivateKey_bio _cffi_d_i2d_PrivateKey_bio +#endif + +static int _cffi_d_i2d_RSAPrivateKey_bio(BIO * x0, RSA * x1) +{ + return i2d_RSAPrivateKey_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_RSAPrivateKey_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + RSA * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_RSAPrivateKey_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (RSA *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(476), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_RSAPrivateKey_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_RSAPrivateKey_bio _cffi_d_i2d_RSAPrivateKey_bio +#endif + +static int _cffi_d_i2d_RSAPublicKey_bio(BIO * x0, RSA * x1) +{ + return i2d_RSAPublicKey_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_RSAPublicKey_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + RSA * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_RSAPublicKey_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(476), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (RSA *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(476), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_RSAPublicKey_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_RSAPublicKey_bio _cffi_d_i2d_RSAPublicKey_bio +#endif + +static int _cffi_d_i2d_X509_CRL_bio(BIO * x0, X509_CRL * x1) +{ + return i2d_X509_CRL_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_X509_CRL_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_CRL * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_X509_CRL_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(57), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_X509_CRL_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_X509_CRL_bio _cffi_d_i2d_X509_CRL_bio +#endif + +static int _cffi_d_i2d_X509_NAME(X509_NAME * x0, unsigned char * * x1) +{ + return i2d_X509_NAME(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_X509_NAME(PyObject *self, PyObject *args) +{ + X509_NAME * x0; + unsigned char * * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_X509_NAME", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(643), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(802), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_X509_NAME(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_X509_NAME _cffi_d_i2d_X509_NAME +#endif + +static int _cffi_d_i2d_X509_REQ_bio(BIO * x0, X509_REQ * x1) +{ + return i2d_X509_REQ_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_X509_REQ_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + X509_REQ * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_X509_REQ_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(294), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_X509_REQ_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_X509_REQ_bio _cffi_d_i2d_X509_REQ_bio +#endif + +static int _cffi_d_i2d_X509_bio(BIO * x0, X509 * x1) +{ + return i2d_X509_bio(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_X509_bio(PyObject *self, PyObject *args) +{ + BIO * x0; + X509 * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_X509_bio", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(186), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (BIO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(186), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_X509_bio(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_X509_bio _cffi_d_i2d_X509_bio +#endif + +static int _cffi_d_i2d_re_X509_CRL_tbs(X509_CRL * x0, unsigned char * * x1) +{ + return i2d_re_X509_CRL_tbs(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_re_X509_CRL_tbs(PyObject *self, PyObject *args) +{ + X509_CRL * x0; + unsigned char * * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_re_X509_CRL_tbs", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(57), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(802), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_re_X509_CRL_tbs(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_re_X509_CRL_tbs _cffi_d_i2d_re_X509_CRL_tbs +#endif + +static int _cffi_d_i2d_re_X509_REQ_tbs(X509_REQ * x0, unsigned char * * x1) +{ + return i2d_re_X509_REQ_tbs(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_re_X509_REQ_tbs(PyObject *self, PyObject *args) +{ + X509_REQ * x0; + unsigned char * * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_re_X509_REQ_tbs", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(294), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_REQ *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(294), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(802), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_re_X509_REQ_tbs(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_re_X509_REQ_tbs _cffi_d_i2d_re_X509_REQ_tbs +#endif + +static int _cffi_d_i2d_re_X509_tbs(X509 * x0, unsigned char * * x1) +{ + return i2d_re_X509_tbs(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_i2d_re_X509_tbs(PyObject *self, PyObject *args) +{ + X509 * x0; + unsigned char * * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "i2d_re_X509_tbs", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(28), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(802), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (unsigned char * *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(802), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = i2d_re_X509_tbs(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_i2d_re_X509_tbs _cffi_d_i2d_re_X509_tbs +#endif + +static void _cffi_d_sk_ACCESS_DESCRIPTION_free(Cryptography_STACK_OF_ACCESS_DESCRIPTION * x0) +{ + sk_ACCESS_DESCRIPTION_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ACCESS_DESCRIPTION_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_ACCESS_DESCRIPTION * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ACCESS_DESCRIPTION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_ACCESS_DESCRIPTION_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_ACCESS_DESCRIPTION_free _cffi_d_sk_ACCESS_DESCRIPTION_free +#endif + +static Cryptography_STACK_OF_ACCESS_DESCRIPTION * _cffi_d_sk_ACCESS_DESCRIPTION_new_null(void) +{ + return sk_ACCESS_DESCRIPTION_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ACCESS_DESCRIPTION_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_ACCESS_DESCRIPTION * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ACCESS_DESCRIPTION_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1)); +} +#else +# define _cffi_f_sk_ACCESS_DESCRIPTION_new_null _cffi_d_sk_ACCESS_DESCRIPTION_new_null +#endif + +static int _cffi_d_sk_ACCESS_DESCRIPTION_num(Cryptography_STACK_OF_ACCESS_DESCRIPTION * x0) +{ + return sk_ACCESS_DESCRIPTION_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ACCESS_DESCRIPTION_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_ACCESS_DESCRIPTION * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ACCESS_DESCRIPTION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ACCESS_DESCRIPTION_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_ACCESS_DESCRIPTION_num _cffi_d_sk_ACCESS_DESCRIPTION_num +#endif + +static void _cffi_d_sk_ACCESS_DESCRIPTION_pop_free(Cryptography_STACK_OF_ACCESS_DESCRIPTION * x0, void(* x1)(ACCESS_DESCRIPTION *)) +{ + sk_ACCESS_DESCRIPTION_pop_free(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ACCESS_DESCRIPTION_pop_free(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_ACCESS_DESCRIPTION * x0; + void(* x1)(ACCESS_DESCRIPTION *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_ACCESS_DESCRIPTION_pop_free", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ACCESS_DESCRIPTION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1), arg0) < 0) + return NULL; + } + + x1 = (void(*)(ACCESS_DESCRIPTION *))_cffi_to_c_pointer(arg1, _cffi_type(2586)); + if (x1 == (void(*)(ACCESS_DESCRIPTION *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_ACCESS_DESCRIPTION_pop_free(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_ACCESS_DESCRIPTION_pop_free _cffi_d_sk_ACCESS_DESCRIPTION_pop_free +#endif + +static int _cffi_d_sk_ACCESS_DESCRIPTION_push(Cryptography_STACK_OF_ACCESS_DESCRIPTION * x0, ACCESS_DESCRIPTION * x1) +{ + return sk_ACCESS_DESCRIPTION_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ACCESS_DESCRIPTION_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_ACCESS_DESCRIPTION * x0; + ACCESS_DESCRIPTION * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_ACCESS_DESCRIPTION_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ACCESS_DESCRIPTION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1056), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ACCESS_DESCRIPTION *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1056), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ACCESS_DESCRIPTION_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_ACCESS_DESCRIPTION_push _cffi_d_sk_ACCESS_DESCRIPTION_push +#endif + +static ACCESS_DESCRIPTION * _cffi_d_sk_ACCESS_DESCRIPTION_value(Cryptography_STACK_OF_ACCESS_DESCRIPTION * x0, int x1) +{ + return sk_ACCESS_DESCRIPTION_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ACCESS_DESCRIPTION_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_ACCESS_DESCRIPTION * x0; + int x1; + Py_ssize_t datasize; + ACCESS_DESCRIPTION * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_ACCESS_DESCRIPTION_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ACCESS_DESCRIPTION *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ACCESS_DESCRIPTION_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1056)); +} +#else +# define _cffi_f_sk_ACCESS_DESCRIPTION_value _cffi_d_sk_ACCESS_DESCRIPTION_value +#endif + +static void _cffi_d_sk_ASN1_INTEGER_free(Cryptography_STACK_OF_ASN1_INTEGER * x0) +{ + sk_ASN1_INTEGER_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ASN1_INTEGER_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_ASN1_INTEGER * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(24), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(24), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_ASN1_INTEGER_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_ASN1_INTEGER_free _cffi_d_sk_ASN1_INTEGER_free +#endif + +static Cryptography_STACK_OF_ASN1_INTEGER * _cffi_d_sk_ASN1_INTEGER_new_null(void) +{ + return sk_ASN1_INTEGER_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ASN1_INTEGER_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_ASN1_INTEGER * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ASN1_INTEGER_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(24)); +} +#else +# define _cffi_f_sk_ASN1_INTEGER_new_null _cffi_d_sk_ASN1_INTEGER_new_null +#endif + +static int _cffi_d_sk_ASN1_INTEGER_num(Cryptography_STACK_OF_ASN1_INTEGER * x0) +{ + return sk_ASN1_INTEGER_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ASN1_INTEGER_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_ASN1_INTEGER * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(24), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(24), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ASN1_INTEGER_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_ASN1_INTEGER_num _cffi_d_sk_ASN1_INTEGER_num +#endif + +static int _cffi_d_sk_ASN1_INTEGER_push(Cryptography_STACK_OF_ASN1_INTEGER * x0, ASN1_INTEGER * x1) +{ + return sk_ASN1_INTEGER_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ASN1_INTEGER_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_ASN1_INTEGER * x0; + ASN1_INTEGER * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_ASN1_INTEGER_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(24), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(24), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(21), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(21), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ASN1_INTEGER_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_ASN1_INTEGER_push _cffi_d_sk_ASN1_INTEGER_push +#endif + +static ASN1_INTEGER * _cffi_d_sk_ASN1_INTEGER_value(Cryptography_STACK_OF_ASN1_INTEGER * x0, int x1) +{ + return sk_ASN1_INTEGER_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ASN1_INTEGER_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_ASN1_INTEGER * x0; + int x1; + Py_ssize_t datasize; + ASN1_INTEGER * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_ASN1_INTEGER_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(24), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ASN1_INTEGER *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(24), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ASN1_INTEGER_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(21)); +} +#else +# define _cffi_f_sk_ASN1_INTEGER_value _cffi_d_sk_ASN1_INTEGER_value +#endif + +static void _cffi_d_sk_ASN1_OBJECT_free(Cryptography_STACK_OF_ASN1_OBJECT * x0) +{ + sk_ASN1_OBJECT_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ASN1_OBJECT_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_ASN1_OBJECT * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(36), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ASN1_OBJECT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(36), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_ASN1_OBJECT_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_ASN1_OBJECT_free _cffi_d_sk_ASN1_OBJECT_free +#endif + +static Cryptography_STACK_OF_ASN1_OBJECT * _cffi_d_sk_ASN1_OBJECT_new_null(void) +{ + return sk_ASN1_OBJECT_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ASN1_OBJECT_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_ASN1_OBJECT * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ASN1_OBJECT_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(36)); +} +#else +# define _cffi_f_sk_ASN1_OBJECT_new_null _cffi_d_sk_ASN1_OBJECT_new_null +#endif + +static int _cffi_d_sk_ASN1_OBJECT_num(Cryptography_STACK_OF_ASN1_OBJECT * x0) +{ + return sk_ASN1_OBJECT_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ASN1_OBJECT_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_ASN1_OBJECT * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(36), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ASN1_OBJECT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(36), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ASN1_OBJECT_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_ASN1_OBJECT_num _cffi_d_sk_ASN1_OBJECT_num +#endif + +static int _cffi_d_sk_ASN1_OBJECT_push(Cryptography_STACK_OF_ASN1_OBJECT * x0, ASN1_OBJECT * x1) +{ + return sk_ASN1_OBJECT_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ASN1_OBJECT_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_ASN1_OBJECT * x0; + ASN1_OBJECT * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_ASN1_OBJECT_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(36), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ASN1_OBJECT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(36), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(607), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (ASN1_OBJECT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(607), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ASN1_OBJECT_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_ASN1_OBJECT_push _cffi_d_sk_ASN1_OBJECT_push +#endif + +static ASN1_OBJECT * _cffi_d_sk_ASN1_OBJECT_value(Cryptography_STACK_OF_ASN1_OBJECT * x0, int x1) +{ + return sk_ASN1_OBJECT_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_ASN1_OBJECT_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_ASN1_OBJECT * x0; + int x1; + Py_ssize_t datasize; + ASN1_OBJECT * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_ASN1_OBJECT_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(36), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_ASN1_OBJECT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(36), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_ASN1_OBJECT_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(607)); +} +#else +# define _cffi_f_sk_ASN1_OBJECT_value _cffi_d_sk_ASN1_OBJECT_value +#endif + +static void _cffi_d_sk_DIST_POINT_free(Cryptography_STACK_OF_DIST_POINT * x0) +{ + sk_DIST_POINT_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_DIST_POINT_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_DIST_POINT * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(204), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_DIST_POINT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(204), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_DIST_POINT_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_DIST_POINT_free _cffi_d_sk_DIST_POINT_free +#endif + +static Cryptography_STACK_OF_DIST_POINT * _cffi_d_sk_DIST_POINT_new_null(void) +{ + return sk_DIST_POINT_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_DIST_POINT_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_DIST_POINT * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_DIST_POINT_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(204)); +} +#else +# define _cffi_f_sk_DIST_POINT_new_null _cffi_d_sk_DIST_POINT_new_null +#endif + +static int _cffi_d_sk_DIST_POINT_num(Cryptography_STACK_OF_DIST_POINT * x0) +{ + return sk_DIST_POINT_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_DIST_POINT_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_DIST_POINT * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(204), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_DIST_POINT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(204), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_DIST_POINT_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_DIST_POINT_num _cffi_d_sk_DIST_POINT_num +#endif + +static void _cffi_d_sk_DIST_POINT_pop_free(Cryptography_STACK_OF_DIST_POINT * x0, void(* x1)(DIST_POINT *)) +{ + sk_DIST_POINT_pop_free(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_DIST_POINT_pop_free(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_DIST_POINT * x0; + void(* x1)(DIST_POINT *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_DIST_POINT_pop_free", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(204), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_DIST_POINT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(204), arg0) < 0) + return NULL; + } + + x1 = (void(*)(DIST_POINT *))_cffi_to_c_pointer(arg1, _cffi_type(2599)); + if (x1 == (void(*)(DIST_POINT *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_DIST_POINT_pop_free(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_DIST_POINT_pop_free _cffi_d_sk_DIST_POINT_pop_free +#endif + +static int _cffi_d_sk_DIST_POINT_push(Cryptography_STACK_OF_DIST_POINT * x0, DIST_POINT * x1) +{ + return sk_DIST_POINT_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_DIST_POINT_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_DIST_POINT * x0; + DIST_POINT * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_DIST_POINT_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(204), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_DIST_POINT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(204), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1077), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (DIST_POINT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1077), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_DIST_POINT_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_DIST_POINT_push _cffi_d_sk_DIST_POINT_push +#endif + +static DIST_POINT * _cffi_d_sk_DIST_POINT_value(Cryptography_STACK_OF_DIST_POINT * x0, int x1) +{ + return sk_DIST_POINT_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_DIST_POINT_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_DIST_POINT * x0; + int x1; + Py_ssize_t datasize; + DIST_POINT * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_DIST_POINT_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(204), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_DIST_POINT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(204), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_DIST_POINT_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1077)); +} +#else +# define _cffi_f_sk_DIST_POINT_value _cffi_d_sk_DIST_POINT_value +#endif + +static int _cffi_d_sk_GENERAL_NAME_num(GENERAL_NAMES * x0) +{ + return sk_GENERAL_NAME_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_GENERAL_NAME_num(PyObject *self, PyObject *arg0) +{ + GENERAL_NAMES * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(316), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (GENERAL_NAMES *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(316), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_GENERAL_NAME_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_GENERAL_NAME_num _cffi_d_sk_GENERAL_NAME_num +#endif + +static void _cffi_d_sk_GENERAL_NAME_pop_free(GENERAL_NAMES * x0, void(* x1)(GENERAL_NAME *)) +{ + sk_GENERAL_NAME_pop_free(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_GENERAL_NAME_pop_free(PyObject *self, PyObject *args) +{ + GENERAL_NAMES * x0; + void(* x1)(GENERAL_NAME *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_GENERAL_NAME_pop_free", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(316), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (GENERAL_NAMES *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(316), arg0) < 0) + return NULL; + } + + x1 = (void(*)(GENERAL_NAME *))_cffi_to_c_pointer(arg1, _cffi_type(2696)); + if (x1 == (void(*)(GENERAL_NAME *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_GENERAL_NAME_pop_free(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_GENERAL_NAME_pop_free _cffi_d_sk_GENERAL_NAME_pop_free +#endif + +static int _cffi_d_sk_GENERAL_NAME_push(GENERAL_NAMES * x0, GENERAL_NAME * x1) +{ + return sk_GENERAL_NAME_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_GENERAL_NAME_push(PyObject *self, PyObject *args) +{ + GENERAL_NAMES * x0; + GENERAL_NAME * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_GENERAL_NAME_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(316), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (GENERAL_NAMES *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(316), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(928), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (GENERAL_NAME *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(928), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_GENERAL_NAME_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_GENERAL_NAME_push _cffi_d_sk_GENERAL_NAME_push +#endif + +static GENERAL_NAME * _cffi_d_sk_GENERAL_NAME_value(GENERAL_NAMES * x0, int x1) +{ + return sk_GENERAL_NAME_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_GENERAL_NAME_value(PyObject *self, PyObject *args) +{ + GENERAL_NAMES * x0; + int x1; + Py_ssize_t datasize; + GENERAL_NAME * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_GENERAL_NAME_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(316), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (GENERAL_NAMES *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(316), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_GENERAL_NAME_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(928)); +} +#else +# define _cffi_f_sk_GENERAL_NAME_value _cffi_d_sk_GENERAL_NAME_value +#endif + +static void _cffi_d_sk_GENERAL_SUBTREE_free(Cryptography_STACK_OF_GENERAL_SUBTREE * x0) +{ + sk_GENERAL_SUBTREE_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_GENERAL_SUBTREE_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_GENERAL_SUBTREE * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(329), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_GENERAL_SUBTREE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(329), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_GENERAL_SUBTREE_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_GENERAL_SUBTREE_free _cffi_d_sk_GENERAL_SUBTREE_free +#endif + +static Cryptography_STACK_OF_GENERAL_SUBTREE * _cffi_d_sk_GENERAL_SUBTREE_new_null(void) +{ + return sk_GENERAL_SUBTREE_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_GENERAL_SUBTREE_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_GENERAL_SUBTREE * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_GENERAL_SUBTREE_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(329)); +} +#else +# define _cffi_f_sk_GENERAL_SUBTREE_new_null _cffi_d_sk_GENERAL_SUBTREE_new_null +#endif + +static int _cffi_d_sk_GENERAL_SUBTREE_num(Cryptography_STACK_OF_GENERAL_SUBTREE * x0) +{ + return sk_GENERAL_SUBTREE_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_GENERAL_SUBTREE_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_GENERAL_SUBTREE * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(329), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_GENERAL_SUBTREE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(329), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_GENERAL_SUBTREE_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_GENERAL_SUBTREE_num _cffi_d_sk_GENERAL_SUBTREE_num +#endif + +static int _cffi_d_sk_GENERAL_SUBTREE_push(Cryptography_STACK_OF_GENERAL_SUBTREE * x0, GENERAL_SUBTREE * x1) +{ + return sk_GENERAL_SUBTREE_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_GENERAL_SUBTREE_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_GENERAL_SUBTREE * x0; + GENERAL_SUBTREE * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_GENERAL_SUBTREE_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(329), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_GENERAL_SUBTREE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(329), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1084), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (GENERAL_SUBTREE *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1084), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_GENERAL_SUBTREE_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_GENERAL_SUBTREE_push _cffi_d_sk_GENERAL_SUBTREE_push +#endif + +static GENERAL_SUBTREE * _cffi_d_sk_GENERAL_SUBTREE_value(Cryptography_STACK_OF_GENERAL_SUBTREE * x0, int x1) +{ + return sk_GENERAL_SUBTREE_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_GENERAL_SUBTREE_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_GENERAL_SUBTREE * x0; + int x1; + Py_ssize_t datasize; + GENERAL_SUBTREE * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_GENERAL_SUBTREE_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(329), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_GENERAL_SUBTREE *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(329), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_GENERAL_SUBTREE_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1084)); +} +#else +# define _cffi_f_sk_GENERAL_SUBTREE_value _cffi_d_sk_GENERAL_SUBTREE_value +#endif + +static void _cffi_d_sk_POLICYINFO_free(Cryptography_STACK_OF_POLICYINFO * x0) +{ + sk_POLICYINFO_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_POLICYINFO_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_POLICYINFO * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(449), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_POLICYINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(449), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_POLICYINFO_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_POLICYINFO_free _cffi_d_sk_POLICYINFO_free +#endif + +static Cryptography_STACK_OF_POLICYINFO * _cffi_d_sk_POLICYINFO_new_null(void) +{ + return sk_POLICYINFO_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_POLICYINFO_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_POLICYINFO * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_POLICYINFO_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(449)); +} +#else +# define _cffi_f_sk_POLICYINFO_new_null _cffi_d_sk_POLICYINFO_new_null +#endif + +static int _cffi_d_sk_POLICYINFO_num(Cryptography_STACK_OF_POLICYINFO * x0) +{ + return sk_POLICYINFO_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_POLICYINFO_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_POLICYINFO * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(449), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_POLICYINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(449), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_POLICYINFO_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_POLICYINFO_num _cffi_d_sk_POLICYINFO_num +#endif + +static void _cffi_d_sk_POLICYINFO_pop_free(Cryptography_STACK_OF_POLICYINFO * x0, void(* x1)(POLICYINFO *)) +{ + sk_POLICYINFO_pop_free(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_POLICYINFO_pop_free(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_POLICYINFO * x0; + void(* x1)(POLICYINFO *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_POLICYINFO_pop_free", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(449), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_POLICYINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(449), arg0) < 0) + return NULL; + } + + x1 = (void(*)(POLICYINFO *))_cffi_to_c_pointer(arg1, _cffi_type(2609)); + if (x1 == (void(*)(POLICYINFO *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_POLICYINFO_pop_free(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_POLICYINFO_pop_free _cffi_d_sk_POLICYINFO_pop_free +#endif + +static int _cffi_d_sk_POLICYINFO_push(Cryptography_STACK_OF_POLICYINFO * x0, POLICYINFO * x1) +{ + return sk_POLICYINFO_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_POLICYINFO_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_POLICYINFO * x0; + POLICYINFO * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_POLICYINFO_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(449), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_POLICYINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(449), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1091), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (POLICYINFO *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1091), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_POLICYINFO_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_POLICYINFO_push _cffi_d_sk_POLICYINFO_push +#endif + +static POLICYINFO * _cffi_d_sk_POLICYINFO_value(Cryptography_STACK_OF_POLICYINFO * x0, int x1) +{ + return sk_POLICYINFO_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_POLICYINFO_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_POLICYINFO * x0; + int x1; + Py_ssize_t datasize; + POLICYINFO * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_POLICYINFO_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(449), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_POLICYINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(449), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_POLICYINFO_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1091)); +} +#else +# define _cffi_f_sk_POLICYINFO_value _cffi_d_sk_POLICYINFO_value +#endif + +static void _cffi_d_sk_POLICYQUALINFO_free(Cryptography_STACK_OF_POLICYQUALINFO * x0) +{ + sk_POLICYQUALINFO_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_POLICYQUALINFO_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_POLICYQUALINFO * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(455), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_POLICYQUALINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(455), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_POLICYQUALINFO_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_POLICYQUALINFO_free _cffi_d_sk_POLICYQUALINFO_free +#endif + +static Cryptography_STACK_OF_POLICYQUALINFO * _cffi_d_sk_POLICYQUALINFO_new_null(void) +{ + return sk_POLICYQUALINFO_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_POLICYQUALINFO_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_POLICYQUALINFO * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_POLICYQUALINFO_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(455)); +} +#else +# define _cffi_f_sk_POLICYQUALINFO_new_null _cffi_d_sk_POLICYQUALINFO_new_null +#endif + +static int _cffi_d_sk_POLICYQUALINFO_num(Cryptography_STACK_OF_POLICYQUALINFO * x0) +{ + return sk_POLICYQUALINFO_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_POLICYQUALINFO_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_POLICYQUALINFO * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(455), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_POLICYQUALINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(455), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_POLICYQUALINFO_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_POLICYQUALINFO_num _cffi_d_sk_POLICYQUALINFO_num +#endif + +static int _cffi_d_sk_POLICYQUALINFO_push(Cryptography_STACK_OF_POLICYQUALINFO * x0, POLICYQUALINFO * x1) +{ + return sk_POLICYQUALINFO_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_POLICYQUALINFO_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_POLICYQUALINFO * x0; + POLICYQUALINFO * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_POLICYQUALINFO_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(455), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_POLICYQUALINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(455), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1098), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (POLICYQUALINFO *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1098), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_POLICYQUALINFO_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_POLICYQUALINFO_push _cffi_d_sk_POLICYQUALINFO_push +#endif + +static POLICYQUALINFO * _cffi_d_sk_POLICYQUALINFO_value(Cryptography_STACK_OF_POLICYQUALINFO * x0, int x1) +{ + return sk_POLICYQUALINFO_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_POLICYQUALINFO_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_POLICYQUALINFO * x0; + int x1; + Py_ssize_t datasize; + POLICYQUALINFO * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_POLICYQUALINFO_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(455), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_POLICYQUALINFO *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(455), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_POLICYQUALINFO_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1098)); +} +#else +# define _cffi_f_sk_POLICYQUALINFO_value _cffi_d_sk_POLICYQUALINFO_value +#endif + +static void _cffi_d_sk_SCT_free(Cryptography_STACK_OF_SCT * x0) +{ + sk_SCT_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_SCT_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_SCT * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1101), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_SCT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1101), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_SCT_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_SCT_free _cffi_d_sk_SCT_free +#endif + +static Cryptography_STACK_OF_SCT * _cffi_d_sk_SCT_new_null(void) +{ + return sk_SCT_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_SCT_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_SCT * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_SCT_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1101)); +} +#else +# define _cffi_f_sk_SCT_new_null _cffi_d_sk_SCT_new_null +#endif + +static int _cffi_d_sk_SCT_num(Cryptography_STACK_OF_SCT const * x0) +{ + return sk_SCT_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_SCT_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_SCT const * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(481), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_SCT const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(481), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_SCT_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_SCT_num _cffi_d_sk_SCT_num +#endif + +static int _cffi_d_sk_SCT_push(Cryptography_STACK_OF_SCT * x0, SCT * x1) +{ + return sk_SCT_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_SCT_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_SCT * x0; + SCT * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_SCT_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1101), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_SCT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1101), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1102), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (SCT *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(1102), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_SCT_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_SCT_push _cffi_d_sk_SCT_push +#endif + +static SCT * _cffi_d_sk_SCT_value(Cryptography_STACK_OF_SCT const * x0, int x1) +{ + return sk_SCT_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_SCT_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_SCT const * x0; + int x1; + Py_ssize_t datasize; + SCT * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_SCT_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(481), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_SCT const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(481), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_SCT_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(1102)); +} +#else +# define _cffi_f_sk_SCT_value _cffi_d_sk_SCT_value +#endif + +static int _cffi_d_sk_SSL_CIPHER_num(Cryptography_STACK_OF_SSL_CIPHER * x0) +{ + return sk_SSL_CIPHER_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_SSL_CIPHER_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_SSL_CIPHER * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(493), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_SSL_CIPHER *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(493), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_SSL_CIPHER_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_SSL_CIPHER_num _cffi_d_sk_SSL_CIPHER_num +#endif + +static SSL_CIPHER const * _cffi_d_sk_SSL_CIPHER_value(Cryptography_STACK_OF_SSL_CIPHER * x0, int x1) +{ + return sk_SSL_CIPHER_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_SSL_CIPHER_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_SSL_CIPHER * x0; + int x1; + Py_ssize_t datasize; + SSL_CIPHER const * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_SSL_CIPHER_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(493), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_SSL_CIPHER *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(493), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_SSL_CIPHER_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(733)); +} +#else +# define _cffi_f_sk_SSL_CIPHER_value _cffi_d_sk_SSL_CIPHER_value +#endif + +static void _cffi_d_sk_X509_CRL_free(Cryptography_STACK_OF_X509_CRL * x0) +{ + sk_X509_CRL_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_CRL_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_X509_CRL * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(565), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(565), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_X509_CRL_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_X509_CRL_free _cffi_d_sk_X509_CRL_free +#endif + +static Cryptography_STACK_OF_X509_CRL * _cffi_d_sk_X509_CRL_new_null(void) +{ + return sk_X509_CRL_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_CRL_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_X509_CRL * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_CRL_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(565)); +} +#else +# define _cffi_f_sk_X509_CRL_new_null _cffi_d_sk_X509_CRL_new_null +#endif + +static int _cffi_d_sk_X509_CRL_num(Cryptography_STACK_OF_X509_CRL * x0) +{ + return sk_X509_CRL_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_CRL_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_X509_CRL * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(565), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(565), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_CRL_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_CRL_num _cffi_d_sk_X509_CRL_num +#endif + +static int _cffi_d_sk_X509_CRL_push(Cryptography_STACK_OF_X509_CRL * x0, X509_CRL * x1) +{ + return sk_X509_CRL_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_CRL_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_X509_CRL * x0; + X509_CRL * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_CRL_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(565), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(565), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(57), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_CRL *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(57), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_CRL_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_CRL_push _cffi_d_sk_X509_CRL_push +#endif + +static X509_CRL * _cffi_d_sk_X509_CRL_value(Cryptography_STACK_OF_X509_CRL * x0, int x1) +{ + return sk_X509_CRL_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_CRL_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_X509_CRL * x0; + int x1; + Py_ssize_t datasize; + X509_CRL * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_CRL_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(565), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_CRL *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(565), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_CRL_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(57)); +} +#else +# define _cffi_f_sk_X509_CRL_value _cffi_d_sk_X509_CRL_value +#endif + +static X509_EXTENSION * _cffi_d_sk_X509_EXTENSION_delete(X509_EXTENSIONS * x0, int x1) +{ + return sk_X509_EXTENSION_delete(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_EXTENSION_delete(PyObject *self, PyObject *args) +{ + X509_EXTENSIONS * x0; + int x1; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_EXTENSION_delete", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(615), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSIONS *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(615), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_EXTENSION_delete(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_sk_X509_EXTENSION_delete _cffi_d_sk_X509_EXTENSION_delete +#endif + +static void _cffi_d_sk_X509_EXTENSION_free(X509_EXTENSIONS * x0) +{ + sk_X509_EXTENSION_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_EXTENSION_free(PyObject *self, PyObject *arg0) +{ + X509_EXTENSIONS * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(615), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSIONS *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(615), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_X509_EXTENSION_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_X509_EXTENSION_free _cffi_d_sk_X509_EXTENSION_free +#endif + +static int _cffi_d_sk_X509_EXTENSION_insert(X509_EXTENSIONS * x0, X509_EXTENSION * x1, int x2) +{ + return sk_X509_EXTENSION_insert(x0, x1, x2); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_EXTENSION_insert(PyObject *self, PyObject *args) +{ + X509_EXTENSIONS * x0; + X509_EXTENSION * x1; + int x2; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + PyObject *arg2; + + if (!PyArg_UnpackTuple(args, "sk_X509_EXTENSION_insert", 3, 3, &arg0, &arg1, &arg2)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(615), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSIONS *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(615), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(40), arg1) < 0) + return NULL; + } + + x2 = _cffi_to_c_int(arg2, int); + if (x2 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_EXTENSION_insert(x0, x1, x2); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_EXTENSION_insert _cffi_d_sk_X509_EXTENSION_insert +#endif + +static X509_EXTENSIONS * _cffi_d_sk_X509_EXTENSION_new_null(void) +{ + return sk_X509_EXTENSION_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_EXTENSION_new_null(PyObject *self, PyObject *noarg) +{ + X509_EXTENSIONS * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_EXTENSION_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(615)); +} +#else +# define _cffi_f_sk_X509_EXTENSION_new_null _cffi_d_sk_X509_EXTENSION_new_null +#endif + +static int _cffi_d_sk_X509_EXTENSION_num(X509_EXTENSIONS * x0) +{ + return sk_X509_EXTENSION_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_EXTENSION_num(PyObject *self, PyObject *arg0) +{ + X509_EXTENSIONS * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(615), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSIONS *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(615), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_EXTENSION_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_EXTENSION_num _cffi_d_sk_X509_EXTENSION_num +#endif + +static void _cffi_d_sk_X509_EXTENSION_pop_free(X509_EXTENSIONS * x0, void(* x1)(X509_EXTENSION *)) +{ + sk_X509_EXTENSION_pop_free(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_EXTENSION_pop_free(PyObject *self, PyObject *args) +{ + X509_EXTENSIONS * x0; + void(* x1)(X509_EXTENSION *); + Py_ssize_t datasize; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_EXTENSION_pop_free", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(615), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSIONS *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(615), arg0) < 0) + return NULL; + } + + x1 = (void(*)(X509_EXTENSION *))_cffi_to_c_pointer(arg1, _cffi_type(2902)); + if (x1 == (void(*)(X509_EXTENSION *))NULL && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_X509_EXTENSION_pop_free(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_X509_EXTENSION_pop_free _cffi_d_sk_X509_EXTENSION_pop_free +#endif + +static int _cffi_d_sk_X509_EXTENSION_push(X509_EXTENSIONS * x0, X509_EXTENSION * x1) +{ + return sk_X509_EXTENSION_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_EXTENSION_push(PyObject *self, PyObject *args) +{ + X509_EXTENSIONS * x0; + X509_EXTENSION * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_EXTENSION_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(615), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSIONS *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(615), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(40), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_EXTENSION *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(40), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_EXTENSION_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_EXTENSION_push _cffi_d_sk_X509_EXTENSION_push +#endif + +static X509_EXTENSION * _cffi_d_sk_X509_EXTENSION_value(X509_EXTENSIONS * x0, int x1) +{ + return sk_X509_EXTENSION_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_EXTENSION_value(PyObject *self, PyObject *args) +{ + X509_EXTENSIONS * x0; + int x1; + Py_ssize_t datasize; + X509_EXTENSION * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_EXTENSION_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(615), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (X509_EXTENSIONS *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(615), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_EXTENSION_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(40)); +} +#else +# define _cffi_f_sk_X509_EXTENSION_value _cffi_d_sk_X509_EXTENSION_value +#endif + +static Cryptography_STACK_OF_X509_NAME_ENTRY * _cffi_d_sk_X509_NAME_ENTRY_dup(Cryptography_STACK_OF_X509_NAME_ENTRY * x0) +{ + return sk_X509_NAME_ENTRY_dup(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_NAME_ENTRY_dup(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_X509_NAME_ENTRY * x0; + Py_ssize_t datasize; + Cryptography_STACK_OF_X509_NAME_ENTRY * result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(175), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_NAME_ENTRY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(175), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_NAME_ENTRY_dup(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(175)); +} +#else +# define _cffi_f_sk_X509_NAME_ENTRY_dup _cffi_d_sk_X509_NAME_ENTRY_dup +#endif + +static Cryptography_STACK_OF_X509_NAME_ENTRY * _cffi_d_sk_X509_NAME_ENTRY_new_null(void) +{ + return sk_X509_NAME_ENTRY_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_NAME_ENTRY_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_X509_NAME_ENTRY * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_NAME_ENTRY_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(175)); +} +#else +# define _cffi_f_sk_X509_NAME_ENTRY_new_null _cffi_d_sk_X509_NAME_ENTRY_new_null +#endif + +static int _cffi_d_sk_X509_NAME_ENTRY_num(Cryptography_STACK_OF_X509_NAME_ENTRY * x0) +{ + return sk_X509_NAME_ENTRY_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_NAME_ENTRY_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_X509_NAME_ENTRY * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(175), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_NAME_ENTRY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(175), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_NAME_ENTRY_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_NAME_ENTRY_num _cffi_d_sk_X509_NAME_ENTRY_num +#endif + +static int _cffi_d_sk_X509_NAME_ENTRY_push(Cryptography_STACK_OF_X509_NAME_ENTRY * x0, X509_NAME_ENTRY * x1) +{ + return sk_X509_NAME_ENTRY_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_NAME_ENTRY_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_X509_NAME_ENTRY * x0; + X509_NAME_ENTRY * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_NAME_ENTRY_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(175), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_NAME_ENTRY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(175), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(43), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_NAME_ENTRY *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(43), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_NAME_ENTRY_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_NAME_ENTRY_push _cffi_d_sk_X509_NAME_ENTRY_push +#endif + +static X509_NAME_ENTRY * _cffi_d_sk_X509_NAME_ENTRY_value(Cryptography_STACK_OF_X509_NAME_ENTRY * x0, int x1) +{ + return sk_X509_NAME_ENTRY_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_NAME_ENTRY_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_X509_NAME_ENTRY * x0; + int x1; + Py_ssize_t datasize; + X509_NAME_ENTRY * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_NAME_ENTRY_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(175), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_NAME_ENTRY *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(175), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_NAME_ENTRY_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(43)); +} +#else +# define _cffi_f_sk_X509_NAME_ENTRY_value _cffi_d_sk_X509_NAME_ENTRY_value +#endif + +static void _cffi_d_sk_X509_NAME_free(Cryptography_STACK_OF_X509_NAME * x0) +{ + sk_X509_NAME_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_NAME_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_X509_NAME * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(633), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(633), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_X509_NAME_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_X509_NAME_free _cffi_d_sk_X509_NAME_free +#endif + +static Cryptography_STACK_OF_X509_NAME * _cffi_d_sk_X509_NAME_new_null(void) +{ + return sk_X509_NAME_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_NAME_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_X509_NAME * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_NAME_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(633)); +} +#else +# define _cffi_f_sk_X509_NAME_new_null _cffi_d_sk_X509_NAME_new_null +#endif + +static int _cffi_d_sk_X509_NAME_num(Cryptography_STACK_OF_X509_NAME * x0) +{ + return sk_X509_NAME_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_NAME_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_X509_NAME * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(633), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(633), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_NAME_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_NAME_num _cffi_d_sk_X509_NAME_num +#endif + +static int _cffi_d_sk_X509_NAME_push(Cryptography_STACK_OF_X509_NAME * x0, X509_NAME * x1) +{ + return sk_X509_NAME_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_NAME_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_X509_NAME * x0; + X509_NAME * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_NAME_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(633), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(633), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(643), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509_NAME *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(643), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_NAME_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_NAME_push _cffi_d_sk_X509_NAME_push +#endif + +static X509_NAME * _cffi_d_sk_X509_NAME_value(Cryptography_STACK_OF_X509_NAME * x0, int x1) +{ + return sk_X509_NAME_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_NAME_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_X509_NAME * x0; + int x1; + Py_ssize_t datasize; + X509_NAME * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_NAME_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(633), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_NAME *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(633), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_NAME_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(643)); +} +#else +# define _cffi_f_sk_X509_NAME_value _cffi_d_sk_X509_NAME_value +#endif + +static int _cffi_d_sk_X509_OBJECT_num(Cryptography_STACK_OF_X509_OBJECT * x0) +{ + return sk_X509_OBJECT_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_OBJECT_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_X509_OBJECT * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(666), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_OBJECT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(666), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_OBJECT_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_OBJECT_num _cffi_d_sk_X509_OBJECT_num +#endif + +static X509_OBJECT * _cffi_d_sk_X509_OBJECT_value(Cryptography_STACK_OF_X509_OBJECT * x0, int x1) +{ + return sk_X509_OBJECT_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_OBJECT_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_X509_OBJECT * x0; + int x1; + Py_ssize_t datasize; + X509_OBJECT * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_OBJECT_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(666), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_OBJECT *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(666), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_OBJECT_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(537)); +} +#else +# define _cffi_f_sk_X509_OBJECT_value _cffi_d_sk_X509_OBJECT_value +#endif + +static int _cffi_d_sk_X509_REVOKED_num(Cryptography_STACK_OF_X509_REVOKED * x0) +{ + return sk_X509_REVOKED_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_REVOKED_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_X509_REVOKED * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(682), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(682), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_REVOKED_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_REVOKED_num _cffi_d_sk_X509_REVOKED_num +#endif + +static X509_REVOKED * _cffi_d_sk_X509_REVOKED_value(Cryptography_STACK_OF_X509_REVOKED * x0, int x1) +{ + return sk_X509_REVOKED_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_REVOKED_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_X509_REVOKED * x0; + int x1; + Py_ssize_t datasize; + X509_REVOKED * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_REVOKED_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(682), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509_REVOKED *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(682), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_REVOKED_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(619)); +} +#else +# define _cffi_f_sk_X509_REVOKED_value _cffi_d_sk_X509_REVOKED_value +#endif + +static void _cffi_d_sk_X509_free(Cryptography_STACK_OF_X509 * x0) +{ + sk_X509_free(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_free(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_X509 * x0; + Py_ssize_t datasize; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(413), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(413), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { sk_X509_free(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + Py_INCREF(Py_None); + return Py_None; +} +#else +# define _cffi_f_sk_X509_free _cffi_d_sk_X509_free +#endif + +static Cryptography_STACK_OF_X509 * _cffi_d_sk_X509_new_null(void) +{ + return sk_X509_new_null(); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_new_null(PyObject *self, PyObject *noarg) +{ + Cryptography_STACK_OF_X509 * result; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_new_null(); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + (void)noarg; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(413)); +} +#else +# define _cffi_f_sk_X509_new_null _cffi_d_sk_X509_new_null +#endif + +static int _cffi_d_sk_X509_num(Cryptography_STACK_OF_X509 * x0) +{ + return sk_X509_num(x0); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_num(PyObject *self, PyObject *arg0) +{ + Cryptography_STACK_OF_X509 * x0; + Py_ssize_t datasize; + int result; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(413), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(413), arg0) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_num(x0); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_num _cffi_d_sk_X509_num +#endif + +static int _cffi_d_sk_X509_push(Cryptography_STACK_OF_X509 * x0, X509 * x1) +{ + return sk_X509_push(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_push(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_X509 * x0; + X509 * x1; + Py_ssize_t datasize; + int result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_push", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(413), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(413), arg0) < 0) + return NULL; + } + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(28), arg1, (char **)&x1); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x1 = (X509 *)alloca((size_t)datasize); + memset((void *)x1, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x1, _cffi_type(28), arg1) < 0) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_push(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, int); +} +#else +# define _cffi_f_sk_X509_push _cffi_d_sk_X509_push +#endif + +static X509 * _cffi_d_sk_X509_value(Cryptography_STACK_OF_X509 * x0, int x1) +{ + return sk_X509_value(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_sk_X509_value(PyObject *self, PyObject *args) +{ + Cryptography_STACK_OF_X509 * x0; + int x1; + Py_ssize_t datasize; + X509 * result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "sk_X509_value", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(413), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (Cryptography_STACK_OF_X509 *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(413), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, int); + if (x1 == (int)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = sk_X509_value(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_pointer((char *)result, _cffi_type(28)); +} +#else +# define _cffi_f_sk_X509_value _cffi_d_sk_X509_value +#endif + +static int _cffi_const_BN_FLG_CONSTTIME(unsigned long long *o) +{ + int n = (BN_FLG_CONSTTIME) <= 0; + *o = (unsigned long long)((BN_FLG_CONSTTIME) | 0); /* check that BN_FLG_CONSTTIME is an integer */ + return n; +} + +_CFFI_UNUSED_FN +static void _cffi_checkfld__ASN1_OCTET_STRING(ASN1_OCTET_STRING *p) +{ + /* only to generate compile-time warnings or errors */ + (void)p; + (void)((p->length) | 0); /* check that 'ASN1_OCTET_STRING.length' is an integer */ + (void)((p->type) | 0); /* check that 'ASN1_OCTET_STRING.type' is an integer */ + { unsigned char * *tmp = &p->data; (void)tmp; } + (void)((p->flags) | 0); /* check that 'ASN1_OCTET_STRING.flags' is an integer */ +} +struct _cffi_align__ASN1_OCTET_STRING { char x; ASN1_OCTET_STRING y; }; + +static const struct _cffi_global_s _cffi_globals[] = { + { "ACCESS_DESCRIPTION_free", (void *)_cffi_f_ACCESS_DESCRIPTION_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2533), (void *)_cffi_d_ACCESS_DESCRIPTION_free }, + { "ACCESS_DESCRIPTION_new", (void *)_cffi_f_ACCESS_DESCRIPTION_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 4), (void *)_cffi_d_ACCESS_DESCRIPTION_new }, + { "AES_unwrap_key", (void *)_cffi_f_AES_unwrap_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 749), (void *)_cffi_d_AES_unwrap_key }, + { "AES_wrap_key", (void *)_cffi_f_AES_wrap_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 749), (void *)_cffi_d_AES_wrap_key }, + { "ASN1_BIT_STRING_free", (void *)_cffi_f_ASN1_BIT_STRING_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2548), (void *)_cffi_d_ASN1_BIT_STRING_free }, + { "ASN1_BIT_STRING_get_bit", (void *)_cffi_f_ASN1_BIT_STRING_get_bit, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 781), (void *)_cffi_d_ASN1_BIT_STRING_get_bit }, + { "ASN1_BIT_STRING_new", (void *)_cffi_f_ASN1_BIT_STRING_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 65), (void *)_cffi_d_ASN1_BIT_STRING_new }, + { "ASN1_BIT_STRING_set_bit", (void *)_cffi_f_ASN1_BIT_STRING_set_bit, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 785), (void *)_cffi_d_ASN1_BIT_STRING_set_bit }, + { "ASN1_ENUMERATED_free", (void *)_cffi_f_ASN1_ENUMERATED_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2536), (void *)_cffi_d_ASN1_ENUMERATED_free }, + { "ASN1_ENUMERATED_get", (void *)_cffi_f_ASN1_ENUMERATED_get, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2285), (void *)_cffi_d_ASN1_ENUMERATED_get }, + { "ASN1_ENUMERATED_new", (void *)_cffi_f_ASN1_ENUMERATED_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 6), (void *)_cffi_d_ASN1_ENUMERATED_new }, + { "ASN1_ENUMERATED_set", (void *)_cffi_f_ASN1_ENUMERATED_set, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 756), (void *)_cffi_d_ASN1_ENUMERATED_set }, + { "ASN1_GENERALIZEDTIME_free", (void *)_cffi_f_ASN1_GENERALIZEDTIME_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2539), (void *)_cffi_d_ASN1_GENERALIZEDTIME_free }, + { "ASN1_GENERALIZEDTIME_set", (void *)_cffi_f_ASN1_GENERALIZEDTIME_set, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 8), (void *)_cffi_d_ASN1_GENERALIZEDTIME_set }, + { "ASN1_IA5STRING_new", (void *)_cffi_f_ASN1_IA5STRING_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 65), (void *)_cffi_d_ASN1_IA5STRING_new }, + { "ASN1_INTEGER_free", (void *)_cffi_f_ASN1_INTEGER_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2542), (void *)_cffi_d_ASN1_INTEGER_free }, + { "ASN1_INTEGER_set", (void *)_cffi_f_ASN1_INTEGER_set, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 760), (void *)_cffi_d_ASN1_INTEGER_set }, + { "ASN1_INTEGER_to_BN", (void *)_cffi_f_ASN1_INTEGER_to_BN, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 86), (void *)_cffi_d_ASN1_INTEGER_to_BN }, + { "ASN1_NULL_new", (void *)_cffi_f_ASN1_NULL_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 33), (void *)_cffi_d_ASN1_NULL_new }, + { "ASN1_OBJECT_free", (void *)_cffi_f_ASN1_OBJECT_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2545), (void *)_cffi_d_ASN1_OBJECT_free }, + { "ASN1_OCTET_STRING_free", (void *)_cffi_f_ASN1_OCTET_STRING_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2548), (void *)_cffi_d_ASN1_OCTET_STRING_free }, + { "ASN1_OCTET_STRING_new", (void *)_cffi_f_ASN1_OCTET_STRING_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 65), (void *)_cffi_d_ASN1_OCTET_STRING_new }, + { "ASN1_OCTET_STRING_set", (void *)_cffi_f_ASN1_OCTET_STRING_set, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 790), (void *)_cffi_d_ASN1_OCTET_STRING_set }, + { "ASN1_STRING_data", (void *)_cffi_f_ASN1_STRING_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2416), (void *)_cffi_d_ASN1_STRING_data }, + { "ASN1_STRING_length", (void *)_cffi_f_ASN1_STRING_length, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 774), (void *)_cffi_d_ASN1_STRING_length }, + { "ASN1_STRING_set", (void *)_cffi_f_ASN1_STRING_set, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 795), (void *)_cffi_d_ASN1_STRING_set }, + { "ASN1_STRING_set_default_mask_asc", (void *)_cffi_f_ASN1_STRING_set_default_mask_asc, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2151), (void *)_cffi_d_ASN1_STRING_set_default_mask_asc }, + { "ASN1_STRING_to_UTF8", (void *)_cffi_f_ASN1_STRING_to_UTF8, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2241), (void *)_cffi_d_ASN1_STRING_to_UTF8 }, + { "ASN1_STRING_type", (void *)_cffi_f_ASN1_STRING_type, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 774), (void *)_cffi_d_ASN1_STRING_type }, + { "ASN1_TIME_free", (void *)_cffi_f_ASN1_TIME_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2548), (void *)_cffi_d_ASN1_TIME_free }, + { "ASN1_TIME_new", (void *)_cffi_f_ASN1_TIME_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 65), (void *)_cffi_d_ASN1_TIME_new }, + { "ASN1_TIME_set_string", (void *)_cffi_f_ASN1_TIME_set_string, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 777), (void *)_cffi_d_ASN1_TIME_set_string }, + { "ASN1_TIME_to_generalizedtime", (void *)_cffi_f_ASN1_TIME_to_generalizedtime, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 12), (void *)_cffi_d_ASN1_TIME_to_generalizedtime }, + { "ASN1_UTF8STRING_free", (void *)_cffi_f_ASN1_UTF8STRING_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2548), (void *)_cffi_d_ASN1_UTF8STRING_free }, + { "ASN1_UTF8STRING_new", (void *)_cffi_f_ASN1_UTF8STRING_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 65), (void *)_cffi_d_ASN1_UTF8STRING_new }, + { "AUTHORITY_KEYID_free", (void *)_cffi_f_AUTHORITY_KEYID_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2556), (void *)_cffi_d_AUTHORITY_KEYID_free }, + { "AUTHORITY_KEYID_new", (void *)_cffi_f_AUTHORITY_KEYID_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 82), (void *)_cffi_d_AUTHORITY_KEYID_new }, + { "BASIC_CONSTRAINTS_free", (void *)_cffi_f_BASIC_CONSTRAINTS_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2559), (void *)_cffi_d_BASIC_CONSTRAINTS_free }, + { "BASIC_CONSTRAINTS_new", (void *)_cffi_f_BASIC_CONSTRAINTS_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 84), (void *)_cffi_d_BASIC_CONSTRAINTS_new }, + { "BIO_clear_retry_flags", (void *)_cffi_f_BIO_clear_retry_flags, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2569), (void *)_cffi_d_BIO_clear_retry_flags }, + { "BIO_ctrl_pending", (void *)_cffi_f_BIO_ctrl_pending, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2369), (void *)_cffi_d_BIO_ctrl_pending }, + { "BIO_free", (void *)_cffi_f_BIO_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 867), (void *)_cffi_d_BIO_free }, + { "BIO_free_all", (void *)_cffi_f_BIO_free_all, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2569), (void *)_cffi_d_BIO_free_all }, + { "BIO_get_mem_data", (void *)_cffi_f_BIO_get_mem_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2288), (void *)_cffi_d_BIO_get_mem_data }, + { "BIO_gets", (void *)_cffi_f_BIO_gets, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1010), (void *)_cffi_d_BIO_gets }, + { "BIO_new", (void *)_cffi_f_BIO_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 114), (void *)_cffi_d_BIO_new }, + { "BIO_new_dgram", (void *)_cffi_f_BIO_new_dgram, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 121), (void *)_cffi_d_BIO_new_dgram }, + { "BIO_new_file", (void *)_cffi_f_BIO_new_file, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 117), (void *)_cffi_d_BIO_new_file }, + { "BIO_new_mem_buf", (void *)_cffi_f_BIO_new_mem_buf, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 125), (void *)_cffi_d_BIO_new_mem_buf }, + { "BIO_read", (void *)_cffi_f_BIO_read, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1015), (void *)_cffi_d_BIO_read }, + { "BIO_reset", (void *)_cffi_f_BIO_reset, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 867), (void *)_cffi_d_BIO_reset }, + { "BIO_s_datagram", (void *)_cffi_f_BIO_s_datagram, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 129), (void *)_cffi_d_BIO_s_datagram }, + { "BIO_s_mem", (void *)_cffi_f_BIO_s_mem, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 129), (void *)_cffi_d_BIO_s_mem }, + { "BIO_set_mem_eof_return", (void *)_cffi_f_BIO_set_mem_eof_return, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2292), (void *)_cffi_d_BIO_set_mem_eof_return }, + { "BIO_set_retry_read", (void *)_cffi_f_BIO_set_retry_read, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2569), (void *)_cffi_d_BIO_set_retry_read }, + { "BIO_should_io_special", (void *)_cffi_f_BIO_should_io_special, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 867), (void *)_cffi_d_BIO_should_io_special }, + { "BIO_should_read", (void *)_cffi_f_BIO_should_read, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 867), (void *)_cffi_d_BIO_should_read }, + { "BIO_should_retry", (void *)_cffi_f_BIO_should_retry, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 867), (void *)_cffi_d_BIO_should_retry }, + { "BIO_should_write", (void *)_cffi_f_BIO_should_write, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 867), (void *)_cffi_d_BIO_should_write }, + { "BIO_up_ref", (void *)_cffi_f_BIO_up_ref, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 867), (void *)_cffi_d_BIO_up_ref }, + { "BIO_write", (void *)_cffi_f_BIO_write, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1020), (void *)_cffi_d_BIO_write }, + { "BN_CTX_end", (void *)_cffi_f_BN_CTX_end, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2572), (void *)_cffi_d_BN_CTX_end }, + { "BN_CTX_free", (void *)_cffi_f_BN_CTX_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2572), (void *)_cffi_d_BN_CTX_free }, + { "BN_CTX_get", (void *)_cffi_f_BN_CTX_get, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 99), (void *)_cffi_d_BN_CTX_get }, + { "BN_CTX_new", (void *)_cffi_f_BN_CTX_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 131), (void *)_cffi_d_BN_CTX_new }, + { "BN_CTX_start", (void *)_cffi_f_BN_CTX_start, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2572), (void *)_cffi_d_BN_CTX_start }, + { "BN_FLG_CONSTTIME", (void *)_cffi_const_BN_FLG_CONSTTIME, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "BN_MONT_CTX_free", (void *)_cffi_f_BN_MONT_CTX_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2575), (void *)_cffi_d_BN_MONT_CTX_free }, + { "BN_MONT_CTX_new", (void *)_cffi_f_BN_MONT_CTX_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 133), (void *)_cffi_d_BN_MONT_CTX_new }, + { "BN_MONT_CTX_set", (void *)_cffi_f_BN_MONT_CTX_set, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1025), (void *)_cffi_d_BN_MONT_CTX_set }, + { "BN_add", (void *)_cffi_f_BN_add, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 812), (void *)_cffi_d_BN_add }, + { "BN_bin2bn", (void *)_cffi_f_BN_bin2bn, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 102), (void *)_cffi_d_BN_bin2bn }, + { "BN_bn2bin", (void *)_cffi_f_BN_bn2bin, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 863), (void *)_cffi_d_BN_bn2bin }, + { "BN_bn2hex", (void *)_cffi_f_BN_bn2hex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 711), (void *)_cffi_d_BN_bn2hex }, + { "BN_clear_free", (void *)_cffi_f_BN_clear_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2562), (void *)_cffi_d_BN_clear_free }, + { "BN_cmp", (void *)_cffi_f_BN_cmp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 853), (void *)_cffi_d_BN_cmp }, + { "BN_dup", (void *)_cffi_f_BN_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 96), (void *)_cffi_d_BN_dup }, + { "BN_free", (void *)_cffi_f_BN_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2562), (void *)_cffi_d_BN_free }, + { "BN_generate_prime_ex", (void *)_cffi_f_BN_generate_prime_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 842), (void *)_cffi_d_BN_generate_prime_ex }, + { "BN_hex2bn", (void *)_cffi_f_BN_hex2bn, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 804), (void *)_cffi_d_BN_hex2bn }, + { "BN_is_negative", (void *)_cffi_f_BN_is_negative, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 850), (void *)_cffi_d_BN_is_negative }, + { "BN_is_prime_ex", (void *)_cffi_f_BN_is_prime_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 857), (void *)_cffi_d_BN_is_prime_ex }, + { "BN_mod", (void *)_cffi_f_BN_mod, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 832), (void *)_cffi_d_BN_mod }, + { "BN_mod_add", (void *)_cffi_f_BN_mod_add, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 817), (void *)_cffi_d_BN_mod_add }, + { "BN_mod_exp", (void *)_cffi_f_BN_mod_exp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 817), (void *)_cffi_d_BN_mod_exp }, + { "BN_mod_exp_mont", (void *)_cffi_f_BN_mod_exp_mont, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 824), (void *)_cffi_d_BN_mod_exp_mont }, + { "BN_mod_exp_mont_consttime", (void *)_cffi_f_BN_mod_exp_mont_consttime, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 824), (void *)_cffi_d_BN_mod_exp_mont_consttime }, + { "BN_mod_inverse", (void *)_cffi_f_BN_mod_inverse, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 90), (void *)_cffi_d_BN_mod_inverse }, + { "BN_mod_mul", (void *)_cffi_f_BN_mod_mul, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 817), (void *)_cffi_d_BN_mod_mul }, + { "BN_mod_sub", (void *)_cffi_f_BN_mod_sub, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 817), (void *)_cffi_d_BN_mod_sub }, + { "BN_new", (void *)_cffi_f_BN_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 107), (void *)_cffi_d_BN_new }, + { "BN_nnmod", (void *)_cffi_f_BN_nnmod, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 832), (void *)_cffi_d_BN_nnmod }, + { "BN_num_bits", (void *)_cffi_f_BN_num_bits, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 850), (void *)_cffi_d_BN_num_bits }, + { "BN_num_bytes", (void *)_cffi_f_BN_num_bytes, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 850), (void *)_cffi_d_BN_num_bytes }, + { "BN_prime_checks_for_size", (void *)_cffi_f_BN_prime_checks_for_size, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2191), (void *)_cffi_d_BN_prime_checks_for_size }, + { "BN_rand_range", (void *)_cffi_f_BN_rand_range, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 808), (void *)_cffi_d_BN_rand_range }, + { "BN_set_flags", (void *)_cffi_f_BN_set_flags, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2565), (void *)_cffi_d_BN_set_flags }, + { "BN_set_word", (void *)_cffi_f_BN_set_word, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 838), (void *)_cffi_d_BN_set_word }, + { "BN_sub", (void *)_cffi_f_BN_sub, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 812), (void *)_cffi_d_BN_sub }, + { "BN_to_ASN1_INTEGER", (void *)_cffi_f_BN_to_ASN1_INTEGER, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 19), (void *)_cffi_d_BN_to_ASN1_INTEGER }, + { "BN_value_one", (void *)_cffi_f_BN_value_one, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 112), (void *)_cffi_d_BN_value_one }, + { "CERTIFICATEPOLICIES_free", (void *)_cffi_f_CERTIFICATEPOLICIES_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2604), (void *)_cffi_d_CERTIFICATEPOLICIES_free }, + { "CMAC_CTX_copy", (void *)_cffi_f_CMAC_CTX_copy, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1030), (void *)_cffi_d_CMAC_CTX_copy }, + { "CMAC_CTX_free", (void *)_cffi_f_CMAC_CTX_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2578), (void *)_cffi_d_CMAC_CTX_free }, + { "CMAC_CTX_new", (void *)_cffi_f_CMAC_CTX_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 135), (void *)_cffi_d_CMAC_CTX_new }, + { "CMAC_Final", (void *)_cffi_f_CMAC_Final, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1034), (void *)_cffi_d_CMAC_Final }, + { "CMAC_Init", (void *)_cffi_f_CMAC_Init, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1044), (void *)_cffi_d_CMAC_Init }, + { "CMAC_Update", (void *)_cffi_f_CMAC_Update, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1039), (void *)_cffi_d_CMAC_Update }, + { "CRL_DIST_POINTS_free", (void *)_cffi_f_CRL_DIST_POINTS_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2594), (void *)_cffi_d_CRL_DIST_POINTS_free }, + { "CRYPTOGRAPHY_IS_LIBRESSL", (void *)_cffi_const_CRYPTOGRAPHY_IS_LIBRESSL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE", (void *)_cffi_const_CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "CRYPTOGRAPHY_OPENSSL_110F_OR_GREATER", (void *)_cffi_const_CRYPTOGRAPHY_OPENSSL_110F_OR_GREATER, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "CRYPTOGRAPHY_OPENSSL_LESS_THAN_111", (void *)_cffi_const_CRYPTOGRAPHY_OPENSSL_LESS_THAN_111, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "CRYPTOGRAPHY_OPENSSL_LESS_THAN_111B", (void *)_cffi_const_CRYPTOGRAPHY_OPENSSL_LESS_THAN_111B, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "CRYPTOGRAPHY_PACKAGE_VERSION", (void *)_cffi_const_CRYPTOGRAPHY_PACKAGE_VERSION, _CFFI_OP(_CFFI_OP_CONSTANT, 46), (void *)0 }, + { "CT_LOG_ENTRY_TYPE_NOT_SET", (void *)_cffi_const_CT_LOG_ENTRY_TYPE_NOT_SET, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "CT_LOG_ENTRY_TYPE_PRECERT", (void *)_cffi_const_CT_LOG_ENTRY_TYPE_PRECERT, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "CT_LOG_ENTRY_TYPE_X509", (void *)_cffi_const_CT_LOG_ENTRY_TYPE_X509, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "Cryptography_CRYPTO_set_mem_functions", (void *)_cffi_f_Cryptography_CRYPTO_set_mem_functions, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2268), (void *)_cffi_d_Cryptography_CRYPTO_set_mem_functions }, + { "Cryptography_DH_check", (void *)_cffi_f_Cryptography_DH_check, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1167), (void *)_cffi_d_Cryptography_DH_check }, + { "Cryptography_DTLSv1_get_timeout", (void *)_cffi_f_Cryptography_DTLSv1_get_timeout, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2311), (void *)_cffi_d_Cryptography_DTLSv1_get_timeout }, + { "Cryptography_EVP_MD_CTX_free", (void *)_cffi_f_Cryptography_EVP_MD_CTX_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2679), (void *)_cffi_d_Cryptography_EVP_MD_CTX_free }, + { "Cryptography_EVP_MD_CTX_new", (void *)_cffi_f_Cryptography_EVP_MD_CTX_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 269), (void *)_cffi_d_Cryptography_EVP_MD_CTX_new }, + { "Cryptography_EVP_PKEY_id", (void *)_cffi_f_Cryptography_EVP_PKEY_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1444), (void *)_cffi_d_Cryptography_EVP_PKEY_id }, + { "Cryptography_HAS_102_VERIFICATION", (void *)_cffi_const_Cryptography_HAS_102_VERIFICATION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_110_VERIFICATION_PARAMS", (void *)_cffi_const_Cryptography_HAS_110_VERIFICATION_PARAMS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_ALPN", (void *)_cffi_const_Cryptography_HAS_ALPN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_CUSTOM_EXT", (void *)_cffi_const_Cryptography_HAS_CUSTOM_EXT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_DTLS", (void *)_cffi_const_Cryptography_HAS_DTLS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_EC2M", (void *)_cffi_const_Cryptography_HAS_EC2M, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_ED25519", (void *)_cffi_const_Cryptography_HAS_ED25519, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_ED448", (void *)_cffi_const_Cryptography_HAS_ED448, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_ENGINE", (void *)_cffi_const_Cryptography_HAS_ENGINE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_EVP_DIGESTFINAL_XOF", (void *)_cffi_const_Cryptography_HAS_EVP_DIGESTFINAL_XOF, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_EVP_PKEY_DHX", (void *)_cffi_const_Cryptography_HAS_EVP_PKEY_DHX, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_EVP_PKEY_get_set_tls_encodedpoint", (void *)_cffi_const_Cryptography_HAS_EVP_PKEY_get_set_tls_encodedpoint, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_FIPS", (void *)_cffi_const_Cryptography_HAS_FIPS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_GET_PROTO_VERSION", (void *)_cffi_const_Cryptography_HAS_GET_PROTO_VERSION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_KEYLOG", (void *)_cffi_const_Cryptography_HAS_KEYLOG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_MEM_FUNCTIONS", (void *)_cffi_const_Cryptography_HAS_MEM_FUNCTIONS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_NEXTPROTONEG", (void *)_cffi_const_Cryptography_HAS_NEXTPROTONEG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_ONESHOT_EVP_DIGEST_SIGN_VERIFY", (void *)_cffi_const_Cryptography_HAS_ONESHOT_EVP_DIGEST_SIGN_VERIFY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_OPENSSL_CLEANUP", (void *)_cffi_const_Cryptography_HAS_OPENSSL_CLEANUP, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_OP_NO_COMPRESSION", (void *)_cffi_const_Cryptography_HAS_OP_NO_COMPRESSION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_POLY1305", (void *)_cffi_const_Cryptography_HAS_POLY1305, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_PSK", (void *)_cffi_const_Cryptography_HAS_PSK, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_RAW_KEY", (void *)_cffi_const_Cryptography_HAS_RAW_KEY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_RELEASE_BUFFERS", (void *)_cffi_const_Cryptography_HAS_RELEASE_BUFFERS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_RSA_OAEP_LABEL", (void *)_cffi_const_Cryptography_HAS_RSA_OAEP_LABEL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_RSA_OAEP_MD", (void *)_cffi_const_Cryptography_HAS_RSA_OAEP_MD, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SCRYPT", (void *)_cffi_const_Cryptography_HAS_SCRYPT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SCT", (void *)_cffi_const_Cryptography_HAS_SCT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SECURE_RENEGOTIATION", (void *)_cffi_const_Cryptography_HAS_SECURE_RENEGOTIATION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SET_CERT_CB", (void *)_cffi_const_Cryptography_HAS_SET_CERT_CB, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SIGALGS", (void *)_cffi_const_Cryptography_HAS_SIGALGS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SRTP", (void *)_cffi_const_Cryptography_HAS_SRTP, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SSL3_METHOD", (void *)_cffi_const_Cryptography_HAS_SSL3_METHOD, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SSL_CTX_CLEAR_OPTIONS", (void *)_cffi_const_Cryptography_HAS_SSL_CTX_CLEAR_OPTIONS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SSL_OP_MSIE_SSLV2_RSA_PADDING", (void *)_cffi_const_Cryptography_HAS_SSL_OP_MSIE_SSLV2_RSA_PADDING, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SSL_OP_NO_TICKET", (void *)_cffi_const_Cryptography_HAS_SSL_OP_NO_TICKET, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SSL_SET_SSL_CTX", (void *)_cffi_const_Cryptography_HAS_SSL_SET_SSL_CTX, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_SSL_ST", (void *)_cffi_const_Cryptography_HAS_SSL_ST, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_TLSEXT_HOSTNAME", (void *)_cffi_const_Cryptography_HAS_TLSEXT_HOSTNAME, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_TLS_ST", (void *)_cffi_const_Cryptography_HAS_TLS_ST, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_TLSv1_1", (void *)_cffi_const_Cryptography_HAS_TLSv1_1, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_TLSv1_2", (void *)_cffi_const_Cryptography_HAS_TLSv1_2, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_TLSv1_3", (void *)_cffi_const_Cryptography_HAS_TLSv1_3, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_VERIFIED_CHAIN", (void *)_cffi_const_Cryptography_HAS_VERIFIED_CHAIN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_HAS_X509_STORE_CTX_GET_ISSUER", (void *)_cffi_const_Cryptography_HAS_X509_STORE_CTX_GET_ISSUER, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "Cryptography_X509_REVOKED_dup", (void *)_cffi_f_Cryptography_X509_REVOKED_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 685), (void *)_cffi_d_Cryptography_X509_REVOKED_dup }, + { "Cryptography_add_osrandom_engine", (void *)_cffi_f_Cryptography_add_osrandom_engine, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2280), (void *)_cffi_d_Cryptography_add_osrandom_engine }, + { "Cryptography_d2i_DHxparams_bio", (void *)_cffi_f_Cryptography_d2i_DHxparams_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 185), (void *)_cffi_d_Cryptography_d2i_DHxparams_bio }, + { "Cryptography_free_wrapper", (void *)_cffi_f_Cryptography_free_wrapper, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2988), (void *)_cffi_d_Cryptography_free_wrapper }, + { "Cryptography_i2d_DHxparams_bio", (void *)_cffi_f_Cryptography_i2d_DHxparams_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 874), (void *)_cffi_d_Cryptography_i2d_DHxparams_bio }, + { "Cryptography_malloc_wrapper", (void *)_cffi_f_Cryptography_malloc_wrapper, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2511), (void *)_cffi_d_Cryptography_malloc_wrapper }, + { "Cryptography_osrandom_engine_id", (void *)_cffi_const_Cryptography_osrandom_engine_id, _CFFI_OP(_CFFI_OP_CONSTANT, 46), (void *)0 }, + { "Cryptography_osrandom_engine_name", (void *)_cffi_const_Cryptography_osrandom_engine_name, _CFFI_OP(_CFFI_OP_CONSTANT, 46), (void *)0 }, + { "Cryptography_pem_password_cb", (void *)_cffi_f_Cryptography_pem_password_cb, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2160), (void *)_cffi_d_Cryptography_pem_password_cb }, + { "Cryptography_realloc_wrapper", (void *)_cffi_f_Cryptography_realloc_wrapper, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2516), (void *)_cffi_d_Cryptography_realloc_wrapper }, + { "DH_NOT_SUITABLE_GENERATOR", (void *)_cffi_const_DH_NOT_SUITABLE_GENERATOR, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "DH_compute_key", (void *)_cffi_f_DH_compute_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2253), (void *)_cffi_d_DH_compute_key }, + { "DH_free", (void *)_cffi_f_DH_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2626), (void *)_cffi_d_DH_free }, + { "DH_generate_key", (void *)_cffi_f_DH_generate_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1144), (void *)_cffi_d_DH_generate_key }, + { "DH_generate_parameters_ex", (void *)_cffi_f_DH_generate_parameters_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1158), (void *)_cffi_d_DH_generate_parameters_ex }, + { "DH_get0_key", (void *)_cffi_f_DH_get0_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2629), (void *)_cffi_d_DH_get0_key }, + { "DH_get0_pqg", (void *)_cffi_f_DH_get0_pqg, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2634), (void *)_cffi_d_DH_get0_pqg }, + { "DH_new", (void *)_cffi_f_DH_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 201), (void *)_cffi_d_DH_new }, + { "DH_set0_key", (void *)_cffi_f_DH_set0_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1147), (void *)_cffi_d_DH_set0_key }, + { "DH_set0_pqg", (void *)_cffi_f_DH_set0_pqg, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1152), (void *)_cffi_d_DH_set0_pqg }, + { "DH_size", (void *)_cffi_f_DH_size, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1164), (void *)_cffi_d_DH_size }, + { "DHparams_dup", (void *)_cffi_f_DHparams_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 195), (void *)_cffi_d_DHparams_dup }, + { "DIST_POINT_NAME_free", (void *)_cffi_f_DIST_POINT_NAME_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2643), (void *)_cffi_d_DIST_POINT_NAME_free }, + { "DIST_POINT_NAME_new", (void *)_cffi_f_DIST_POINT_NAME_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 209), (void *)_cffi_d_DIST_POINT_NAME_new }, + { "DIST_POINT_free", (void *)_cffi_f_DIST_POINT_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2640), (void *)_cffi_d_DIST_POINT_free }, + { "DIST_POINT_new", (void *)_cffi_f_DIST_POINT_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 207), (void *)_cffi_d_DIST_POINT_new }, + { "DSA_free", (void *)_cffi_f_DSA_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2646), (void *)_cffi_d_DSA_free }, + { "DSA_generate_key", (void *)_cffi_f_DSA_generate_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1171), (void *)_cffi_d_DSA_generate_key }, + { "DSA_generate_parameters_ex", (void *)_cffi_f_DSA_generate_parameters_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1185), (void *)_cffi_d_DSA_generate_parameters_ex }, + { "DSA_get0_key", (void *)_cffi_f_DSA_get0_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2649), (void *)_cffi_d_DSA_get0_key }, + { "DSA_get0_pqg", (void *)_cffi_f_DSA_get0_pqg, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2654), (void *)_cffi_d_DSA_get0_pqg }, + { "DSA_new", (void *)_cffi_f_DSA_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 217), (void *)_cffi_d_DSA_new }, + { "DSA_set0_key", (void *)_cffi_f_DSA_set0_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1174), (void *)_cffi_d_DSA_set0_key }, + { "DSA_set0_pqg", (void *)_cffi_f_DSA_set0_pqg, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1179), (void *)_cffi_d_DSA_set0_pqg }, + { "DSA_sign", (void *)_cffi_f_DSA_sign, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2202), (void *)_cffi_d_DSA_sign }, + { "DSA_size", (void *)_cffi_f_DSA_size, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1194), (void *)_cffi_d_DSA_size }, + { "DSA_verify", (void *)_cffi_f_DSA_verify, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2218), (void *)_cffi_d_DSA_verify }, + { "DSAparams_dup", (void *)_cffi_f_DSAparams_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 211), (void *)_cffi_d_DSAparams_dup }, + { "DTLS_client_method", (void *)_cffi_f_DTLS_client_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_DTLS_client_method }, + { "DTLS_get_link_min_mtu", (void *)_cffi_f_DTLS_get_link_min_mtu, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2296), (void *)_cffi_d_DTLS_get_link_min_mtu }, + { "DTLS_method", (void *)_cffi_f_DTLS_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_DTLS_method }, + { "DTLS_server_method", (void *)_cffi_f_DTLS_server_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_DTLS_server_method }, + { "DTLS_set_link_mtu", (void *)_cffi_f_DTLS_set_link_mtu, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2307), (void *)_cffi_d_DTLS_set_link_mtu }, + { "DTLSv1_client_method", (void *)_cffi_f_DTLSv1_client_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_DTLSv1_client_method }, + { "DTLSv1_handle_timeout", (void *)_cffi_f_DTLSv1_handle_timeout, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2296), (void *)_cffi_d_DTLSv1_handle_timeout }, + { "DTLSv1_method", (void *)_cffi_f_DTLSv1_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_DTLSv1_method }, + { "DTLSv1_server_method", (void *)_cffi_f_DTLSv1_server_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_DTLSv1_server_method }, + { "ECDH_compute_key", (void *)_cffi_f_ECDH_compute_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2273), (void *)_cffi_d_ECDH_compute_key }, + { "ECDSA_sign", (void *)_cffi_f_ECDSA_sign, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2210), (void *)_cffi_d_ECDSA_sign }, + { "ECDSA_size", (void *)_cffi_f_ECDSA_size, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1294), (void *)_cffi_d_ECDSA_size }, + { "ECDSA_verify", (void *)_cffi_f_ECDSA_verify, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2226), (void *)_cffi_d_ECDSA_verify }, + { "EC_GROUP_free", (void *)_cffi_f_EC_GROUP_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2660), (void *)_cffi_d_EC_GROUP_free }, + { "EC_GROUP_get0_generator", (void *)_cffi_f_EC_GROUP_get0_generator, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 247), (void *)_cffi_d_EC_GROUP_get0_generator }, + { "EC_GROUP_get_asn1_flag", (void *)_cffi_f_EC_GROUP_get_asn1_flag, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1197), (void *)_cffi_d_EC_GROUP_get_asn1_flag }, + { "EC_GROUP_get_curve_name", (void *)_cffi_f_EC_GROUP_get_curve_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1197), (void *)_cffi_d_EC_GROUP_get_curve_name }, + { "EC_GROUP_get_degree", (void *)_cffi_f_EC_GROUP_get_degree, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1197), (void *)_cffi_d_EC_GROUP_get_degree }, + { "EC_GROUP_get_order", (void *)_cffi_f_EC_GROUP_get_order, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1200), (void *)_cffi_d_EC_GROUP_get_order }, + { "EC_GROUP_method_of", (void *)_cffi_f_EC_GROUP_method_of, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 237), (void *)_cffi_d_EC_GROUP_method_of }, + { "EC_GROUP_new_by_curve_name", (void *)_cffi_f_EC_GROUP_new_by_curve_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 219), (void *)_cffi_d_EC_GROUP_new_by_curve_name }, + { "EC_KEY_free", (void *)_cffi_f_EC_KEY_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2663), (void *)_cffi_d_EC_KEY_free }, + { "EC_KEY_generate_key", (void *)_cffi_f_EC_KEY_generate_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1274), (void *)_cffi_d_EC_KEY_generate_key }, + { "EC_KEY_get0_group", (void *)_cffi_f_EC_KEY_get0_group, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 222), (void *)_cffi_d_EC_KEY_get0_group }, + { "EC_KEY_get0_private_key", (void *)_cffi_f_EC_KEY_get0_private_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 109), (void *)_cffi_d_EC_KEY_get0_private_key }, + { "EC_KEY_get0_public_key", (void *)_cffi_f_EC_KEY_get0_public_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 250), (void *)_cffi_d_EC_KEY_get0_public_key }, + { "EC_KEY_new", (void *)_cffi_f_EC_KEY_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 235), (void *)_cffi_d_EC_KEY_new }, + { "EC_KEY_new_by_curve_name", (void *)_cffi_f_EC_KEY_new_by_curve_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 232), (void *)_cffi_d_EC_KEY_new_by_curve_name }, + { "EC_KEY_set_asn1_flag", (void *)_cffi_f_EC_KEY_set_asn1_flag, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2666), (void *)_cffi_d_EC_KEY_set_asn1_flag }, + { "EC_KEY_set_group", (void *)_cffi_f_EC_KEY_set_group, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1286), (void *)_cffi_d_EC_KEY_set_group }, + { "EC_KEY_set_private_key", (void *)_cffi_f_EC_KEY_set_private_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1282), (void *)_cffi_d_EC_KEY_set_private_key }, + { "EC_KEY_set_public_key", (void *)_cffi_f_EC_KEY_set_public_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1290), (void *)_cffi_d_EC_KEY_set_public_key }, + { "EC_KEY_set_public_key_affine_coordinates", (void *)_cffi_f_EC_KEY_set_public_key_affine_coordinates, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1277), (void *)_cffi_d_EC_KEY_set_public_key_affine_coordinates }, + { "EC_METHOD_get_field_type", (void *)_cffi_f_EC_METHOD_get_field_type, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1297), (void *)_cffi_d_EC_METHOD_get_field_type }, + { "EC_POINT_add", (void *)_cffi_f_EC_POINT_add, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1238), (void *)_cffi_d_EC_POINT_add }, + { "EC_POINT_clear_free", (void *)_cffi_f_EC_POINT_clear_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2670), (void *)_cffi_d_EC_POINT_clear_free }, + { "EC_POINT_cmp", (void *)_cffi_f_EC_POINT_cmp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1268), (void *)_cffi_d_EC_POINT_cmp }, + { "EC_POINT_dbl", (void *)_cffi_f_EC_POINT_dbl, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1232), (void *)_cffi_d_EC_POINT_dbl }, + { "EC_POINT_dup", (void *)_cffi_f_EC_POINT_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 243), (void *)_cffi_d_EC_POINT_dup }, + { "EC_POINT_free", (void *)_cffi_f_EC_POINT_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2670), (void *)_cffi_d_EC_POINT_free }, + { "EC_POINT_get_affine_coordinates_GF2m", (void *)_cffi_f_EC_POINT_get_affine_coordinates_GF2m, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1256), (void *)_cffi_d_EC_POINT_get_affine_coordinates_GF2m }, + { "EC_POINT_get_affine_coordinates_GFp", (void *)_cffi_f_EC_POINT_get_affine_coordinates_GFp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1256), (void *)_cffi_d_EC_POINT_get_affine_coordinates_GFp }, + { "EC_POINT_invert", (void *)_cffi_f_EC_POINT_invert, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1227), (void *)_cffi_d_EC_POINT_invert }, + { "EC_POINT_is_at_infinity", (void *)_cffi_f_EC_POINT_is_at_infinity, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1252), (void *)_cffi_d_EC_POINT_is_at_infinity }, + { "EC_POINT_is_on_curve", (void *)_cffi_f_EC_POINT_is_on_curve, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1263), (void *)_cffi_d_EC_POINT_is_on_curve }, + { "EC_POINT_mul", (void *)_cffi_f_EC_POINT_mul, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1212), (void *)_cffi_d_EC_POINT_mul }, + { "EC_POINT_new", (void *)_cffi_f_EC_POINT_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 240), (void *)_cffi_d_EC_POINT_new }, + { "EC_POINT_oct2point", (void *)_cffi_f_EC_POINT_oct2point, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1245), (void *)_cffi_d_EC_POINT_oct2point }, + { "EC_POINT_point2oct", (void *)_cffi_f_EC_POINT_point2oct, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2372), (void *)_cffi_d_EC_POINT_point2oct }, + { "EC_POINT_set_affine_coordinates_GF2m", (void *)_cffi_f_EC_POINT_set_affine_coordinates_GF2m, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1205), (void *)_cffi_d_EC_POINT_set_affine_coordinates_GF2m }, + { "EC_POINT_set_affine_coordinates_GFp", (void *)_cffi_f_EC_POINT_set_affine_coordinates_GFp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1205), (void *)_cffi_d_EC_POINT_set_affine_coordinates_GFp }, + { "EC_POINT_set_compressed_coordinates_GF2m", (void *)_cffi_f_EC_POINT_set_compressed_coordinates_GF2m, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1220), (void *)_cffi_d_EC_POINT_set_compressed_coordinates_GF2m }, + { "EC_POINT_set_compressed_coordinates_GFp", (void *)_cffi_f_EC_POINT_set_compressed_coordinates_GFp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1220), (void *)_cffi_d_EC_POINT_set_compressed_coordinates_GFp }, + { "EC_curve_nid2nist", (void *)_cffi_f_EC_curve_nid2nist, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 735), (void *)_cffi_d_EC_curve_nid2nist }, + { "EC_get_builtin_curves", (void *)_cffi_f_EC_get_builtin_curves, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2380), (void *)_cffi_d_EC_get_builtin_curves }, + { "ENGINE_by_id", (void *)_cffi_f_ENGINE_by_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 253), (void *)_cffi_d_ENGINE_by_id }, + { "ENGINE_ctrl_cmd", (void *)_cffi_f_ENGINE_ctrl_cmd, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1309), (void *)_cffi_d_ENGINE_ctrl_cmd }, + { "ENGINE_ctrl_cmd_string", (void *)_cffi_f_ENGINE_ctrl_cmd_string, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1303), (void *)_cffi_d_ENGINE_ctrl_cmd_string }, + { "ENGINE_finish", (void *)_cffi_f_ENGINE_finish, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1300), (void *)_cffi_d_ENGINE_finish }, + { "ENGINE_free", (void *)_cffi_f_ENGINE_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1300), (void *)_cffi_d_ENGINE_free }, + { "ENGINE_get_default_RAND", (void *)_cffi_f_ENGINE_get_default_RAND, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 256), (void *)_cffi_d_ENGINE_get_default_RAND }, + { "ENGINE_get_name", (void *)_cffi_f_ENGINE_get_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 722), (void *)_cffi_d_ENGINE_get_name }, + { "ENGINE_init", (void *)_cffi_f_ENGINE_init, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1300), (void *)_cffi_d_ENGINE_init }, + { "ENGINE_load_builtin_engines", (void *)_cffi_f_ENGINE_load_builtin_engines, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2998), (void *)_cffi_d_ENGINE_load_builtin_engines }, + { "ENGINE_load_private_key", (void *)_cffi_f_ENGINE_load_private_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 281), (void *)_cffi_d_ENGINE_load_private_key }, + { "ENGINE_load_public_key", (void *)_cffi_f_ENGINE_load_public_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 281), (void *)_cffi_d_ENGINE_load_public_key }, + { "ENGINE_set_default_RAND", (void *)_cffi_f_ENGINE_set_default_RAND, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1300), (void *)_cffi_d_ENGINE_set_default_RAND }, + { "ENGINE_unregister_RAND", (void *)_cffi_f_ENGINE_unregister_RAND, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2673), (void *)_cffi_d_ENGINE_unregister_RAND }, + { "ERR_GET_FUNC", (void *)_cffi_f_ERR_GET_FUNC, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2265), (void *)_cffi_d_ERR_GET_FUNC }, + { "ERR_GET_LIB", (void *)_cffi_f_ERR_GET_LIB, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2265), (void *)_cffi_d_ERR_GET_LIB }, + { "ERR_GET_REASON", (void *)_cffi_f_ERR_GET_REASON, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2265), (void *)_cffi_d_ERR_GET_REASON }, + { "ERR_LIB_ASN1", (void *)_cffi_const_ERR_LIB_ASN1, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "ERR_LIB_EVP", (void *)_cffi_const_ERR_LIB_EVP, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "ERR_LIB_PEM", (void *)_cffi_const_ERR_LIB_PEM, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "ERR_LIB_PKCS12", (void *)_cffi_const_ERR_LIB_PKCS12, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "ERR_clear_error", (void *)_cffi_f_ERR_clear_error, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2998), (void *)_cffi_d_ERR_clear_error }, + { "ERR_error_string_n", (void *)_cffi_f_ERR_error_string_n, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2980), (void *)_cffi_d_ERR_error_string_n }, + { "ERR_func_error_string", (void *)_cffi_f_ERR_func_error_string, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 741), (void *)_cffi_d_ERR_func_error_string }, + { "ERR_get_error", (void *)_cffi_f_ERR_get_error, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2476), (void *)_cffi_d_ERR_get_error }, + { "ERR_lib_error_string", (void *)_cffi_f_ERR_lib_error_string, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 741), (void *)_cffi_d_ERR_lib_error_string }, + { "ERR_load_RAND_strings", (void *)_cffi_f_ERR_load_RAND_strings, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2998), (void *)_cffi_d_ERR_load_RAND_strings }, + { "ERR_peek_error", (void *)_cffi_f_ERR_peek_error, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2476), (void *)_cffi_d_ERR_peek_error }, + { "ERR_put_error", (void *)_cffi_f_ERR_put_error, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2973), (void *)_cffi_d_ERR_put_error }, + { "ERR_reason_error_string", (void *)_cffi_f_ERR_reason_error_string, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 741), (void *)_cffi_d_ERR_reason_error_string }, + { "EVP_CIPHER_CTX_cipher", (void *)_cffi_f_EVP_CIPHER_CTX_cipher, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 258), (void *)_cffi_d_EVP_CIPHER_CTX_cipher }, + { "EVP_CIPHER_CTX_cleanup", (void *)_cffi_f_EVP_CIPHER_CTX_cleanup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1317), (void *)_cffi_d_EVP_CIPHER_CTX_cleanup }, + { "EVP_CIPHER_CTX_ctrl", (void *)_cffi_f_EVP_CIPHER_CTX_ctrl, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1332), (void *)_cffi_d_EVP_CIPHER_CTX_ctrl }, + { "EVP_CIPHER_CTX_free", (void *)_cffi_f_EVP_CIPHER_CTX_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2676), (void *)_cffi_d_EVP_CIPHER_CTX_free }, + { "EVP_CIPHER_CTX_new", (void *)_cffi_f_EVP_CIPHER_CTX_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 264), (void *)_cffi_d_EVP_CIPHER_CTX_new }, + { "EVP_CIPHER_CTX_set_key_length", (void *)_cffi_f_EVP_CIPHER_CTX_set_key_length, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1328), (void *)_cffi_d_EVP_CIPHER_CTX_set_key_length }, + { "EVP_CIPHER_CTX_set_padding", (void *)_cffi_f_EVP_CIPHER_CTX_set_padding, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1328), (void *)_cffi_d_EVP_CIPHER_CTX_set_padding }, + { "EVP_CTRL_AEAD_GET_TAG", (void *)_cffi_const_EVP_CTRL_AEAD_GET_TAG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_CTRL_AEAD_SET_IVLEN", (void *)_cffi_const_EVP_CTRL_AEAD_SET_IVLEN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_CTRL_AEAD_SET_TAG", (void *)_cffi_const_EVP_CTRL_AEAD_SET_TAG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_CipherFinal_ex", (void *)_cffi_f_EVP_CipherFinal_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1338), (void *)_cffi_d_EVP_CipherFinal_ex }, + { "EVP_CipherInit_ex", (void *)_cffi_f_EVP_CipherInit_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1320), (void *)_cffi_d_EVP_CipherInit_ex }, + { "EVP_CipherUpdate", (void *)_cffi_f_EVP_CipherUpdate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1343), (void *)_cffi_d_EVP_CipherUpdate }, + { "EVP_DigestFinalXOF", (void *)_cffi_f_EVP_DigestFinalXOF, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1382), (void *)_cffi_d_EVP_DigestFinalXOF }, + { "EVP_DigestFinal_ex", (void *)_cffi_f_EVP_DigestFinal_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1387), (void *)_cffi_d_EVP_DigestFinal_ex }, + { "EVP_DigestInit_ex", (void *)_cffi_f_EVP_DigestInit_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1354), (void *)_cffi_d_EVP_DigestInit_ex }, + { "EVP_DigestSign", (void *)_cffi_f_EVP_DigestSign, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1375), (void *)_cffi_d_EVP_DigestSign }, + { "EVP_DigestSignFinal", (void *)_cffi_f_EVP_DigestSignFinal, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1370), (void *)_cffi_d_EVP_DigestSignFinal }, + { "EVP_DigestSignInit", (void *)_cffi_f_EVP_DigestSignInit, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1363), (void *)_cffi_d_EVP_DigestSignInit }, + { "EVP_DigestSignUpdate", (void *)_cffi_f_EVP_DigestSignUpdate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1411), (void *)_cffi_d_EVP_DigestSignUpdate }, + { "EVP_DigestUpdate", (void *)_cffi_f_EVP_DigestUpdate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1411), (void *)_cffi_d_EVP_DigestUpdate }, + { "EVP_DigestVerify", (void *)_cffi_f_EVP_DigestVerify, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1398), (void *)_cffi_d_EVP_DigestVerify }, + { "EVP_DigestVerifyInit", (void *)_cffi_f_EVP_DigestVerifyInit, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1363), (void *)_cffi_d_EVP_DigestVerifyInit }, + { "EVP_F_EVP_ENCRYPTFINAL_EX", (void *)_cffi_const_EVP_F_EVP_ENCRYPTFINAL_EX, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_MAX_MD_SIZE", (void *)_cffi_const_EVP_MAX_MD_SIZE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_MD_CTX_copy_ex", (void *)_cffi_f_EVP_MD_CTX_copy_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1359), (void *)_cffi_d_EVP_MD_CTX_copy_ex }, + { "EVP_MD_CTX_free", (void *)_cffi_f_EVP_MD_CTX_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2679), (void *)_cffi_d_EVP_MD_CTX_free }, + { "EVP_MD_CTX_new", (void *)_cffi_f_EVP_MD_CTX_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 269), (void *)_cffi_d_EVP_MD_CTX_new }, + { "EVP_PBE_scrypt", (void *)_cffi_f_EVP_PBE_scrypt, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2179), (void *)_cffi_d_EVP_PBE_scrypt }, + { "EVP_PKEY_CTX_dup", (void *)_cffi_f_EVP_PKEY_CTX_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 308), (void *)_cffi_d_EVP_PKEY_CTX_dup }, + { "EVP_PKEY_CTX_free", (void *)_cffi_f_EVP_PKEY_CTX_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2685), (void *)_cffi_d_EVP_PKEY_CTX_free }, + { "EVP_PKEY_CTX_new", (void *)_cffi_f_EVP_PKEY_CTX_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 304), (void *)_cffi_d_EVP_PKEY_CTX_new }, + { "EVP_PKEY_CTX_new_id", (void *)_cffi_f_EVP_PKEY_CTX_new_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 311), (void *)_cffi_d_EVP_PKEY_CTX_new_id }, + { "EVP_PKEY_CTX_set0_rsa_oaep_label", (void *)_cffi_f_EVP_PKEY_CTX_set0_rsa_oaep_label, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1479), (void *)_cffi_d_EVP_PKEY_CTX_set0_rsa_oaep_label }, + { "EVP_PKEY_CTX_set_rsa_mgf1_md", (void *)_cffi_f_EVP_PKEY_CTX_set_rsa_mgf1_md, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1459), (void *)_cffi_d_EVP_PKEY_CTX_set_rsa_mgf1_md }, + { "EVP_PKEY_CTX_set_rsa_oaep_md", (void *)_cffi_f_EVP_PKEY_CTX_set_rsa_oaep_md, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1459), (void *)_cffi_d_EVP_PKEY_CTX_set_rsa_oaep_md }, + { "EVP_PKEY_CTX_set_rsa_padding", (void *)_cffi_f_EVP_PKEY_CTX_set_rsa_padding, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1475), (void *)_cffi_d_EVP_PKEY_CTX_set_rsa_padding }, + { "EVP_PKEY_CTX_set_rsa_pss_saltlen", (void *)_cffi_f_EVP_PKEY_CTX_set_rsa_pss_saltlen, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1475), (void *)_cffi_d_EVP_PKEY_CTX_set_rsa_pss_saltlen }, + { "EVP_PKEY_CTX_set_signature_md", (void *)_cffi_f_EVP_PKEY_CTX_set_signature_md, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1463), (void *)_cffi_d_EVP_PKEY_CTX_set_signature_md }, + { "EVP_PKEY_DH", (void *)_cffi_const_EVP_PKEY_DH, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_PKEY_DHX", (void *)_cffi_const_EVP_PKEY_DHX, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_PKEY_DSA", (void *)_cffi_const_EVP_PKEY_DSA, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_PKEY_EC", (void *)_cffi_const_EVP_PKEY_EC, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_PKEY_ED25519", (void *)_cffi_const_EVP_PKEY_ED25519, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_PKEY_ED448", (void *)_cffi_const_EVP_PKEY_ED448, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_PKEY_POLY1305", (void *)_cffi_const_EVP_PKEY_POLY1305, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_PKEY_RSA", (void *)_cffi_const_EVP_PKEY_RSA, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_PKEY_X25519", (void *)_cffi_const_EVP_PKEY_X25519, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_PKEY_X448", (void *)_cffi_const_EVP_PKEY_X448, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_PKEY_assign_RSA", (void *)_cffi_f_EVP_PKEY_assign_RSA, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1431), (void *)_cffi_d_EVP_PKEY_assign_RSA }, + { "EVP_PKEY_bits", (void *)_cffi_f_EVP_PKEY_bits, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1416), (void *)_cffi_d_EVP_PKEY_bits }, + { "EVP_PKEY_cmp", (void *)_cffi_f_EVP_PKEY_cmp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1447), (void *)_cffi_d_EVP_PKEY_cmp }, + { "EVP_PKEY_decrypt", (void *)_cffi_f_EVP_PKEY_decrypt, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1489), (void *)_cffi_d_EVP_PKEY_decrypt }, + { "EVP_PKEY_decrypt_init", (void *)_cffi_f_EVP_PKEY_decrypt_init, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1456), (void *)_cffi_d_EVP_PKEY_decrypt_init }, + { "EVP_PKEY_derive", (void *)_cffi_f_EVP_PKEY_derive, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1484), (void *)_cffi_d_EVP_PKEY_derive }, + { "EVP_PKEY_derive_init", (void *)_cffi_f_EVP_PKEY_derive_init, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1456), (void *)_cffi_d_EVP_PKEY_derive_init }, + { "EVP_PKEY_derive_set_peer", (void *)_cffi_f_EVP_PKEY_derive_set_peer, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1471), (void *)_cffi_d_EVP_PKEY_derive_set_peer }, + { "EVP_PKEY_encrypt", (void *)_cffi_f_EVP_PKEY_encrypt, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1489), (void *)_cffi_d_EVP_PKEY_encrypt }, + { "EVP_PKEY_encrypt_init", (void *)_cffi_f_EVP_PKEY_encrypt_init, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1456), (void *)_cffi_d_EVP_PKEY_encrypt_init }, + { "EVP_PKEY_free", (void *)_cffi_f_EVP_PKEY_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2682), (void *)_cffi_d_EVP_PKEY_free }, + { "EVP_PKEY_get1_DH", (void *)_cffi_f_EVP_PKEY_get1_DH, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 198), (void *)_cffi_d_EVP_PKEY_get1_DH }, + { "EVP_PKEY_get1_DSA", (void *)_cffi_f_EVP_PKEY_get1_DSA, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 214), (void *)_cffi_d_EVP_PKEY_get1_DSA }, + { "EVP_PKEY_get1_EC_KEY", (void *)_cffi_f_EVP_PKEY_get1_EC_KEY, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 229), (void *)_cffi_d_EVP_PKEY_get1_EC_KEY }, + { "EVP_PKEY_get1_RSA", (void *)_cffi_f_EVP_PKEY_get1_RSA, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 472), (void *)_cffi_d_EVP_PKEY_get1_RSA }, + { "EVP_PKEY_get1_tls_encodedpoint", (void *)_cffi_f_EVP_PKEY_get1_tls_encodedpoint, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2384), (void *)_cffi_d_EVP_PKEY_get1_tls_encodedpoint }, + { "EVP_PKEY_get_raw_private_key", (void *)_cffi_f_EVP_PKEY_get_raw_private_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1451), (void *)_cffi_d_EVP_PKEY_get_raw_private_key }, + { "EVP_PKEY_get_raw_public_key", (void *)_cffi_f_EVP_PKEY_get_raw_public_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1451), (void *)_cffi_d_EVP_PKEY_get_raw_public_key }, + { "EVP_PKEY_id", (void *)_cffi_f_EVP_PKEY_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1444), (void *)_cffi_d_EVP_PKEY_id }, + { "EVP_PKEY_keygen", (void *)_cffi_f_EVP_PKEY_keygen, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1467), (void *)_cffi_d_EVP_PKEY_keygen }, + { "EVP_PKEY_keygen_init", (void *)_cffi_f_EVP_PKEY_keygen_init, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1456), (void *)_cffi_d_EVP_PKEY_keygen_init }, + { "EVP_PKEY_new", (void *)_cffi_f_EVP_PKEY_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 302), (void *)_cffi_d_EVP_PKEY_new }, + { "EVP_PKEY_new_raw_private_key", (void *)_cffi_f_EVP_PKEY_new_raw_private_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 296), (void *)_cffi_d_EVP_PKEY_new_raw_private_key }, + { "EVP_PKEY_new_raw_public_key", (void *)_cffi_f_EVP_PKEY_new_raw_public_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 296), (void *)_cffi_d_EVP_PKEY_new_raw_public_key }, + { "EVP_PKEY_set1_DH", (void *)_cffi_f_EVP_PKEY_set1_DH, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1419), (void *)_cffi_d_EVP_PKEY_set1_DH }, + { "EVP_PKEY_set1_DSA", (void *)_cffi_f_EVP_PKEY_set1_DSA, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1423), (void *)_cffi_d_EVP_PKEY_set1_DSA }, + { "EVP_PKEY_set1_EC_KEY", (void *)_cffi_f_EVP_PKEY_set1_EC_KEY, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1427), (void *)_cffi_d_EVP_PKEY_set1_EC_KEY }, + { "EVP_PKEY_set1_RSA", (void *)_cffi_f_EVP_PKEY_set1_RSA, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1431), (void *)_cffi_d_EVP_PKEY_set1_RSA }, + { "EVP_PKEY_set1_tls_encodedpoint", (void *)_cffi_f_EVP_PKEY_set1_tls_encodedpoint, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1439), (void *)_cffi_d_EVP_PKEY_set1_tls_encodedpoint }, + { "EVP_PKEY_set_type", (void *)_cffi_f_EVP_PKEY_set_type, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1435), (void *)_cffi_d_EVP_PKEY_set_type }, + { "EVP_PKEY_sign", (void *)_cffi_f_EVP_PKEY_sign, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1489), (void *)_cffi_d_EVP_PKEY_sign }, + { "EVP_PKEY_sign_init", (void *)_cffi_f_EVP_PKEY_sign_init, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1456), (void *)_cffi_d_EVP_PKEY_sign_init }, + { "EVP_PKEY_size", (void *)_cffi_f_EVP_PKEY_size, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1416), (void *)_cffi_d_EVP_PKEY_size }, + { "EVP_PKEY_type", (void *)_cffi_f_EVP_PKEY_type, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2191), (void *)_cffi_d_EVP_PKEY_type }, + { "EVP_PKEY_verify", (void *)_cffi_f_EVP_PKEY_verify, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1496), (void *)_cffi_d_EVP_PKEY_verify }, + { "EVP_PKEY_verify_init", (void *)_cffi_f_EVP_PKEY_verify_init, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1456), (void *)_cffi_d_EVP_PKEY_verify_init }, + { "EVP_PKEY_verify_recover", (void *)_cffi_f_EVP_PKEY_verify_recover, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1489), (void *)_cffi_d_EVP_PKEY_verify_recover }, + { "EVP_PKEY_verify_recover_init", (void *)_cffi_f_EVP_PKEY_verify_recover_init, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1456), (void *)_cffi_d_EVP_PKEY_verify_recover_init }, + { "EVP_R_BAD_DECRYPT", (void *)_cffi_const_EVP_R_BAD_DECRYPT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH", (void *)_cffi_const_EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_R_UNKNOWN_PBE_ALGORITHM", (void *)_cffi_const_EVP_R_UNKNOWN_PBE_ALGORITHM, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM", (void *)_cffi_const_EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "EVP_SignFinal", (void *)_cffi_f_EVP_SignFinal, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1392), (void *)_cffi_d_EVP_SignFinal }, + { "EVP_SignInit", (void *)_cffi_f_EVP_SignInit, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1350), (void *)_cffi_d_EVP_SignInit }, + { "EVP_SignUpdate", (void *)_cffi_f_EVP_SignUpdate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1411), (void *)_cffi_d_EVP_SignUpdate }, + { "EVP_VerifyFinal", (void *)_cffi_f_EVP_VerifyFinal, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1405), (void *)_cffi_d_EVP_VerifyFinal }, + { "EVP_VerifyInit", (void *)_cffi_f_EVP_VerifyInit, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1350), (void *)_cffi_d_EVP_VerifyInit }, + { "EVP_VerifyUpdate", (void *)_cffi_f_EVP_VerifyUpdate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1411), (void *)_cffi_d_EVP_VerifyUpdate }, + { "EVP_get_cipherbyname", (void *)_cffi_f_EVP_get_cipherbyname, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 261), (void *)_cffi_d_EVP_get_cipherbyname }, + { "EVP_get_digestbyname", (void *)_cffi_f_EVP_get_digestbyname, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 266), (void *)_cffi_d_EVP_get_digestbyname }, + { "FIPS_mode", (void *)_cffi_f_FIPS_mode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2280), (void *)_cffi_d_FIPS_mode }, + { "FIPS_mode_set", (void *)_cffi_f_FIPS_mode_set, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2191), (void *)_cffi_d_FIPS_mode_set }, + { "GENERAL_NAMES_free", (void *)_cffi_f_GENERAL_NAMES_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2691), (void *)_cffi_d_GENERAL_NAMES_free }, + { "GENERAL_NAMES_new", (void *)_cffi_f_GENERAL_NAMES_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 326), (void *)_cffi_d_GENERAL_NAMES_new }, + { "GENERAL_NAME_free", (void *)_cffi_f_GENERAL_NAME_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2688), (void *)_cffi_d_GENERAL_NAME_free }, + { "GENERAL_NAME_new", (void *)_cffi_f_GENERAL_NAME_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 319), (void *)_cffi_d_GENERAL_NAME_new }, + { "GENERAL_NAME_print", (void *)_cffi_f_GENERAL_NAME_print, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 926), (void *)_cffi_d_GENERAL_NAME_print }, + { "GENERAL_SUBTREE_new", (void *)_cffi_f_GENERAL_SUBTREE_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 332), (void *)_cffi_d_GENERAL_SUBTREE_new }, + { "GEN_DIRNAME", (void *)_cffi_const_GEN_DIRNAME, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "GEN_DNS", (void *)_cffi_const_GEN_DNS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "GEN_EDIPARTY", (void *)_cffi_const_GEN_EDIPARTY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "GEN_EMAIL", (void *)_cffi_const_GEN_EMAIL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "GEN_IPADD", (void *)_cffi_const_GEN_IPADD, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "GEN_OTHERNAME", (void *)_cffi_const_GEN_OTHERNAME, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "GEN_RID", (void *)_cffi_const_GEN_RID, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "GEN_URI", (void *)_cffi_const_GEN_URI, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "GEN_X400", (void *)_cffi_const_GEN_X400, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "HMAC_CTX_copy", (void *)_cffi_f_HMAC_CTX_copy, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1514), (void *)_cffi_d_HMAC_CTX_copy }, + { "HMAC_CTX_free", (void *)_cffi_f_HMAC_CTX_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2698), (void *)_cffi_d_HMAC_CTX_free }, + { "HMAC_CTX_new", (void *)_cffi_f_HMAC_CTX_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 334), (void *)_cffi_d_HMAC_CTX_new }, + { "HMAC_Final", (void *)_cffi_f_HMAC_Final, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1518), (void *)_cffi_d_HMAC_Final }, + { "HMAC_Init_ex", (void *)_cffi_f_HMAC_Init_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1528), (void *)_cffi_d_HMAC_Init_ex }, + { "HMAC_Update", (void *)_cffi_f_HMAC_Update, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1523), (void *)_cffi_d_HMAC_Update }, + { "ISSUING_DIST_POINT_free", (void *)_cffi_f_ISSUING_DIST_POINT_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2701), (void *)_cffi_d_ISSUING_DIST_POINT_free }, + { "ISSUING_DIST_POINT_new", (void *)_cffi_f_ISSUING_DIST_POINT_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 336), (void *)_cffi_d_ISSUING_DIST_POINT_new }, + { "MBSTRING_UTF8", (void *)_cffi_const_MBSTRING_UTF8, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "NAME_CONSTRAINTS_free", (void *)_cffi_f_NAME_CONSTRAINTS_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2704), (void *)_cffi_d_NAME_CONSTRAINTS_free }, + { "NAME_CONSTRAINTS_new", (void *)_cffi_f_NAME_CONSTRAINTS_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 338), (void *)_cffi_d_NAME_CONSTRAINTS_new }, + { "NETSCAPE_SPKI_b64_decode", (void *)_cffi_f_NETSCAPE_SPKI_b64_decode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 340), (void *)_cffi_d_NETSCAPE_SPKI_b64_decode }, + { "NETSCAPE_SPKI_b64_encode", (void *)_cffi_f_NETSCAPE_SPKI_b64_encode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 714), (void *)_cffi_d_NETSCAPE_SPKI_b64_encode }, + { "NETSCAPE_SPKI_free", (void *)_cffi_f_NETSCAPE_SPKI_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2707), (void *)_cffi_d_NETSCAPE_SPKI_free }, + { "NETSCAPE_SPKI_get_pubkey", (void *)_cffi_f_NETSCAPE_SPKI_get_pubkey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 287), (void *)_cffi_d_NETSCAPE_SPKI_get_pubkey }, + { "NETSCAPE_SPKI_new", (void *)_cffi_f_NETSCAPE_SPKI_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 344), (void *)_cffi_d_NETSCAPE_SPKI_new }, + { "NETSCAPE_SPKI_set_pubkey", (void *)_cffi_f_NETSCAPE_SPKI_set_pubkey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1535), (void *)_cffi_d_NETSCAPE_SPKI_set_pubkey }, + { "NETSCAPE_SPKI_sign", (void *)_cffi_f_NETSCAPE_SPKI_sign, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1539), (void *)_cffi_d_NETSCAPE_SPKI_sign }, + { "NETSCAPE_SPKI_verify", (void *)_cffi_f_NETSCAPE_SPKI_verify, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1535), (void *)_cffi_d_NETSCAPE_SPKI_verify }, + { "NID_ED25519", (void *)_cffi_const_NID_ED25519, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "NID_ED448", (void *)_cffi_const_NID_ED448, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "NID_X25519", (void *)_cffi_const_NID_X25519, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "NID_X448", (void *)_cffi_const_NID_X448, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "NID_crl_reason", (void *)_cffi_const_NID_crl_reason, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "NID_pbe_WithSHA1And3_Key_TripleDES_CBC", (void *)_cffi_const_NID_pbe_WithSHA1And3_Key_TripleDES_CBC, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "NID_pkcs7_signed", (void *)_cffi_const_NID_pkcs7_signed, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "NID_poly1305", (void *)_cffi_const_NID_poly1305, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "NID_subject_alt_name", (void *)_cffi_const_NID_subject_alt_name, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "NID_undef", (void *)_cffi_const_NID_undef, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "NOTICEREF_free", (void *)_cffi_f_NOTICEREF_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2710), (void *)_cffi_d_NOTICEREF_free }, + { "NOTICEREF_new", (void *)_cffi_f_NOTICEREF_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 346), (void *)_cffi_d_NOTICEREF_new }, + { "OBJ_NAME_TYPE_MD_METH", (void *)_cffi_const_OBJ_NAME_TYPE_MD_METH, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "OBJ_nid2ln", (void *)_cffi_f_OBJ_nid2ln, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 735), (void *)_cffi_d_OBJ_nid2ln }, + { "OBJ_nid2sn", (void *)_cffi_f_OBJ_nid2sn, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 735), (void *)_cffi_d_OBJ_nid2sn }, + { "OBJ_obj2nid", (void *)_cffi_f_OBJ_obj2nid, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 764), (void *)_cffi_d_OBJ_obj2nid }, + { "OBJ_obj2txt", (void *)_cffi_f_OBJ_obj2txt, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2154), (void *)_cffi_d_OBJ_obj2txt }, + { "OBJ_sn2nid", (void *)_cffi_f_OBJ_sn2nid, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2166), (void *)_cffi_d_OBJ_sn2nid }, + { "OBJ_txt2nid", (void *)_cffi_f_OBJ_txt2nid, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2166), (void *)_cffi_d_OBJ_txt2nid }, + { "OBJ_txt2obj", (void *)_cffi_f_OBJ_txt2obj, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 45), (void *)_cffi_d_OBJ_txt2obj }, + { "OCSP_BASICRESP_add_ext", (void *)_cffi_f_OCSP_BASICRESP_add_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1559), (void *)_cffi_d_OCSP_BASICRESP_add_ext }, + { "OCSP_BASICRESP_free", (void *)_cffi_f_OCSP_BASICRESP_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2713), (void *)_cffi_d_OCSP_BASICRESP_free }, + { "OCSP_BASICRESP_get_ext", (void *)_cffi_f_OCSP_BASICRESP_get_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 585), (void *)_cffi_d_OCSP_BASICRESP_get_ext }, + { "OCSP_BASICRESP_get_ext_count", (void *)_cffi_f_OCSP_BASICRESP_get_ext_count, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1544), (void *)_cffi_d_OCSP_BASICRESP_get_ext_count }, + { "OCSP_BASICRESP_new", (void *)_cffi_f_OCSP_BASICRESP_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 351), (void *)_cffi_d_OCSP_BASICRESP_new }, + { "OCSP_CERTID_free", (void *)_cffi_f_OCSP_CERTID_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2716), (void *)_cffi_d_OCSP_CERTID_free }, + { "OCSP_NOCERTS", (void *)_cffi_const_OCSP_NOCERTS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "OCSP_REQUEST_add_ext", (void *)_cffi_f_OCSP_REQUEST_add_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1572), (void *)_cffi_d_OCSP_REQUEST_add_ext }, + { "OCSP_REQUEST_free", (void *)_cffi_f_OCSP_REQUEST_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2719), (void *)_cffi_d_OCSP_REQUEST_free }, + { "OCSP_REQUEST_get_ext", (void *)_cffi_f_OCSP_REQUEST_get_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 589), (void *)_cffi_d_OCSP_REQUEST_get_ext }, + { "OCSP_REQUEST_get_ext_count", (void *)_cffi_f_OCSP_REQUEST_get_ext_count, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1569), (void *)_cffi_d_OCSP_REQUEST_get_ext_count }, + { "OCSP_REQUEST_new", (void *)_cffi_f_OCSP_REQUEST_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 376), (void *)_cffi_d_OCSP_REQUEST_new }, + { "OCSP_RESPID_KEY", (void *)_cffi_const_OCSP_RESPID_KEY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "OCSP_RESPONSE_free", (void *)_cffi_f_OCSP_RESPONSE_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2722), (void *)_cffi_d_OCSP_RESPONSE_free }, + { "OCSP_SINGLERESP_get0_id", (void *)_cffi_f_OCSP_SINGLERESP_get0_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 361), (void *)_cffi_d_OCSP_SINGLERESP_get0_id }, + { "OCSP_SINGLERESP_get_ext", (void *)_cffi_f_OCSP_SINGLERESP_get_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 593), (void *)_cffi_d_OCSP_SINGLERESP_get_ext }, + { "OCSP_SINGLERESP_get_ext_count", (void *)_cffi_f_OCSP_SINGLERESP_get_ext_count, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1584), (void *)_cffi_d_OCSP_SINGLERESP_get_ext_count }, + { "OCSP_basic_add1_cert", (void *)_cffi_f_OCSP_basic_add1_cert, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1547), (void *)_cffi_d_OCSP_basic_add1_cert }, + { "OCSP_basic_add1_status", (void *)_cffi_f_OCSP_basic_add1_status, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 389), (void *)_cffi_d_OCSP_basic_add1_status }, + { "OCSP_basic_sign", (void *)_cffi_f_OCSP_basic_sign, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1551), (void *)_cffi_d_OCSP_basic_sign }, + { "OCSP_cert_to_id", (void *)_cffi_f_OCSP_cert_to_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 353), (void *)_cffi_d_OCSP_cert_to_id }, + { "OCSP_id_get0_info", (void *)_cffi_f_OCSP_id_get0_info, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 767), (void *)_cffi_d_OCSP_id_get0_info }, + { "OCSP_onereq_get0_id", (void *)_cffi_f_OCSP_onereq_get0_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 358), (void *)_cffi_d_OCSP_onereq_get0_id }, + { "OCSP_request_add0_id", (void *)_cffi_f_OCSP_request_add0_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 364), (void *)_cffi_d_OCSP_request_add0_id }, + { "OCSP_request_onereq_count", (void *)_cffi_f_OCSP_request_onereq_count, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1569), (void *)_cffi_d_OCSP_request_onereq_count }, + { "OCSP_request_onereq_get0", (void *)_cffi_f_OCSP_request_onereq_get0, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 368), (void *)_cffi_d_OCSP_request_onereq_get0 }, + { "OCSP_resp_count", (void *)_cffi_f_OCSP_resp_count, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1544), (void *)_cffi_d_OCSP_resp_count }, + { "OCSP_resp_get0", (void *)_cffi_f_OCSP_resp_get0, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 398), (void *)_cffi_d_OCSP_resp_get0 }, + { "OCSP_resp_get0_certs", (void *)_cffi_f_OCSP_resp_get0_certs, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 153), (void *)_cffi_d_OCSP_resp_get0_certs }, + { "OCSP_resp_get0_id", (void *)_cffi_f_OCSP_resp_get0_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1564), (void *)_cffi_d_OCSP_resp_get0_id }, + { "OCSP_resp_get0_produced_at", (void *)_cffi_f_OCSP_resp_get0_produced_at, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 16), (void *)_cffi_d_OCSP_resp_get0_produced_at }, + { "OCSP_resp_get0_respdata", (void *)_cffi_f_OCSP_resp_get0_respdata, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 378), (void *)_cffi_d_OCSP_resp_get0_respdata }, + { "OCSP_resp_get0_signature", (void *)_cffi_f_OCSP_resp_get0_signature, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 67), (void *)_cffi_d_OCSP_resp_get0_signature }, + { "OCSP_resp_get0_tbs_sigalg", (void *)_cffi_f_OCSP_resp_get0_tbs_sigalg, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 544), (void *)_cffi_d_OCSP_resp_get0_tbs_sigalg }, + { "OCSP_response_create", (void *)_cffi_f_OCSP_response_create, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 385), (void *)_cffi_d_OCSP_response_create }, + { "OCSP_response_get1_basic", (void *)_cffi_f_OCSP_response_get1_basic, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 348), (void *)_cffi_d_OCSP_response_get1_basic }, + { "OCSP_response_status", (void *)_cffi_f_OCSP_response_status, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1581), (void *)_cffi_d_OCSP_response_status }, + { "OCSP_single_get0_status", (void *)_cffi_f_OCSP_single_get0_status, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1587), (void *)_cffi_d_OCSP_single_get0_status }, + { "OPENSSL_BUILT_ON", (void *)_cffi_const_OPENSSL_BUILT_ON, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "OPENSSL_CFLAGS", (void *)_cffi_const_OPENSSL_CFLAGS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "OPENSSL_DIR", (void *)_cffi_const_OPENSSL_DIR, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "OPENSSL_EC_NAMED_CURVE", (void *)_cffi_const_OPENSSL_EC_NAMED_CURVE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "OPENSSL_PLATFORM", (void *)_cffi_const_OPENSSL_PLATFORM, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "OPENSSL_VERSION", (void *)_cffi_const_OPENSSL_VERSION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "OPENSSL_VERSION_NUMBER", (void *)_cffi_const_OPENSSL_VERSION_NUMBER, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "OPENSSL_VERSION_TEXT", (void *)_cffi_const_OPENSSL_VERSION_TEXT, _CFFI_OP(_CFFI_OP_CONSTANT, 46), (void *)0 }, + { "OPENSSL_cleanup", (void *)_cffi_f_OPENSSL_cleanup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2998), (void *)_cffi_d_OPENSSL_cleanup }, + { "OPENSSL_config", (void *)_cffi_f_OPENSSL_config, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2970), (void *)_cffi_d_OPENSSL_config }, + { "OPENSSL_free", (void *)_cffi_f_OPENSSL_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2985), (void *)_cffi_d_OPENSSL_free }, + { "OPENSSL_malloc", (void *)_cffi_f_OPENSSL_malloc, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2508), (void *)_cffi_d_OPENSSL_malloc }, + { "OPENSSL_no_config", (void *)_cffi_f_OPENSSL_no_config, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2998), (void *)_cffi_d_OPENSSL_no_config }, + { "OTHERNAME_free", (void *)_cffi_f_OTHERNAME_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2725), (void *)_cffi_d_OTHERNAME_free }, + { "OTHERNAME_new", (void *)_cffi_f_OTHERNAME_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 402), (void *)_cffi_d_OTHERNAME_new }, + { "OpenSSL_add_all_algorithms", (void *)_cffi_f_OpenSSL_add_all_algorithms, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2998), (void *)_cffi_d_OpenSSL_add_all_algorithms }, + { "OpenSSL_version", (void *)_cffi_f_OpenSSL_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 735), (void *)_cffi_d_OpenSSL_version }, + { "OpenSSL_version_num", (void *)_cffi_f_OpenSSL_version_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2476), (void *)_cffi_d_OpenSSL_version_num }, + { "PEM_R_UNSUPPORTED_ENCRYPTION", (void *)_cffi_const_PEM_R_UNSUPPORTED_ENCRYPTION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PEM_read_bio_DHparams", (void *)_cffi_f_PEM_read_bio_DHparams, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 189), (void *)_cffi_d_PEM_read_bio_DHparams }, + { "PEM_read_bio_PKCS7", (void *)_cffi_f_PEM_read_bio_PKCS7, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 428), (void *)_cffi_d_PEM_read_bio_PKCS7 }, + { "PEM_read_bio_PUBKEY", (void *)_cffi_f_PEM_read_bio_PUBKEY, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 275), (void *)_cffi_d_PEM_read_bio_PUBKEY }, + { "PEM_read_bio_PrivateKey", (void *)_cffi_f_PEM_read_bio_PrivateKey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 275), (void *)_cffi_d_PEM_read_bio_PrivateKey }, + { "PEM_read_bio_RSAPublicKey", (void *)_cffi_f_PEM_read_bio_RSAPublicKey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 466), (void *)_cffi_d_PEM_read_bio_RSAPublicKey }, + { "PEM_read_bio_X509", (void *)_cffi_f_PEM_read_bio_X509, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 520), (void *)_cffi_d_PEM_read_bio_X509 }, + { "PEM_read_bio_X509_CRL", (void *)_cffi_f_PEM_read_bio_X509_CRL, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 558), (void *)_cffi_d_PEM_read_bio_X509_CRL }, + { "PEM_read_bio_X509_REQ", (void *)_cffi_f_PEM_read_bio_X509_REQ, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 673), (void *)_cffi_d_PEM_read_bio_X509_REQ }, + { "PEM_write_bio_DHparams", (void *)_cffi_f_PEM_write_bio_DHparams, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 874), (void *)_cffi_d_PEM_write_bio_DHparams }, + { "PEM_write_bio_DHxparams", (void *)_cffi_f_PEM_write_bio_DHxparams, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 874), (void *)_cffi_d_PEM_write_bio_DHxparams }, + { "PEM_write_bio_DSAPrivateKey", (void *)_cffi_f_PEM_write_bio_DSAPrivateKey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 882), (void *)_cffi_d_PEM_write_bio_DSAPrivateKey }, + { "PEM_write_bio_ECPrivateKey", (void *)_cffi_f_PEM_write_bio_ECPrivateKey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 895), (void *)_cffi_d_PEM_write_bio_ECPrivateKey }, + { "PEM_write_bio_PKCS7", (void *)_cffi_f_PEM_write_bio_PKCS7, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 942), (void *)_cffi_d_PEM_write_bio_PKCS7 }, + { "PEM_write_bio_PKCS7_stream", (void *)_cffi_f_PEM_write_bio_PKCS7_stream, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 946), (void *)_cffi_d_PEM_write_bio_PKCS7_stream }, + { "PEM_write_bio_PKCS8PrivateKey", (void *)_cffi_f_PEM_write_bio_PKCS8PrivateKey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 908), (void *)_cffi_d_PEM_write_bio_PKCS8PrivateKey }, + { "PEM_write_bio_PUBKEY", (void *)_cffi_f_PEM_write_bio_PUBKEY, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 904), (void *)_cffi_d_PEM_write_bio_PUBKEY }, + { "PEM_write_bio_PrivateKey", (void *)_cffi_f_PEM_write_bio_PrivateKey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 917), (void *)_cffi_d_PEM_write_bio_PrivateKey }, + { "PEM_write_bio_RSAPrivateKey", (void *)_cffi_f_PEM_write_bio_RSAPrivateKey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 956), (void *)_cffi_d_PEM_write_bio_RSAPrivateKey }, + { "PEM_write_bio_RSAPublicKey", (void *)_cffi_f_PEM_write_bio_RSAPublicKey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 965), (void *)_cffi_d_PEM_write_bio_RSAPublicKey }, + { "PEM_write_bio_X509", (void *)_cffi_f_PEM_write_bio_X509, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 974), (void *)_cffi_d_PEM_write_bio_X509 }, + { "PEM_write_bio_X509_CRL", (void *)_cffi_f_PEM_write_bio_X509_CRL, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 984), (void *)_cffi_d_PEM_write_bio_X509_CRL }, + { "PEM_write_bio_X509_REQ", (void *)_cffi_f_PEM_write_bio_X509_REQ, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1000), (void *)_cffi_d_PEM_write_bio_X509_REQ }, + { "PKCS12_R_PKCS12_CIPHERFINAL_ERROR", (void *)_cffi_const_PKCS12_R_PKCS12_CIPHERFINAL_ERROR, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS12_create", (void *)_cffi_f_PKCS12_create, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 408), (void *)_cffi_d_PKCS12_create }, + { "PKCS12_free", (void *)_cffi_f_PKCS12_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2728), (void *)_cffi_d_PKCS12_free }, + { "PKCS12_parse", (void *)_cffi_f_PKCS12_parse, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1594), (void *)_cffi_d_PKCS12_parse }, + { "PKCS5_PBKDF2_HMAC", (void *)_cffi_f_PKCS5_PBKDF2_HMAC, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2169), (void *)_cffi_d_PKCS5_PBKDF2_HMAC }, + { "PKCS7_BINARY", (void *)_cffi_const_PKCS7_BINARY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_DETACHED", (void *)_cffi_const_PKCS7_DETACHED, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_NOATTR", (void *)_cffi_const_PKCS7_NOATTR, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_NOCERTS", (void *)_cffi_const_PKCS7_NOCERTS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_NOCHAIN", (void *)_cffi_const_PKCS7_NOCHAIN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_NOINTERN", (void *)_cffi_const_PKCS7_NOINTERN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_NOSIGS", (void *)_cffi_const_PKCS7_NOSIGS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_NOSMIMECAP", (void *)_cffi_const_PKCS7_NOSMIMECAP, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_NOVERIFY", (void *)_cffi_const_PKCS7_NOVERIFY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_PARTIAL", (void *)_cffi_const_PKCS7_PARTIAL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_STREAM", (void *)_cffi_const_PKCS7_STREAM, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_TEXT", (void *)_cffi_const_PKCS7_TEXT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "PKCS7_final", (void *)_cffi_f_PKCS7_final, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1604), (void *)_cffi_d_PKCS7_final }, + { "PKCS7_free", (void *)_cffi_f_PKCS7_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2731), (void *)_cffi_d_PKCS7_free }, + { "PKCS7_sign", (void *)_cffi_f_PKCS7_sign, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 434), (void *)_cffi_d_PKCS7_sign }, + { "PKCS7_sign_add_signer", (void *)_cffi_f_PKCS7_sign_add_signer, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 441), (void *)_cffi_d_PKCS7_sign_add_signer }, + { "PKCS7_type_is_data", (void *)_cffi_f_PKCS7_type_is_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1601), (void *)_cffi_d_PKCS7_type_is_data }, + { "PKCS7_type_is_enveloped", (void *)_cffi_f_PKCS7_type_is_enveloped, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1601), (void *)_cffi_d_PKCS7_type_is_enveloped }, + { "PKCS7_type_is_signed", (void *)_cffi_f_PKCS7_type_is_signed, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1601), (void *)_cffi_d_PKCS7_type_is_signed }, + { "PKCS7_type_is_signedAndEnveloped", (void *)_cffi_f_PKCS7_type_is_signedAndEnveloped, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1601), (void *)_cffi_d_PKCS7_type_is_signedAndEnveloped }, + { "PKCS7_verify", (void *)_cffi_f_PKCS7_verify, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1609), (void *)_cffi_d_PKCS7_verify }, + { "POINT_CONVERSION_COMPRESSED", (void *)_cffi_const_POINT_CONVERSION_COMPRESSED, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "POINT_CONVERSION_UNCOMPRESSED", (void *)_cffi_const_POINT_CONVERSION_UNCOMPRESSED, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "POLICYINFO_free", (void *)_cffi_f_POLICYINFO_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2734), (void *)_cffi_d_POLICYINFO_free }, + { "POLICYINFO_new", (void *)_cffi_f_POLICYINFO_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 452), (void *)_cffi_d_POLICYINFO_new }, + { "POLICYQUALINFO_free", (void *)_cffi_f_POLICYQUALINFO_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2737), (void *)_cffi_d_POLICYQUALINFO_free }, + { "POLICYQUALINFO_new", (void *)_cffi_f_POLICYQUALINFO_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 458), (void *)_cffi_d_POLICYQUALINFO_new }, + { "POLICY_CONSTRAINTS_free", (void *)_cffi_f_POLICY_CONSTRAINTS_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2740), (void *)_cffi_d_POLICY_CONSTRAINTS_free }, + { "POLICY_CONSTRAINTS_new", (void *)_cffi_f_POLICY_CONSTRAINTS_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 460), (void *)_cffi_d_POLICY_CONSTRAINTS_new }, + { "RAND_add", (void *)_cffi_f_RAND_add, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2993), (void *)_cffi_d_RAND_add }, + { "RAND_bytes", (void *)_cffi_f_RAND_bytes, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2258), (void *)_cffi_d_RAND_bytes }, + { "RAND_set_rand_method", (void *)_cffi_f_RAND_set_rand_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1617), (void *)_cffi_d_RAND_set_rand_method }, + { "RAND_status", (void *)_cffi_f_RAND_status, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2280), (void *)_cffi_d_RAND_status }, + { "RSAPublicKey_dup", (void *)_cffi_f_RSAPublicKey_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 475), (void *)_cffi_d_RSAPublicKey_dup }, + { "RSA_F4", (void *)_cffi_const_RSA_F4, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "RSA_NO_PADDING", (void *)_cffi_const_RSA_NO_PADDING, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "RSA_PKCS1_OAEP_PADDING", (void *)_cffi_const_RSA_PKCS1_OAEP_PADDING, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "RSA_PKCS1_PADDING", (void *)_cffi_const_RSA_PKCS1_PADDING, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "RSA_PKCS1_PSS_PADDING", (void *)_cffi_const_RSA_PKCS1_PSS_PADDING, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "RSA_blinding_on", (void *)_cffi_f_RSA_blinding_on, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1631), (void *)_cffi_d_RSA_blinding_on }, + { "RSA_check_key", (void *)_cffi_f_RSA_check_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1641), (void *)_cffi_d_RSA_check_key }, + { "RSA_free", (void *)_cffi_f_RSA_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2743), (void *)_cffi_d_RSA_free }, + { "RSA_generate_key_ex", (void *)_cffi_f_RSA_generate_key_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1635), (void *)_cffi_d_RSA_generate_key_ex }, + { "RSA_get0_crt_params", (void *)_cffi_f_RSA_get0_crt_params, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2751), (void *)_cffi_d_RSA_get0_crt_params }, + { "RSA_get0_factors", (void *)_cffi_f_RSA_get0_factors, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2746), (void *)_cffi_d_RSA_get0_factors }, + { "RSA_get0_key", (void *)_cffi_f_RSA_get0_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2751), (void *)_cffi_d_RSA_get0_key }, + { "RSA_new", (void *)_cffi_f_RSA_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 478), (void *)_cffi_d_RSA_new }, + { "RSA_print", (void *)_cffi_f_RSA_print, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 969), (void *)_cffi_d_RSA_print }, + { "RSA_set0_crt_params", (void *)_cffi_f_RSA_set0_crt_params, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1625), (void *)_cffi_d_RSA_set0_crt_params }, + { "RSA_set0_factors", (void *)_cffi_f_RSA_set0_factors, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1620), (void *)_cffi_d_RSA_set0_factors }, + { "RSA_set0_key", (void *)_cffi_f_RSA_set0_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1625), (void *)_cffi_d_RSA_set0_key }, + { "SCT_LIST_free", (void *)_cffi_f_SCT_LIST_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2614), (void *)_cffi_d_SCT_LIST_free }, + { "SCT_SOURCE_OCSP_STAPLED_RESPONSE", (void *)_cffi_const_SCT_SOURCE_OCSP_STAPLED_RESPONSE, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "SCT_SOURCE_TLS_EXTENSION", (void *)_cffi_const_SCT_SOURCE_TLS_EXTENSION, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "SCT_SOURCE_UNKNOWN", (void *)_cffi_const_SCT_SOURCE_UNKNOWN, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "SCT_SOURCE_X509V3_EXTENSION", (void *)_cffi_const_SCT_SOURCE_X509V3_EXTENSION, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "SCT_VERSION_NOT_SET", (void *)_cffi_const_SCT_VERSION_NOT_SET, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "SCT_VERSION_V1", (void *)_cffi_const_SCT_VERSION_V1, _CFFI_OP(_CFFI_OP_ENUM, -1), (void *)0 }, + { "SCT_get0_log_id", (void *)_cffi_f_SCT_get0_log_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2388), (void *)_cffi_d_SCT_get0_log_id }, + { "SCT_get0_signature", (void *)_cffi_f_SCT_get0_signature, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2388), (void *)_cffi_d_SCT_get0_signature }, + { "SCT_get_log_entry_type", (void *)_cffi_f_SCT_get_log_entry_type, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 746), (void *)_cffi_d_SCT_get_log_entry_type }, + { "SCT_get_timestamp", (void *)_cffi_f_SCT_get_timestamp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2410), (void *)_cffi_d_SCT_get_timestamp }, + { "SCT_get_version", (void *)_cffi_f_SCT_get_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2366), (void *)_cffi_d_SCT_get_version }, + { "SCT_new", (void *)_cffi_f_SCT_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 484), (void *)_cffi_d_SCT_new }, + { "SCT_set1_log_id", (void *)_cffi_f_SCT_set1_log_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1656), (void *)_cffi_d_SCT_set1_log_id }, + { "SCT_set_log_entry_type", (void *)_cffi_f_SCT_set_log_entry_type, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1644), (void *)_cffi_d_SCT_set_log_entry_type }, + { "SCT_set_source", (void *)_cffi_f_SCT_set_source, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1648), (void *)_cffi_d_SCT_set_source }, + { "SCT_set_timestamp", (void *)_cffi_f_SCT_set_timestamp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2757), (void *)_cffi_d_SCT_set_timestamp }, + { "SCT_set_version", (void *)_cffi_f_SCT_set_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1652), (void *)_cffi_d_SCT_set_version }, + { "SMIME_read_PKCS7", (void *)_cffi_f_SMIME_read_PKCS7, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 420), (void *)_cffi_d_SMIME_read_PKCS7 }, + { "SMIME_write_PKCS7", (void *)_cffi_f_SMIME_write_PKCS7, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 946), (void *)_cffi_d_SMIME_write_PKCS7 }, + { "SSL3_RANDOM_SIZE", (void *)_cffi_const_SSL3_RANDOM_SIZE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSLEAY_BUILT_ON", (void *)_cffi_const_SSLEAY_BUILT_ON, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSLEAY_CFLAGS", (void *)_cffi_const_SSLEAY_CFLAGS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSLEAY_DIR", (void *)_cffi_const_SSLEAY_DIR, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSLEAY_PLATFORM", (void *)_cffi_const_SSLEAY_PLATFORM, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSLEAY_VERSION", (void *)_cffi_const_SSLEAY_VERSION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_ACCEPT_EXIT", (void *)_cffi_const_SSL_CB_ACCEPT_EXIT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_ACCEPT_LOOP", (void *)_cffi_const_SSL_CB_ACCEPT_LOOP, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_ALERT", (void *)_cffi_const_SSL_CB_ALERT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_CONNECT_EXIT", (void *)_cffi_const_SSL_CB_CONNECT_EXIT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_CONNECT_LOOP", (void *)_cffi_const_SSL_CB_CONNECT_LOOP, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_EXIT", (void *)_cffi_const_SSL_CB_EXIT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_HANDSHAKE_DONE", (void *)_cffi_const_SSL_CB_HANDSHAKE_DONE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_HANDSHAKE_START", (void *)_cffi_const_SSL_CB_HANDSHAKE_START, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_LOOP", (void *)_cffi_const_SSL_CB_LOOP, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_READ", (void *)_cffi_const_SSL_CB_READ, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_READ_ALERT", (void *)_cffi_const_SSL_CB_READ_ALERT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_WRITE", (void *)_cffi_const_SSL_CB_WRITE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CB_WRITE_ALERT", (void *)_cffi_const_SSL_CB_WRITE_ALERT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_CIPHER_get_auth_nid", (void *)_cffi_f_SSL_CIPHER_get_auth_nid, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1772), (void *)_cffi_d_SSL_CIPHER_get_auth_nid }, + { "SSL_CIPHER_get_bits", (void *)_cffi_f_SSL_CIPHER_get_bits, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1775), (void *)_cffi_d_SSL_CIPHER_get_bits }, + { "SSL_CIPHER_get_cipher_nid", (void *)_cffi_f_SSL_CIPHER_get_cipher_nid, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1772), (void *)_cffi_d_SSL_CIPHER_get_cipher_nid }, + { "SSL_CIPHER_get_digest_nid", (void *)_cffi_f_SSL_CIPHER_get_digest_nid, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1772), (void *)_cffi_d_SSL_CIPHER_get_digest_nid }, + { "SSL_CIPHER_get_id", (void *)_cffi_f_SSL_CIPHER_get_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2413), (void *)_cffi_d_SSL_CIPHER_get_id }, + { "SSL_CIPHER_get_kx_nid", (void *)_cffi_f_SSL_CIPHER_get_kx_nid, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1772), (void *)_cffi_d_SSL_CIPHER_get_kx_nid }, + { "SSL_CIPHER_get_name", (void *)_cffi_f_SSL_CIPHER_get_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 732), (void *)_cffi_d_SSL_CIPHER_get_name }, + { "SSL_CIPHER_get_version", (void *)_cffi_f_SSL_CIPHER_get_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 732), (void *)_cffi_d_SSL_CIPHER_get_version }, + { "SSL_CIPHER_is_aead", (void *)_cffi_f_SSL_CIPHER_is_aead, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1772), (void *)_cffi_d_SSL_CIPHER_is_aead }, + { "SSL_CTX_add_client_CA", (void *)_cffi_f_SSL_CTX_add_client_CA, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1786), (void *)_cffi_d_SSL_CTX_add_client_CA }, + { "SSL_CTX_add_client_custom_ext", (void *)_cffi_f_SSL_CTX_add_client_custom_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1818), (void *)_cffi_d_SSL_CTX_add_client_custom_ext }, + { "SSL_CTX_add_extra_chain_cert", (void *)_cffi_f_SSL_CTX_add_extra_chain_cert, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2459), (void *)_cffi_d_SSL_CTX_add_extra_chain_cert }, + { "SSL_CTX_add_server_custom_ext", (void *)_cffi_f_SSL_CTX_add_server_custom_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1818), (void *)_cffi_d_SSL_CTX_add_server_custom_ext }, + { "SSL_CTX_check_private_key", (void *)_cffi_f_SSL_CTX_check_private_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1827), (void *)_cffi_d_SSL_CTX_check_private_key }, + { "SSL_CTX_clear_mode", (void *)_cffi_f_SSL_CTX_clear_mode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2463), (void *)_cffi_d_SSL_CTX_clear_mode }, + { "SSL_CTX_clear_options", (void *)_cffi_f_SSL_CTX_clear_options, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2463), (void *)_cffi_d_SSL_CTX_clear_options }, + { "SSL_CTX_free", (void *)_cffi_f_SSL_CTX_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2802), (void *)_cffi_d_SSL_CTX_free }, + { "SSL_CTX_get0_param", (void *)_cffi_f_SSL_CTX_get0_param, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 700), (void *)_cffi_d_SSL_CTX_get0_param }, + { "SSL_CTX_get_cert_store", (void *)_cffi_f_SSL_CTX_get_cert_store, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 690), (void *)_cffi_d_SSL_CTX_get_cert_store }, + { "SSL_CTX_get_ex_data", (void *)_cffi_f_SSL_CTX_get_ex_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2482), (void *)_cffi_d_SSL_CTX_get_ex_data }, + { "SSL_CTX_get_ex_new_index", (void *)_cffi_f_SSL_CTX_get_ex_new_index, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2234), (void *)_cffi_d_SSL_CTX_get_ex_new_index }, + { "SSL_CTX_get_info_callback", (void *)_cffi_f_SSL_CTX_get_info_callback, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 3003), (void *)_cffi_d_SSL_CTX_get_info_callback }, + { "SSL_CTX_get_keylog_callback", (void *)_cffi_f_SSL_CTX_get_keylog_callback, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 3000), (void *)_cffi_d_SSL_CTX_get_keylog_callback }, + { "SSL_CTX_get_max_proto_version", (void *)_cffi_f_SSL_CTX_get_max_proto_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_get_max_proto_version }, + { "SSL_CTX_get_min_proto_version", (void *)_cffi_f_SSL_CTX_get_min_proto_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_get_min_proto_version }, + { "SSL_CTX_get_mode", (void *)_cffi_f_SSL_CTX_get_mode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2448), (void *)_cffi_d_SSL_CTX_get_mode }, + { "SSL_CTX_get_options", (void *)_cffi_f_SSL_CTX_get_options, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2448), (void *)_cffi_d_SSL_CTX_get_options }, + { "SSL_CTX_get_read_ahead", (void *)_cffi_f_SSL_CTX_get_read_ahead, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_get_read_ahead }, + { "SSL_CTX_get_session_cache_mode", (void *)_cffi_f_SSL_CTX_get_session_cache_mode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2448), (void *)_cffi_d_SSL_CTX_get_session_cache_mode }, + { "SSL_CTX_get_timeout", (void *)_cffi_f_SSL_CTX_get_timeout, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2351), (void *)_cffi_d_SSL_CTX_get_timeout }, + { "SSL_CTX_get_verify_depth", (void *)_cffi_f_SSL_CTX_get_verify_depth, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1827), (void *)_cffi_d_SSL_CTX_get_verify_depth }, + { "SSL_CTX_get_verify_mode", (void *)_cffi_f_SSL_CTX_get_verify_mode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1827), (void *)_cffi_d_SSL_CTX_get_verify_mode }, + { "SSL_CTX_load_verify_locations", (void *)_cffi_f_SSL_CTX_load_verify_locations, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1794), (void *)_cffi_d_SSL_CTX_load_verify_locations }, + { "SSL_CTX_new", (void *)_cffi_f_SSL_CTX_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 503), (void *)_cffi_d_SSL_CTX_new }, + { "SSL_CTX_sess_accept", (void *)_cffi_f_SSL_CTX_sess_accept, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_accept }, + { "SSL_CTX_sess_accept_good", (void *)_cffi_f_SSL_CTX_sess_accept_good, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_accept_good }, + { "SSL_CTX_sess_accept_renegotiate", (void *)_cffi_f_SSL_CTX_sess_accept_renegotiate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_accept_renegotiate }, + { "SSL_CTX_sess_cache_full", (void *)_cffi_f_SSL_CTX_sess_cache_full, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_cache_full }, + { "SSL_CTX_sess_cb_hits", (void *)_cffi_f_SSL_CTX_sess_cb_hits, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_cb_hits }, + { "SSL_CTX_sess_connect", (void *)_cffi_f_SSL_CTX_sess_connect, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_connect }, + { "SSL_CTX_sess_connect_good", (void *)_cffi_f_SSL_CTX_sess_connect_good, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_connect_good }, + { "SSL_CTX_sess_connect_renegotiate", (void *)_cffi_f_SSL_CTX_sess_connect_renegotiate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_connect_renegotiate }, + { "SSL_CTX_sess_hits", (void *)_cffi_f_SSL_CTX_sess_hits, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_hits }, + { "SSL_CTX_sess_misses", (void *)_cffi_f_SSL_CTX_sess_misses, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_misses }, + { "SSL_CTX_sess_number", (void *)_cffi_f_SSL_CTX_sess_number, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_number }, + { "SSL_CTX_sess_timeouts", (void *)_cffi_f_SSL_CTX_sess_timeouts, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2328), (void *)_cffi_d_SSL_CTX_sess_timeouts }, + { "SSL_CTX_set1_sigalgs_list", (void *)_cffi_f_SSL_CTX_set1_sigalgs_list, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2331), (void *)_cffi_d_SSL_CTX_set1_sigalgs_list }, + { "SSL_CTX_set_alpn_protos", (void *)_cffi_f_SSL_CTX_set_alpn_protos, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1813), (void *)_cffi_d_SSL_CTX_set_alpn_protos }, + { "SSL_CTX_set_alpn_select_cb", (void *)_cffi_f_SSL_CTX_set_alpn_select_cb, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2821), (void *)_cffi_d_SSL_CTX_set_alpn_select_cb }, + { "SSL_CTX_set_cert_cb", (void *)_cffi_f_SSL_CTX_set_cert_cb, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2826), (void *)_cffi_d_SSL_CTX_set_cert_cb }, + { "SSL_CTX_set_cert_store", (void *)_cffi_f_SSL_CTX_set_cert_store, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2809), (void *)_cffi_d_SSL_CTX_set_cert_store }, + { "SSL_CTX_set_cert_verify_callback", (void *)_cffi_f_SSL_CTX_set_cert_verify_callback, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2831), (void *)_cffi_d_SSL_CTX_set_cert_verify_callback }, + { "SSL_CTX_set_cipher_list", (void *)_cffi_f_SSL_CTX_set_cipher_list, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1790), (void *)_cffi_d_SSL_CTX_set_cipher_list }, + { "SSL_CTX_set_ciphersuites", (void *)_cffi_f_SSL_CTX_set_ciphersuites, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1790), (void *)_cffi_d_SSL_CTX_set_ciphersuites }, + { "SSL_CTX_set_client_CA_list", (void *)_cffi_f_SSL_CTX_set_client_CA_list, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2805), (void *)_cffi_d_SSL_CTX_set_client_CA_list }, + { "SSL_CTX_set_cookie_generate_cb", (void *)_cffi_f_SSL_CTX_set_cookie_generate_cb, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2817), (void *)_cffi_d_SSL_CTX_set_cookie_generate_cb }, + { "SSL_CTX_set_default_passwd_cb", (void *)_cffi_f_SSL_CTX_set_default_passwd_cb, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2836), (void *)_cffi_d_SSL_CTX_set_default_passwd_cb }, + { "SSL_CTX_set_default_passwd_cb_userdata", (void *)_cffi_f_SSL_CTX_set_default_passwd_cb_userdata, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2857), (void *)_cffi_d_SSL_CTX_set_default_passwd_cb_userdata }, + { "SSL_CTX_set_default_verify_paths", (void *)_cffi_f_SSL_CTX_set_default_verify_paths, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1779), (void *)_cffi_d_SSL_CTX_set_default_verify_paths }, + { "SSL_CTX_set_ecdh_auto", (void *)_cffi_f_SSL_CTX_set_ecdh_auto, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2339), (void *)_cffi_d_SSL_CTX_set_ecdh_auto }, + { "SSL_CTX_set_ex_data", (void *)_cffi_f_SSL_CTX_set_ex_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1804), (void *)_cffi_d_SSL_CTX_set_ex_data }, + { "SSL_CTX_set_info_callback", (void *)_cffi_f_SSL_CTX_set_info_callback, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2865), (void *)_cffi_d_SSL_CTX_set_info_callback }, + { "SSL_CTX_set_keylog_callback", (void *)_cffi_f_SSL_CTX_set_keylog_callback, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2861), (void *)_cffi_d_SSL_CTX_set_keylog_callback }, + { "SSL_CTX_set_max_early_data", (void *)_cffi_f_SSL_CTX_set_max_early_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1809), (void *)_cffi_d_SSL_CTX_set_max_early_data }, + { "SSL_CTX_set_max_proto_version", (void *)_cffi_f_SSL_CTX_set_max_proto_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2339), (void *)_cffi_d_SSL_CTX_set_max_proto_version }, + { "SSL_CTX_set_min_proto_version", (void *)_cffi_f_SSL_CTX_set_min_proto_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2339), (void *)_cffi_d_SSL_CTX_set_min_proto_version }, + { "SSL_CTX_set_mode", (void *)_cffi_f_SSL_CTX_set_mode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2463), (void *)_cffi_d_SSL_CTX_set_mode }, + { "SSL_CTX_set_options", (void *)_cffi_f_SSL_CTX_set_options, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2463), (void *)_cffi_d_SSL_CTX_set_options }, + { "SSL_CTX_set_post_handshake_auth", (void *)_cffi_f_SSL_CTX_set_post_handshake_auth, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2840), (void *)_cffi_d_SSL_CTX_set_post_handshake_auth }, + { "SSL_CTX_set_psk_client_callback", (void *)_cffi_f_SSL_CTX_set_psk_client_callback, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2849), (void *)_cffi_d_SSL_CTX_set_psk_client_callback }, + { "SSL_CTX_set_psk_server_callback", (void *)_cffi_f_SSL_CTX_set_psk_server_callback, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2853), (void *)_cffi_d_SSL_CTX_set_psk_server_callback }, + { "SSL_CTX_set_read_ahead", (void *)_cffi_f_SSL_CTX_set_read_ahead, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2343), (void *)_cffi_d_SSL_CTX_set_read_ahead }, + { "SSL_CTX_set_session_cache_mode", (void *)_cffi_f_SSL_CTX_set_session_cache_mode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2463), (void *)_cffi_d_SSL_CTX_set_session_cache_mode }, + { "SSL_CTX_set_session_id_context", (void *)_cffi_f_SSL_CTX_set_session_id_context, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1813), (void *)_cffi_d_SSL_CTX_set_session_id_context }, + { "SSL_CTX_set_timeout", (void *)_cffi_f_SSL_CTX_set_timeout, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2343), (void *)_cffi_d_SSL_CTX_set_timeout }, + { "SSL_CTX_set_tlsext_servername_arg", (void *)_cffi_f_SSL_CTX_set_tlsext_servername_arg, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2857), (void *)_cffi_d_SSL_CTX_set_tlsext_servername_arg }, + { "SSL_CTX_set_tlsext_servername_callback", (void *)_cffi_f_SSL_CTX_set_tlsext_servername_callback, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2813), (void *)_cffi_d_SSL_CTX_set_tlsext_servername_callback }, + { "SSL_CTX_set_tlsext_status_arg", (void *)_cffi_f_SSL_CTX_set_tlsext_status_arg, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2347), (void *)_cffi_d_SSL_CTX_set_tlsext_status_arg }, + { "SSL_CTX_set_tlsext_status_cb", (void *)_cffi_f_SSL_CTX_set_tlsext_status_cb, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2335), (void *)_cffi_d_SSL_CTX_set_tlsext_status_cb }, + { "SSL_CTX_set_tlsext_use_srtp", (void *)_cffi_f_SSL_CTX_set_tlsext_use_srtp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1790), (void *)_cffi_d_SSL_CTX_set_tlsext_use_srtp }, + { "SSL_CTX_set_tmp_dh", (void *)_cffi_f_SSL_CTX_set_tmp_dh, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2451), (void *)_cffi_d_SSL_CTX_set_tmp_dh }, + { "SSL_CTX_set_tmp_ecdh", (void *)_cffi_f_SSL_CTX_set_tmp_ecdh, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2455), (void *)_cffi_d_SSL_CTX_set_tmp_ecdh }, + { "SSL_CTX_set_verify", (void *)_cffi_f_SSL_CTX_set_verify, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2844), (void *)_cffi_d_SSL_CTX_set_verify }, + { "SSL_CTX_set_verify_depth", (void *)_cffi_f_SSL_CTX_set_verify_depth, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2840), (void *)_cffi_d_SSL_CTX_set_verify_depth }, + { "SSL_CTX_use_PrivateKey", (void *)_cffi_f_SSL_CTX_use_PrivateKey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1782), (void *)_cffi_d_SSL_CTX_use_PrivateKey }, + { "SSL_CTX_use_PrivateKey_file", (void *)_cffi_f_SSL_CTX_use_PrivateKey_file, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1799), (void *)_cffi_d_SSL_CTX_use_PrivateKey_file }, + { "SSL_CTX_use_certificate", (void *)_cffi_f_SSL_CTX_use_certificate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1786), (void *)_cffi_d_SSL_CTX_use_certificate }, + { "SSL_CTX_use_certificate_chain_file", (void *)_cffi_f_SSL_CTX_use_certificate_chain_file, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1790), (void *)_cffi_d_SSL_CTX_use_certificate_chain_file }, + { "SSL_CTX_use_certificate_file", (void *)_cffi_f_SSL_CTX_use_certificate_file, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1799), (void *)_cffi_d_SSL_CTX_use_certificate_file }, + { "SSL_CTX_use_psk_identity_hint", (void *)_cffi_f_SSL_CTX_use_psk_identity_hint, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1790), (void *)_cffi_d_SSL_CTX_use_psk_identity_hint }, + { "SSL_ERROR_NONE", (void *)_cffi_const_SSL_ERROR_NONE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ERROR_SSL", (void *)_cffi_const_SSL_ERROR_SSL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ERROR_SYSCALL", (void *)_cffi_const_SSL_ERROR_SYSCALL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ERROR_WANT_CONNECT", (void *)_cffi_const_SSL_ERROR_WANT_CONNECT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ERROR_WANT_READ", (void *)_cffi_const_SSL_ERROR_WANT_READ, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ERROR_WANT_WRITE", (void *)_cffi_const_SSL_ERROR_WANT_WRITE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ERROR_WANT_X509_LOOKUP", (void *)_cffi_const_SSL_ERROR_WANT_X509_LOOKUP, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ERROR_ZERO_RETURN", (void *)_cffi_const_SSL_ERROR_ZERO_RETURN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_FILETYPE_ASN1", (void *)_cffi_const_SSL_FILETYPE_ASN1, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_FILETYPE_PEM", (void *)_cffi_const_SSL_FILETYPE_PEM, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER", (void *)_cffi_const_SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_MODE_AUTO_RETRY", (void *)_cffi_const_SSL_MODE_AUTO_RETRY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_MODE_ENABLE_PARTIAL_WRITE", (void *)_cffi_const_SSL_MODE_ENABLE_PARTIAL_WRITE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_MODE_RELEASE_BUFFERS", (void *)_cffi_const_SSL_MODE_RELEASE_BUFFERS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_ALL", (void *)_cffi_const_SSL_OP_ALL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION", (void *)_cffi_const_SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_CIPHER_SERVER_PREFERENCE", (void *)_cffi_const_SSL_OP_CIPHER_SERVER_PREFERENCE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_COOKIE_EXCHANGE", (void *)_cffi_const_SSL_OP_COOKIE_EXCHANGE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS", (void *)_cffi_const_SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_EPHEMERAL_RSA", (void *)_cffi_const_SSL_OP_EPHEMERAL_RSA, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_LEGACY_SERVER_CONNECT", (void *)_cffi_const_SSL_OP_LEGACY_SERVER_CONNECT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER", (void *)_cffi_const_SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_MICROSOFT_SESS_ID_BUG", (void *)_cffi_const_SSL_OP_MICROSOFT_SESS_ID_BUG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_MSIE_SSLV2_RSA_PADDING", (void *)_cffi_const_SSL_OP_MSIE_SSLV2_RSA_PADDING, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NETSCAPE_CA_DN_BUG", (void *)_cffi_const_SSL_OP_NETSCAPE_CA_DN_BUG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NETSCAPE_CHALLENGE_BUG", (void *)_cffi_const_SSL_OP_NETSCAPE_CHALLENGE_BUG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG", (void *)_cffi_const_SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG", (void *)_cffi_const_SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NO_COMPRESSION", (void *)_cffi_const_SSL_OP_NO_COMPRESSION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NO_DTLSv1", (void *)_cffi_const_SSL_OP_NO_DTLSv1, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NO_DTLSv1_2", (void *)_cffi_const_SSL_OP_NO_DTLSv1_2, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NO_QUERY_MTU", (void *)_cffi_const_SSL_OP_NO_QUERY_MTU, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NO_SSLv2", (void *)_cffi_const_SSL_OP_NO_SSLv2, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NO_SSLv3", (void *)_cffi_const_SSL_OP_NO_SSLv3, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NO_TICKET", (void *)_cffi_const_SSL_OP_NO_TICKET, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NO_TLSv1", (void *)_cffi_const_SSL_OP_NO_TLSv1, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NO_TLSv1_1", (void *)_cffi_const_SSL_OP_NO_TLSv1_1, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NO_TLSv1_2", (void *)_cffi_const_SSL_OP_NO_TLSv1_2, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_NO_TLSv1_3", (void *)_cffi_const_SSL_OP_NO_TLSv1_3, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_PKCS1_CHECK_1", (void *)_cffi_const_SSL_OP_PKCS1_CHECK_1, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_PKCS1_CHECK_2", (void *)_cffi_const_SSL_OP_PKCS1_CHECK_2, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_SINGLE_DH_USE", (void *)_cffi_const_SSL_OP_SINGLE_DH_USE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_SINGLE_ECDH_USE", (void *)_cffi_const_SSL_OP_SINGLE_ECDH_USE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_SSLEAY_080_CLIENT_DH_BUG", (void *)_cffi_const_SSL_OP_SSLEAY_080_CLIENT_DH_BUG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG", (void *)_cffi_const_SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_TLS_BLOCK_PADDING_BUG", (void *)_cffi_const_SSL_OP_TLS_BLOCK_PADDING_BUG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_TLS_D5_BUG", (void *)_cffi_const_SSL_OP_TLS_D5_BUG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_OP_TLS_ROLLBACK_BUG", (void *)_cffi_const_SSL_OP_TLS_ROLLBACK_BUG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_RECEIVED_SHUTDOWN", (void *)_cffi_const_SSL_RECEIVED_SHUTDOWN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_SENT_SHUTDOWN", (void *)_cffi_const_SSL_SENT_SHUTDOWN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_SESSION_free", (void *)_cffi_f_SSL_SESSION_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2869), (void *)_cffi_d_SSL_SESSION_free }, + { "SSL_SESSION_get_id", (void *)_cffi_f_SSL_SESSION_get_id, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2423), (void *)_cffi_d_SSL_SESSION_get_id }, + { "SSL_SESSION_get_master_key", (void *)_cffi_f_SSL_SESSION_get_master_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2402), (void *)_cffi_d_SSL_SESSION_get_master_key }, + { "SSL_SESSION_get_max_early_data", (void *)_cffi_f_SSL_SESSION_get_max_early_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2407), (void *)_cffi_d_SSL_SESSION_get_max_early_data }, + { "SSL_SESSION_get_ticket_lifetime_hint", (void *)_cffi_f_SSL_SESSION_get_ticket_lifetime_hint, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2354), (void *)_cffi_d_SSL_SESSION_get_ticket_lifetime_hint }, + { "SSL_SESSION_get_time", (void *)_cffi_f_SSL_SESSION_get_time, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2354), (void *)_cffi_d_SSL_SESSION_get_time }, + { "SSL_SESSION_get_timeout", (void *)_cffi_f_SSL_SESSION_get_timeout, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2354), (void *)_cffi_d_SSL_SESSION_get_timeout }, + { "SSL_SESSION_has_ticket", (void *)_cffi_f_SSL_SESSION_has_ticket, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1835), (void *)_cffi_d_SSL_SESSION_has_ticket }, + { "SSL_SESSION_set1_id_context", (void *)_cffi_f_SSL_SESSION_set1_id_context, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1830), (void *)_cffi_d_SSL_SESSION_set1_id_context }, + { "SSL_SESS_CACHE_BOTH", (void *)_cffi_const_SSL_SESS_CACHE_BOTH, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_SESS_CACHE_CLIENT", (void *)_cffi_const_SSL_SESS_CACHE_CLIENT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_SESS_CACHE_NO_AUTO_CLEAR", (void *)_cffi_const_SSL_SESS_CACHE_NO_AUTO_CLEAR, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_SESS_CACHE_NO_INTERNAL", (void *)_cffi_const_SSL_SESS_CACHE_NO_INTERNAL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_SESS_CACHE_NO_INTERNAL_LOOKUP", (void *)_cffi_const_SSL_SESS_CACHE_NO_INTERNAL_LOOKUP, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_SESS_CACHE_NO_INTERNAL_STORE", (void *)_cffi_const_SSL_SESS_CACHE_NO_INTERNAL_STORE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_SESS_CACHE_OFF", (void *)_cffi_const_SSL_SESS_CACHE_OFF, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_SESS_CACHE_SERVER", (void *)_cffi_const_SSL_SESS_CACHE_SERVER, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ST_ACCEPT", (void *)_cffi_const_SSL_ST_ACCEPT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ST_BEFORE", (void *)_cffi_const_SSL_ST_BEFORE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ST_CONNECT", (void *)_cffi_const_SSL_ST_CONNECT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ST_INIT", (void *)_cffi_const_SSL_ST_INIT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ST_MASK", (void *)_cffi_const_SSL_ST_MASK, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ST_OK", (void *)_cffi_const_SSL_ST_OK, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_ST_RENEGOTIATE", (void *)_cffi_const_SSL_ST_RENEGOTIATE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_TLSEXT_ERR_ALERT_FATAL", (void *)_cffi_const_SSL_TLSEXT_ERR_ALERT_FATAL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_TLSEXT_ERR_NOACK", (void *)_cffi_const_SSL_TLSEXT_ERR_NOACK, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_TLSEXT_ERR_OK", (void *)_cffi_const_SSL_TLSEXT_ERR_OK, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_VERIFY_CLIENT_ONCE", (void *)_cffi_const_SSL_VERIFY_CLIENT_ONCE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_VERIFY_FAIL_IF_NO_PEER_CERT", (void *)_cffi_const_SSL_VERIFY_FAIL_IF_NO_PEER_CERT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_VERIFY_NONE", (void *)_cffi_const_SSL_VERIFY_NONE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_VERIFY_PEER", (void *)_cffi_const_SSL_VERIFY_PEER, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_VERIFY_POST_HANDSHAKE", (void *)_cffi_const_SSL_VERIFY_POST_HANDSHAKE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "SSL_clear_mode", (void *)_cffi_f_SSL_clear_mode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2444), (void *)_cffi_d_SSL_clear_mode }, + { "SSL_do_handshake", (void *)_cffi_f_SSL_do_handshake, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1661), (void *)_cffi_d_SSL_do_handshake }, + { "SSL_export_keying_material", (void *)_cffi_f_SSL_export_keying_material, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1695), (void *)_cffi_d_SSL_export_keying_material }, + { "SSL_extension_supported", (void *)_cffi_f_SSL_extension_supported, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2262), (void *)_cffi_d_SSL_extension_supported }, + { "SSL_free", (void *)_cffi_f_SSL_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2761), (void *)_cffi_d_SSL_free }, + { "SSL_get0_alpn_selected", (void *)_cffi_f_SSL_get0_alpn_selected, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2797), (void *)_cffi_d_SSL_get0_alpn_selected }, + { "SSL_get0_param", (void *)_cffi_f_SSL_get0_param, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 697), (void *)_cffi_d_SSL_get0_param }, + { "SSL_get0_verified_chain", (void *)_cffi_f_SSL_get0_verified_chain, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 156), (void *)_cffi_d_SSL_get0_verified_chain }, + { "SSL_get1_session", (void *)_cffi_f_SSL_get1_session, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 508), (void *)_cffi_d_SSL_get1_session }, + { "SSL_get_certificate", (void *)_cffi_f_SSL_get_certificate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 530), (void *)_cffi_d_SSL_get_certificate }, + { "SSL_get_cipher_list", (void *)_cffi_f_SSL_get_cipher_list, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 728), (void *)_cffi_d_SSL_get_cipher_list }, + { "SSL_get_client_CA_list", (void *)_cffi_f_SSL_get_client_CA_list, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 166), (void *)_cffi_d_SSL_get_client_CA_list }, + { "SSL_get_client_random", (void *)_cffi_f_SSL_get_client_random, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2392), (void *)_cffi_d_SSL_get_client_random }, + { "SSL_get_current_cipher", (void *)_cffi_f_SSL_get_current_cipher, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 496), (void *)_cffi_d_SSL_get_current_cipher }, + { "SSL_get_error", (void *)_cffi_f_SSL_get_error, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1768), (void *)_cffi_d_SSL_get_error }, + { "SSL_get_ex_data", (void *)_cffi_f_SSL_get_ex_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2478), (void *)_cffi_d_SSL_get_ex_data }, + { "SSL_get_ex_data_X509_STORE_CTX_idx", (void *)_cffi_f_SSL_get_ex_data_X509_STORE_CTX_idx, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2280), (void *)_cffi_d_SSL_get_ex_data_X509_STORE_CTX_idx }, + { "SSL_get_ex_new_index", (void *)_cffi_f_SSL_get_ex_new_index, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2234), (void *)_cffi_d_SSL_get_ex_new_index }, + { "SSL_get_finished", (void *)_cffi_f_SSL_get_finished, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2397), (void *)_cffi_d_SSL_get_finished }, + { "SSL_get_max_proto_version", (void *)_cffi_f_SSL_get_max_proto_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2296), (void *)_cffi_d_SSL_get_max_proto_version }, + { "SSL_get_min_proto_version", (void *)_cffi_f_SSL_get_min_proto_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2296), (void *)_cffi_d_SSL_get_min_proto_version }, + { "SSL_get_mode", (void *)_cffi_f_SSL_get_mode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2441), (void *)_cffi_d_SSL_get_mode }, + { "SSL_get_options", (void *)_cffi_f_SSL_get_options, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2441), (void *)_cffi_d_SSL_get_options }, + { "SSL_get_peer_cert_chain", (void *)_cffi_f_SSL_get_peer_cert_chain, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 156), (void *)_cffi_d_SSL_get_peer_cert_chain }, + { "SSL_get_peer_certificate", (void *)_cffi_f_SSL_get_peer_certificate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 530), (void *)_cffi_d_SSL_get_peer_certificate }, + { "SSL_get_peer_finished", (void *)_cffi_f_SSL_get_peer_finished, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2397), (void *)_cffi_d_SSL_get_peer_finished }, + { "SSL_get_secure_renegotiation_support", (void *)_cffi_f_SSL_get_secure_renegotiation_support, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2296), (void *)_cffi_d_SSL_get_secure_renegotiation_support }, + { "SSL_get_selected_srtp_profile", (void *)_cffi_f_SSL_get_selected_srtp_profile, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 486), (void *)_cffi_d_SSL_get_selected_srtp_profile }, + { "SSL_get_server_random", (void *)_cffi_f_SSL_get_server_random, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2392), (void *)_cffi_d_SSL_get_server_random }, + { "SSL_get_server_tmp_key", (void *)_cffi_f_SSL_get_server_tmp_key, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2299), (void *)_cffi_d_SSL_get_server_tmp_key }, + { "SSL_get_servername", (void *)_cffi_f_SSL_get_servername, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 728), (void *)_cffi_d_SSL_get_servername }, + { "SSL_get_session", (void *)_cffi_f_SSL_get_session, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 511), (void *)_cffi_d_SSL_get_session }, + { "SSL_get_shutdown", (void *)_cffi_f_SSL_get_shutdown, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1765), (void *)_cffi_d_SSL_get_shutdown }, + { "SSL_get_sigalgs", (void *)_cffi_f_SSL_get_sigalgs, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1681), (void *)_cffi_d_SSL_get_sigalgs }, + { "SSL_get_tlsext_status_ocsp_resp", (void *)_cffi_f_SSL_get_tlsext_status_ocsp_resp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2321), (void *)_cffi_d_SSL_get_tlsext_status_ocsp_resp }, + { "SSL_get_verify_result", (void *)_cffi_f_SSL_get_verify_result, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2325), (void *)_cffi_d_SSL_get_verify_result }, + { "SSL_get_version", (void *)_cffi_f_SSL_get_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 725), (void *)_cffi_d_SSL_get_version }, + { "SSL_library_init", (void *)_cffi_f_SSL_library_init, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2280), (void *)_cffi_d_SSL_library_init }, + { "SSL_load_client_CA_file", (void *)_cffi_f_SSL_load_client_CA_file, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 169), (void *)_cffi_d_SSL_load_client_CA_file }, + { "SSL_load_error_strings", (void *)_cffi_f_SSL_load_error_strings, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2998), (void *)_cffi_d_SSL_load_error_strings }, + { "SSL_new", (void *)_cffi_f_SSL_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 489), (void *)_cffi_d_SSL_new }, + { "SSL_peek", (void *)_cffi_f_SSL_peek, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1743), (void *)_cffi_d_SSL_peek }, + { "SSL_pending", (void *)_cffi_f_SSL_pending, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1765), (void *)_cffi_d_SSL_pending }, + { "SSL_read", (void *)_cffi_f_SSL_read, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1743), (void *)_cffi_d_SSL_read }, + { "SSL_read_early_data", (void *)_cffi_f_SSL_read_early_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1748), (void *)_cffi_d_SSL_read_early_data }, + { "SSL_renegotiate", (void *)_cffi_f_SSL_renegotiate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1661), (void *)_cffi_d_SSL_renegotiate }, + { "SSL_renegotiate_pending", (void *)_cffi_f_SSL_renegotiate_pending, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1661), (void *)_cffi_d_SSL_renegotiate_pending }, + { "SSL_select_next_proto", (void *)_cffi_f_SSL_select_next_proto, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2245), (void *)_cffi_d_SSL_select_next_proto }, + { "SSL_session_reused", (void *)_cffi_f_SSL_session_reused, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2296), (void *)_cffi_d_SSL_session_reused }, + { "SSL_set_SSL_CTX", (void *)_cffi_f_SSL_set_SSL_CTX, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 499), (void *)_cffi_d_SSL_set_SSL_CTX }, + { "SSL_set_accept_state", (void *)_cffi_f_SSL_set_accept_state, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2761), (void *)_cffi_d_SSL_set_accept_state }, + { "SSL_set_alpn_protos", (void *)_cffi_f_SSL_set_alpn_protos, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1718), (void *)_cffi_d_SSL_set_alpn_protos }, + { "SSL_set_bio", (void *)_cffi_f_SSL_set_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2764), (void *)_cffi_d_SSL_set_bio }, + { "SSL_set_cert_cb", (void *)_cffi_f_SSL_set_cert_cb, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2773), (void *)_cffi_d_SSL_set_cert_cb }, + { "SSL_set_connect_state", (void *)_cffi_f_SSL_set_connect_state, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2761), (void *)_cffi_d_SSL_set_connect_state }, + { "SSL_set_ex_data", (void *)_cffi_f_SSL_set_ex_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1690), (void *)_cffi_d_SSL_set_ex_data }, + { "SSL_set_fd", (void *)_cffi_f_SSL_set_fd, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1677), (void *)_cffi_d_SSL_set_fd }, + { "SSL_set_max_proto_version", (void *)_cffi_f_SSL_set_max_proto_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2303), (void *)_cffi_d_SSL_set_max_proto_version }, + { "SSL_set_min_proto_version", (void *)_cffi_f_SSL_set_min_proto_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2303), (void *)_cffi_d_SSL_set_min_proto_version }, + { "SSL_set_mode", (void *)_cffi_f_SSL_set_mode, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2444), (void *)_cffi_d_SSL_set_mode }, + { "SSL_set_options", (void *)_cffi_f_SSL_set_options, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2444), (void *)_cffi_d_SSL_set_options }, + { "SSL_set_post_handshake_auth", (void *)_cffi_f_SSL_set_post_handshake_auth, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2778), (void *)_cffi_d_SSL_set_post_handshake_auth }, + { "SSL_set_session", (void *)_cffi_f_SSL_set_session, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1664), (void *)_cffi_d_SSL_set_session }, + { "SSL_set_shutdown", (void *)_cffi_f_SSL_set_shutdown, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2778), (void *)_cffi_d_SSL_set_shutdown }, + { "SSL_set_tlsext_host_name", (void *)_cffi_f_SSL_set_tlsext_host_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2769), (void *)_cffi_d_SSL_set_tlsext_host_name }, + { "SSL_set_tlsext_status_ocsp_resp", (void *)_cffi_f_SSL_set_tlsext_status_ocsp_resp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2316), (void *)_cffi_d_SSL_set_tlsext_status_ocsp_resp }, + { "SSL_set_tlsext_status_type", (void *)_cffi_f_SSL_set_tlsext_status_type, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2307), (void *)_cffi_d_SSL_set_tlsext_status_type }, + { "SSL_set_tlsext_use_srtp", (void *)_cffi_f_SSL_set_tlsext_use_srtp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1668), (void *)_cffi_d_SSL_set_tlsext_use_srtp }, + { "SSL_shutdown", (void *)_cffi_f_SSL_shutdown, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1661), (void *)_cffi_d_SSL_shutdown }, + { "SSL_state_string_long", (void *)_cffi_f_SSL_state_string_long, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 725), (void *)_cffi_d_SSL_state_string_long }, + { "SSL_total_renegotiations", (void *)_cffi_f_SSL_total_renegotiations, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2296), (void *)_cffi_d_SSL_total_renegotiations }, + { "SSL_verify_client_post_handshake", (void *)_cffi_f_SSL_verify_client_post_handshake, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1661), (void *)_cffi_d_SSL_verify_client_post_handshake }, + { "SSL_version", (void *)_cffi_f_SSL_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1765), (void *)_cffi_d_SSL_version }, + { "SSL_want_read", (void *)_cffi_f_SSL_want_read, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1765), (void *)_cffi_d_SSL_want_read }, + { "SSL_want_write", (void *)_cffi_f_SSL_want_write, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1765), (void *)_cffi_d_SSL_want_write }, + { "SSL_write", (void *)_cffi_f_SSL_write, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1754), (void *)_cffi_d_SSL_write }, + { "SSL_write_early_data", (void *)_cffi_f_SSL_write_early_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1759), (void *)_cffi_d_SSL_write_early_data }, + { "SSLeay", (void *)_cffi_f_SSLeay, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 2476), (void *)_cffi_d_SSLeay }, + { "SSLeay_version", (void *)_cffi_f_SSLeay_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 735), (void *)_cffi_d_SSLeay_version }, + { "SSLv23_client_method", (void *)_cffi_f_SSLv23_client_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_SSLv23_client_method }, + { "SSLv23_method", (void *)_cffi_f_SSLv23_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_SSLv23_method }, + { "SSLv23_server_method", (void *)_cffi_f_SSLv23_server_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_SSLv23_server_method }, + { "SSLv3_client_method", (void *)_cffi_f_SSLv3_client_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_SSLv3_client_method }, + { "SSLv3_method", (void *)_cffi_f_SSLv3_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_SSLv3_method }, + { "SSLv3_server_method", (void *)_cffi_f_SSLv3_server_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_SSLv3_server_method }, + { "TLSEXT_NAMETYPE_host_name", (void *)_cffi_const_TLSEXT_NAMETYPE_host_name, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "TLSEXT_STATUSTYPE_ocsp", (void *)_cffi_const_TLSEXT_STATUSTYPE_ocsp, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "TLS_ST_BEFORE", (void *)_cffi_const_TLS_ST_BEFORE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "TLS_ST_OK", (void *)_cffi_const_TLS_ST_OK, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "TLS_client_method", (void *)_cffi_f_TLS_client_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLS_client_method }, + { "TLS_method", (void *)_cffi_f_TLS_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLS_method }, + { "TLS_server_method", (void *)_cffi_f_TLS_server_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLS_server_method }, + { "TLSv1_1_client_method", (void *)_cffi_f_TLSv1_1_client_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLSv1_1_client_method }, + { "TLSv1_1_method", (void *)_cffi_f_TLSv1_1_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLSv1_1_method }, + { "TLSv1_1_server_method", (void *)_cffi_f_TLSv1_1_server_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLSv1_1_server_method }, + { "TLSv1_2_client_method", (void *)_cffi_f_TLSv1_2_client_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLSv1_2_client_method }, + { "TLSv1_2_method", (void *)_cffi_f_TLSv1_2_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLSv1_2_method }, + { "TLSv1_2_server_method", (void *)_cffi_f_TLSv1_2_server_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLSv1_2_server_method }, + { "TLSv1_client_method", (void *)_cffi_f_TLSv1_client_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLSv1_client_method }, + { "TLSv1_method", (void *)_cffi_f_TLSv1_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLSv1_method }, + { "TLSv1_server_method", (void *)_cffi_f_TLSv1_server_method, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 506), (void *)_cffi_d_TLSv1_server_method }, + { "USERNOTICE_free", (void *)_cffi_f_USERNOTICE_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2872), (void *)_cffi_d_USERNOTICE_free }, + { "USERNOTICE_new", (void *)_cffi_f_USERNOTICE_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 514), (void *)_cffi_d_USERNOTICE_new }, + { "V_ASN1_GENERALIZEDTIME", (void *)_cffi_const_V_ASN1_GENERALIZEDTIME, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509V3_EXT_add_alias", (void *)_cffi_f_X509V3_EXT_add_alias, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2198), (void *)_cffi_d_X509V3_EXT_add_alias }, + { "X509V3_EXT_conf_nid", (void *)_cffi_f_X509V3_EXT_conf_nid, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 579), (void *)_cffi_d_X509V3_EXT_conf_nid }, + { "X509V3_EXT_d2i", (void *)_cffi_f_X509V3_EXT_d2i, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2501), (void *)_cffi_d_X509V3_EXT_d2i }, + { "X509V3_EXT_i2d", (void *)_cffi_f_X509V3_EXT_i2d, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 622), (void *)_cffi_d_X509V3_EXT_i2d }, + { "X509V3_EXT_nconf", (void *)_cffi_f_X509V3_EXT_nconf, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 573), (void *)_cffi_d_X509V3_EXT_nconf }, + { "X509V3_EXT_print", (void *)_cffi_f_X509V3_EXT_print, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 988), (void *)_cffi_d_X509V3_EXT_print }, + { "X509V3_set_ctx", (void *)_cffi_f_X509V3_set_ctx, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2878), (void *)_cffi_d_X509V3_set_ctx }, + { "X509V3_set_ctx_nodb", (void *)_cffi_f_X509V3_set_ctx_nodb, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2492), (void *)_cffi_d_X509V3_set_ctx_nodb }, + { "X509_ATTRIBUTE_count", (void *)_cffi_f_X509_ATTRIBUTE_count, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1893), (void *)_cffi_d_X509_ATTRIBUTE_count }, + { "X509_ATTRIBUTE_get0_data", (void *)_cffi_f_X509_ATTRIBUTE_get0_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2495), (void *)_cffi_d_X509_ATTRIBUTE_get0_data }, + { "X509_ATTRIBUTE_get0_type", (void *)_cffi_f_X509_ATTRIBUTE_get0_type, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 78), (void *)_cffi_d_X509_ATTRIBUTE_get0_type }, + { "X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT", (void *)_cffi_const_X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS", (void *)_cffi_const_X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_CHECK_FLAG_NEVER_CHECK_SUBJECT", (void *)_cffi_const_X509_CHECK_FLAG_NEVER_CHECK_SUBJECT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS", (void *)_cffi_const_X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_CHECK_FLAG_NO_WILDCARDS", (void *)_cffi_const_X509_CHECK_FLAG_NO_WILDCARDS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS", (void *)_cffi_const_X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_CRL_add0_revoked", (void *)_cffi_f_X509_CRL_add0_revoked, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1926), (void *)_cffi_d_X509_CRL_add0_revoked }, + { "X509_CRL_add_ext", (void *)_cffi_f_X509_CRL_add_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1912), (void *)_cffi_d_X509_CRL_add_ext }, + { "X509_CRL_cmp", (void *)_cffi_f_X509_CRL_cmp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1938), (void *)_cffi_d_X509_CRL_cmp }, + { "X509_CRL_dup", (void *)_cffi_f_X509_CRL_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 568), (void *)_cffi_d_X509_CRL_dup }, + { "X509_CRL_free", (void *)_cffi_f_X509_CRL_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2886), (void *)_cffi_d_X509_CRL_free }, + { "X509_CRL_get0_by_serial", (void *)_cffi_f_X509_CRL_get0_by_serial, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1921), (void *)_cffi_d_X509_CRL_get0_by_serial }, + { "X509_CRL_get0_signature", (void *)_cffi_f_X509_CRL_get0_signature, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2889), (void *)_cffi_d_X509_CRL_get0_signature }, + { "X509_CRL_get_REVOKED", (void *)_cffi_f_X509_CRL_get_REVOKED, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 182), (void *)_cffi_d_X509_CRL_get_REVOKED }, + { "X509_CRL_get_ext", (void *)_cffi_f_X509_CRL_get_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 601), (void *)_cffi_d_X509_CRL_get_ext }, + { "X509_CRL_get_ext_count", (void *)_cffi_f_X509_CRL_get_ext_count, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1896), (void *)_cffi_d_X509_CRL_get_ext_count }, + { "X509_CRL_get_issuer", (void *)_cffi_f_X509_CRL_get_issuer, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 639), (void *)_cffi_d_X509_CRL_get_issuer }, + { "X509_CRL_get_lastUpdate", (void *)_cffi_f_X509_CRL_get_lastUpdate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 56), (void *)_cffi_d_X509_CRL_get_lastUpdate }, + { "X509_CRL_get_nextUpdate", (void *)_cffi_f_X509_CRL_get_nextUpdate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 56), (void *)_cffi_d_X509_CRL_get_nextUpdate }, + { "X509_CRL_get_version", (void *)_cffi_f_X509_CRL_get_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2360), (void *)_cffi_d_X509_CRL_get_version }, + { "X509_CRL_new", (void *)_cffi_f_X509_CRL_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 571), (void *)_cffi_d_X509_CRL_new }, + { "X509_CRL_print", (void *)_cffi_f_X509_CRL_print, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 984), (void *)_cffi_d_X509_CRL_print }, + { "X509_CRL_set_issuer_name", (void *)_cffi_f_X509_CRL_set_issuer_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1917), (void *)_cffi_d_X509_CRL_set_issuer_name }, + { "X509_CRL_set_lastUpdate", (void *)_cffi_f_X509_CRL_set_lastUpdate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1899), (void *)_cffi_d_X509_CRL_set_lastUpdate }, + { "X509_CRL_set_nextUpdate", (void *)_cffi_f_X509_CRL_set_nextUpdate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1899), (void *)_cffi_d_X509_CRL_set_nextUpdate }, + { "X509_CRL_set_version", (void *)_cffi_f_X509_CRL_set_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1930), (void *)_cffi_d_X509_CRL_set_version }, + { "X509_CRL_sign", (void *)_cffi_f_X509_CRL_sign, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1907), (void *)_cffi_d_X509_CRL_sign }, + { "X509_CRL_sort", (void *)_cffi_f_X509_CRL_sort, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1896), (void *)_cffi_d_X509_CRL_sort }, + { "X509_CRL_verify", (void *)_cffi_f_X509_CRL_verify, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1903), (void *)_cffi_d_X509_CRL_verify }, + { "X509_EXTENSION_create_by_OBJ", (void *)_cffi_f_X509_EXTENSION_create_by_OBJ, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 605), (void *)_cffi_d_X509_EXTENSION_create_by_OBJ }, + { "X509_EXTENSION_dup", (void *)_cffi_f_X509_EXTENSION_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 611), (void *)_cffi_d_X509_EXTENSION_dup }, + { "X509_EXTENSION_free", (void *)_cffi_f_X509_EXTENSION_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2894), (void *)_cffi_d_X509_EXTENSION_free }, + { "X509_EXTENSION_get_critical", (void *)_cffi_f_X509_EXTENSION_get_critical, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1942), (void *)_cffi_d_X509_EXTENSION_get_critical }, + { "X509_EXTENSION_get_data", (void *)_cffi_f_X509_EXTENSION_get_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 59), (void *)_cffi_d_X509_EXTENSION_get_data }, + { "X509_EXTENSION_get_object", (void *)_cffi_f_X509_EXTENSION_get_object, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 39), (void *)_cffi_d_X509_EXTENSION_get_object }, + { "X509_LU_CRL", (void *)_cffi_const_X509_LU_CRL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_LU_X509", (void *)_cffi_const_X509_LU_X509, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_NAME_ENTRY_create_by_OBJ", (void *)_cffi_f_X509_NAME_ENTRY_create_by_OBJ, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 658), (void *)_cffi_d_X509_NAME_ENTRY_create_by_OBJ }, + { "X509_NAME_ENTRY_free", (void *)_cffi_f_X509_NAME_ENTRY_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2907), (void *)_cffi_d_X509_NAME_ENTRY_free }, + { "X509_NAME_ENTRY_get_data", (void *)_cffi_f_X509_NAME_ENTRY_get_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 62), (void *)_cffi_d_X509_NAME_ENTRY_get_data }, + { "X509_NAME_ENTRY_get_object", (void *)_cffi_f_X509_NAME_ENTRY_get_object, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 42), (void *)_cffi_d_X509_NAME_ENTRY_get_object }, + { "X509_NAME_ENTRY_set", (void *)_cffi_f_X509_NAME_ENTRY_set, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2006), (void *)_cffi_d_X509_NAME_ENTRY_set }, + { "X509_NAME_add_entry", (void *)_cffi_f_X509_NAME_add_entry, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1969), (void *)_cffi_d_X509_NAME_add_entry }, + { "X509_NAME_add_entry_by_NID", (void *)_cffi_f_X509_NAME_add_entry_by_NID, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1989), (void *)_cffi_d_X509_NAME_add_entry_by_NID }, + { "X509_NAME_add_entry_by_OBJ", (void *)_cffi_f_X509_NAME_add_entry_by_OBJ, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1960), (void *)_cffi_d_X509_NAME_add_entry_by_OBJ }, + { "X509_NAME_add_entry_by_txt", (void *)_cffi_f_X509_NAME_add_entry_by_txt, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1975), (void *)_cffi_d_X509_NAME_add_entry_by_txt }, + { "X509_NAME_cmp", (void *)_cffi_f_X509_NAME_cmp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2002), (void *)_cffi_d_X509_NAME_cmp }, + { "X509_NAME_delete_entry", (void *)_cffi_f_X509_NAME_delete_entry, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 654), (void *)_cffi_d_X509_NAME_delete_entry }, + { "X509_NAME_dup", (void *)_cffi_f_X509_NAME_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 642), (void *)_cffi_d_X509_NAME_dup }, + { "X509_NAME_entry_count", (void *)_cffi_f_X509_NAME_entry_count, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1957), (void *)_cffi_d_X509_NAME_entry_count }, + { "X509_NAME_free", (void *)_cffi_f_X509_NAME_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2904), (void *)_cffi_d_X509_NAME_free }, + { "X509_NAME_get_entry", (void *)_cffi_f_X509_NAME_get_entry, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 654), (void *)_cffi_d_X509_NAME_get_entry }, + { "X509_NAME_get_index_by_NID", (void *)_cffi_f_X509_NAME_get_index_by_NID, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1984), (void *)_cffi_d_X509_NAME_get_index_by_NID }, + { "X509_NAME_hash", (void *)_cffi_f_X509_NAME_hash, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2470), (void *)_cffi_d_X509_NAME_hash }, + { "X509_NAME_new", (void *)_cffi_f_X509_NAME_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 648), (void *)_cffi_d_X509_NAME_new }, + { "X509_NAME_oneline", (void *)_cffi_f_X509_NAME_oneline, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 717), (void *)_cffi_d_X509_NAME_oneline }, + { "X509_NAME_print_ex", (void *)_cffi_f_X509_NAME_print_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 994), (void *)_cffi_d_X509_NAME_print_ex }, + { "X509_OBJECT_get0_X509", (void *)_cffi_f_X509_OBJECT_get0_X509, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 536), (void *)_cffi_d_X509_OBJECT_get0_X509 }, + { "X509_OBJECT_get_type", (void *)_cffi_f_X509_OBJECT_get_type, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2009), (void *)_cffi_d_X509_OBJECT_get_type }, + { "X509_REQ_add1_attr_by_OBJ", (void *)_cffi_f_X509_REQ_add1_attr_by_OBJ, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2012), (void *)_cffi_d_X509_REQ_add1_attr_by_OBJ }, + { "X509_REQ_add_extensions", (void *)_cffi_f_X509_REQ_add_extensions, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2028), (void *)_cffi_d_X509_REQ_add_extensions }, + { "X509_REQ_free", (void *)_cffi_f_X509_REQ_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2910), (void *)_cffi_d_X509_REQ_free }, + { "X509_REQ_get0_signature", (void *)_cffi_f_X509_REQ_get0_signature, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2913), (void *)_cffi_d_X509_REQ_get0_signature }, + { "X509_REQ_get_attr", (void *)_cffi_f_X509_REQ_get_attr, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 550), (void *)_cffi_d_X509_REQ_get_attr }, + { "X509_REQ_get_attr_by_OBJ", (void *)_cffi_f_X509_REQ_get_attr_by_OBJ, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2044), (void *)_cffi_d_X509_REQ_get_attr_by_OBJ }, + { "X509_REQ_get_extensions", (void *)_cffi_f_X509_REQ_get_extensions, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 627), (void *)_cffi_d_X509_REQ_get_extensions }, + { "X509_REQ_get_pubkey", (void *)_cffi_f_X509_REQ_get_pubkey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 293), (void *)_cffi_d_X509_REQ_get_pubkey }, + { "X509_REQ_get_subject_name", (void *)_cffi_f_X509_REQ_get_subject_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 645), (void *)_cffi_d_X509_REQ_get_subject_name }, + { "X509_REQ_get_version", (void *)_cffi_f_X509_REQ_get_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2363), (void *)_cffi_d_X509_REQ_get_version }, + { "X509_REQ_new", (void *)_cffi_f_X509_REQ_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 679), (void *)_cffi_d_X509_REQ_new }, + { "X509_REQ_print_ex", (void *)_cffi_f_X509_REQ_print_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1004), (void *)_cffi_d_X509_REQ_print_ex }, + { "X509_REQ_set_pubkey", (void *)_cffi_f_X509_REQ_set_pubkey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2019), (void *)_cffi_d_X509_REQ_set_pubkey }, + { "X509_REQ_set_subject_name", (void *)_cffi_f_X509_REQ_set_subject_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2032), (void *)_cffi_d_X509_REQ_set_subject_name }, + { "X509_REQ_set_version", (void *)_cffi_f_X509_REQ_set_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2036), (void *)_cffi_d_X509_REQ_set_version }, + { "X509_REQ_sign", (void *)_cffi_f_X509_REQ_sign, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2023), (void *)_cffi_d_X509_REQ_sign }, + { "X509_REQ_verify", (void *)_cffi_f_X509_REQ_verify, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2019), (void *)_cffi_d_X509_REQ_verify }, + { "X509_REVOKED_add1_ext_i2d", (void *)_cffi_f_X509_REVOKED_add1_ext_i2d, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2065), (void *)_cffi_d_X509_REVOKED_add1_ext_i2d }, + { "X509_REVOKED_add_ext", (void *)_cffi_f_X509_REVOKED_add_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2060), (void *)_cffi_d_X509_REVOKED_add_ext }, + { "X509_REVOKED_delete_ext", (void *)_cffi_f_X509_REVOKED_delete_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 618), (void *)_cffi_d_X509_REVOKED_delete_ext }, + { "X509_REVOKED_dup", (void *)_cffi_f_X509_REVOKED_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 685), (void *)_cffi_d_X509_REVOKED_dup }, + { "X509_REVOKED_free", (void *)_cffi_f_X509_REVOKED_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2918), (void *)_cffi_d_X509_REVOKED_free }, + { "X509_REVOKED_get0_revocationDate", (void *)_cffi_f_X509_REVOKED_get0_revocationDate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 70), (void *)_cffi_d_X509_REVOKED_get0_revocationDate }, + { "X509_REVOKED_get0_serialNumber", (void *)_cffi_f_X509_REVOKED_get0_serialNumber, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 30), (void *)_cffi_d_X509_REVOKED_get0_serialNumber }, + { "X509_REVOKED_get_ext", (void *)_cffi_f_X509_REVOKED_get_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 618), (void *)_cffi_d_X509_REVOKED_get_ext }, + { "X509_REVOKED_get_ext_count", (void *)_cffi_f_X509_REVOKED_get_ext_count, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2049), (void *)_cffi_d_X509_REVOKED_get_ext_count }, + { "X509_REVOKED_new", (void *)_cffi_f_X509_REVOKED_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 688), (void *)_cffi_d_X509_REVOKED_new }, + { "X509_REVOKED_set_revocationDate", (void *)_cffi_f_X509_REVOKED_set_revocationDate, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2056), (void *)_cffi_d_X509_REVOKED_set_revocationDate }, + { "X509_REVOKED_set_serialNumber", (void *)_cffi_f_X509_REVOKED_set_serialNumber, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2052), (void *)_cffi_d_X509_REVOKED_set_serialNumber }, + { "X509_R_CERT_ALREADY_IN_HASH_TABLE", (void *)_cffi_const_X509_R_CERT_ALREADY_IN_HASH_TABLE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_STORE_CTX_cleanup", (void *)_cffi_f_X509_STORE_CTX_cleanup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2928), (void *)_cffi_d_X509_STORE_CTX_cleanup }, + { "X509_STORE_CTX_free", (void *)_cffi_f_X509_STORE_CTX_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2928), (void *)_cffi_d_X509_STORE_CTX_free }, + { "X509_STORE_CTX_get0_cert", (void *)_cffi_f_X509_STORE_CTX_get0_cert, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 539), (void *)_cffi_d_X509_STORE_CTX_get0_cert }, + { "X509_STORE_CTX_get0_param", (void *)_cffi_f_X509_STORE_CTX_get0_param, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 706), (void *)_cffi_d_X509_STORE_CTX_get0_param }, + { "X509_STORE_CTX_get1_chain", (void *)_cffi_f_X509_STORE_CTX_get1_chain, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 159), (void *)_cffi_d_X509_STORE_CTX_get1_chain }, + { "X509_STORE_CTX_get1_issuer", (void *)_cffi_f_X509_STORE_CTX_get1_issuer, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1838), (void *)_cffi_d_X509_STORE_CTX_get1_issuer }, + { "X509_STORE_CTX_get_chain", (void *)_cffi_f_X509_STORE_CTX_get_chain, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 159), (void *)_cffi_d_X509_STORE_CTX_get_chain }, + { "X509_STORE_CTX_get_current_cert", (void *)_cffi_f_X509_STORE_CTX_get_current_cert, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 539), (void *)_cffi_d_X509_STORE_CTX_get_current_cert }, + { "X509_STORE_CTX_get_error", (void *)_cffi_f_X509_STORE_CTX_get_error, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2096), (void *)_cffi_d_X509_STORE_CTX_get_error }, + { "X509_STORE_CTX_get_error_depth", (void *)_cffi_f_X509_STORE_CTX_get_error_depth, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2096), (void *)_cffi_d_X509_STORE_CTX_get_error_depth }, + { "X509_STORE_CTX_get_ex_data", (void *)_cffi_f_X509_STORE_CTX_get_ex_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2504), (void *)_cffi_d_X509_STORE_CTX_get_ex_data }, + { "X509_STORE_CTX_get_ex_new_index", (void *)_cffi_f_X509_STORE_CTX_get_ex_new_index, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2234), (void *)_cffi_d_X509_STORE_CTX_get_ex_new_index }, + { "X509_STORE_CTX_init", (void *)_cffi_f_X509_STORE_CTX_init, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2099), (void *)_cffi_d_X509_STORE_CTX_init }, + { "X509_STORE_CTX_new", (void *)_cffi_f_X509_STORE_CTX_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 695), (void *)_cffi_d_X509_STORE_CTX_new }, + { "X509_STORE_CTX_set0_crls", (void *)_cffi_f_X509_STORE_CTX_set0_crls, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2935), (void *)_cffi_d_X509_STORE_CTX_set0_crls }, + { "X509_STORE_CTX_set0_param", (void *)_cffi_f_X509_STORE_CTX_set0_param, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2943), (void *)_cffi_d_X509_STORE_CTX_set0_param }, + { "X509_STORE_CTX_set_cert", (void *)_cffi_f_X509_STORE_CTX_set_cert, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2939), (void *)_cffi_d_X509_STORE_CTX_set_cert }, + { "X509_STORE_CTX_set_chain", (void *)_cffi_f_X509_STORE_CTX_set_chain, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2931), (void *)_cffi_d_X509_STORE_CTX_set_chain }, + { "X509_STORE_CTX_set_default", (void *)_cffi_f_X509_STORE_CTX_set_default, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2105), (void *)_cffi_d_X509_STORE_CTX_set_default }, + { "X509_STORE_CTX_set_error", (void *)_cffi_f_X509_STORE_CTX_set_error, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2951), (void *)_cffi_d_X509_STORE_CTX_set_error }, + { "X509_STORE_CTX_set_ex_data", (void *)_cffi_f_X509_STORE_CTX_set_ex_data, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2109), (void *)_cffi_d_X509_STORE_CTX_set_ex_data }, + { "X509_STORE_CTX_set_verify_cb", (void *)_cffi_f_X509_STORE_CTX_set_verify_cb, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2947), (void *)_cffi_d_X509_STORE_CTX_set_verify_cb }, + { "X509_STORE_CTX_trusted_stack", (void *)_cffi_f_X509_STORE_CTX_trusted_stack, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2931), (void *)_cffi_d_X509_STORE_CTX_trusted_stack }, + { "X509_STORE_add_cert", (void *)_cffi_f_X509_STORE_add_cert, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2075), (void *)_cffi_d_X509_STORE_add_cert }, + { "X509_STORE_add_crl", (void *)_cffi_f_X509_STORE_add_crl, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2079), (void *)_cffi_d_X509_STORE_add_crl }, + { "X509_STORE_free", (void *)_cffi_f_X509_STORE_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2921), (void *)_cffi_d_X509_STORE_free }, + { "X509_STORE_get0_objects", (void *)_cffi_f_X509_STORE_get0_objects, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 179), (void *)_cffi_d_X509_STORE_get0_objects }, + { "X509_STORE_get0_param", (void *)_cffi_f_X509_STORE_get0_param, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 703), (void *)_cffi_d_X509_STORE_get0_param }, + { "X509_STORE_get_get_issuer", (void *)_cffi_f_X509_STORE_get_get_issuer, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2282), (void *)_cffi_d_X509_STORE_get_get_issuer }, + { "X509_STORE_load_locations", (void *)_cffi_f_X509_STORE_load_locations, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2087), (void *)_cffi_d_X509_STORE_load_locations }, + { "X509_STORE_new", (void *)_cffi_f_X509_STORE_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 693), (void *)_cffi_d_X509_STORE_new }, + { "X509_STORE_set1_param", (void *)_cffi_f_X509_STORE_set1_param, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2083), (void *)_cffi_d_X509_STORE_set1_param }, + { "X509_STORE_set_default_paths", (void *)_cffi_f_X509_STORE_set_default_paths, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2072), (void *)_cffi_d_X509_STORE_set_default_paths }, + { "X509_STORE_set_flags", (void *)_cffi_f_X509_STORE_set_flags, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2092), (void *)_cffi_d_X509_STORE_set_flags }, + { "X509_STORE_set_get_issuer", (void *)_cffi_f_X509_STORE_set_get_issuer, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2924), (void *)_cffi_d_X509_STORE_set_get_issuer }, + { "X509_VERIFY_PARAM_add0_policy", (void *)_cffi_f_X509_VERIFY_PARAM_add0_policy, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2118), (void *)_cffi_d_X509_VERIFY_PARAM_add0_policy }, + { "X509_VERIFY_PARAM_clear_flags", (void *)_cffi_f_X509_VERIFY_PARAM_clear_flags, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2144), (void *)_cffi_d_X509_VERIFY_PARAM_clear_flags }, + { "X509_VERIFY_PARAM_free", (void *)_cffi_f_X509_VERIFY_PARAM_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2955), (void *)_cffi_d_X509_VERIFY_PARAM_free }, + { "X509_VERIFY_PARAM_get_depth", (void *)_cffi_f_X509_VERIFY_PARAM_get_depth, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2148), (void *)_cffi_d_X509_VERIFY_PARAM_get_depth }, + { "X509_VERIFY_PARAM_get_flags", (void *)_cffi_f_X509_VERIFY_PARAM_get_flags, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2473), (void *)_cffi_d_X509_VERIFY_PARAM_get_flags }, + { "X509_VERIFY_PARAM_new", (void *)_cffi_f_X509_VERIFY_PARAM_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 709), (void *)_cffi_d_X509_VERIFY_PARAM_new }, + { "X509_VERIFY_PARAM_set1_email", (void *)_cffi_f_X509_VERIFY_PARAM_set1_email, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2130), (void *)_cffi_d_X509_VERIFY_PARAM_set1_email }, + { "X509_VERIFY_PARAM_set1_host", (void *)_cffi_f_X509_VERIFY_PARAM_set1_host, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2130), (void *)_cffi_d_X509_VERIFY_PARAM_set1_host }, + { "X509_VERIFY_PARAM_set1_ip", (void *)_cffi_f_X509_VERIFY_PARAM_set1_ip, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2139), (void *)_cffi_d_X509_VERIFY_PARAM_set1_ip }, + { "X509_VERIFY_PARAM_set1_ip_asc", (void *)_cffi_f_X509_VERIFY_PARAM_set1_ip_asc, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2126), (void *)_cffi_d_X509_VERIFY_PARAM_set1_ip_asc }, + { "X509_VERIFY_PARAM_set1_policies", (void *)_cffi_f_X509_VERIFY_PARAM_set1_policies, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2122), (void *)_cffi_d_X509_VERIFY_PARAM_set1_policies }, + { "X509_VERIFY_PARAM_set_depth", (void *)_cffi_f_X509_VERIFY_PARAM_set_depth, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2958), (void *)_cffi_d_X509_VERIFY_PARAM_set_depth }, + { "X509_VERIFY_PARAM_set_flags", (void *)_cffi_f_X509_VERIFY_PARAM_set_flags, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2144), (void *)_cffi_d_X509_VERIFY_PARAM_set_flags }, + { "X509_VERIFY_PARAM_set_hostflags", (void *)_cffi_f_X509_VERIFY_PARAM_set_hostflags, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2966), (void *)_cffi_d_X509_VERIFY_PARAM_set_hostflags }, + { "X509_VERIFY_PARAM_set_purpose", (void *)_cffi_f_X509_VERIFY_PARAM_set_purpose, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2135), (void *)_cffi_d_X509_VERIFY_PARAM_set_purpose }, + { "X509_VERIFY_PARAM_set_time", (void *)_cffi_f_X509_VERIFY_PARAM_set_time, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2962), (void *)_cffi_d_X509_VERIFY_PARAM_set_time }, + { "X509_VERIFY_PARAM_set_trust", (void *)_cffi_f_X509_VERIFY_PARAM_set_trust, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2135), (void *)_cffi_d_X509_VERIFY_PARAM_set_trust }, + { "X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH", (void *)_cffi_const_X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_AKID_SKID_MISMATCH", (void *)_cffi_const_X509_V_ERR_AKID_SKID_MISMATCH, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_APPLICATION_VERIFICATION", (void *)_cffi_const_X509_V_ERR_APPLICATION_VERIFICATION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_CERT_CHAIN_TOO_LONG", (void *)_cffi_const_X509_V_ERR_CERT_CHAIN_TOO_LONG, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_CERT_HAS_EXPIRED", (void *)_cffi_const_X509_V_ERR_CERT_HAS_EXPIRED, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_CERT_NOT_YET_VALID", (void *)_cffi_const_X509_V_ERR_CERT_NOT_YET_VALID, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_CERT_REJECTED", (void *)_cffi_const_X509_V_ERR_CERT_REJECTED, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_CERT_REVOKED", (void *)_cffi_const_X509_V_ERR_CERT_REVOKED, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_CERT_SIGNATURE_FAILURE", (void *)_cffi_const_X509_V_ERR_CERT_SIGNATURE_FAILURE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_CERT_UNTRUSTED", (void *)_cffi_const_X509_V_ERR_CERT_UNTRUSTED, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_CRL_HAS_EXPIRED", (void *)_cffi_const_X509_V_ERR_CRL_HAS_EXPIRED, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_CRL_NOT_YET_VALID", (void *)_cffi_const_X509_V_ERR_CRL_NOT_YET_VALID, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_CRL_PATH_VALIDATION_ERROR", (void *)_cffi_const_X509_V_ERR_CRL_PATH_VALIDATION_ERROR, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_CRL_SIGNATURE_FAILURE", (void *)_cffi_const_X509_V_ERR_CRL_SIGNATURE_FAILURE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT", (void *)_cffi_const_X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_DIFFERENT_CRL_SCOPE", (void *)_cffi_const_X509_V_ERR_DIFFERENT_CRL_SCOPE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_EMAIL_MISMATCH", (void *)_cffi_const_X509_V_ERR_EMAIL_MISMATCH, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD", (void *)_cffi_const_X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD", (void *)_cffi_const_X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD", (void *)_cffi_const_X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD", (void *)_cffi_const_X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_EXCLUDED_VIOLATION", (void *)_cffi_const_X509_V_ERR_EXCLUDED_VIOLATION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_HOSTNAME_MISMATCH", (void *)_cffi_const_X509_V_ERR_HOSTNAME_MISMATCH, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_INVALID_CA", (void *)_cffi_const_X509_V_ERR_INVALID_CA, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_INVALID_EXTENSION", (void *)_cffi_const_X509_V_ERR_INVALID_EXTENSION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_INVALID_NON_CA", (void *)_cffi_const_X509_V_ERR_INVALID_NON_CA, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_INVALID_POLICY_EXTENSION", (void *)_cffi_const_X509_V_ERR_INVALID_POLICY_EXTENSION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_INVALID_PURPOSE", (void *)_cffi_const_X509_V_ERR_INVALID_PURPOSE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_IP_ADDRESS_MISMATCH", (void *)_cffi_const_X509_V_ERR_IP_ADDRESS_MISMATCH, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_KEYUSAGE_NO_CERTSIGN", (void *)_cffi_const_X509_V_ERR_KEYUSAGE_NO_CERTSIGN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_KEYUSAGE_NO_CRL_SIGN", (void *)_cffi_const_X509_V_ERR_KEYUSAGE_NO_CRL_SIGN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE", (void *)_cffi_const_X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_NO_EXPLICIT_POLICY", (void *)_cffi_const_X509_V_ERR_NO_EXPLICIT_POLICY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_OUT_OF_MEM", (void *)_cffi_const_X509_V_ERR_OUT_OF_MEM, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_PATH_LENGTH_EXCEEDED", (void *)_cffi_const_X509_V_ERR_PATH_LENGTH_EXCEEDED, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_PERMITTED_VIOLATION", (void *)_cffi_const_X509_V_ERR_PERMITTED_VIOLATION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED", (void *)_cffi_const_X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED", (void *)_cffi_const_X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN", (void *)_cffi_const_X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_SUBJECT_ISSUER_MISMATCH", (void *)_cffi_const_X509_V_ERR_SUBJECT_ISSUER_MISMATCH, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_SUBTREE_MINMAX", (void *)_cffi_const_X509_V_ERR_SUBTREE_MINMAX, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256", (void *)_cffi_const_X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_SUITE_B_INVALID_ALGORITHM", (void *)_cffi_const_X509_V_ERR_SUITE_B_INVALID_ALGORITHM, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_SUITE_B_INVALID_CURVE", (void *)_cffi_const_X509_V_ERR_SUITE_B_INVALID_CURVE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM", (void *)_cffi_const_X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_SUITE_B_INVALID_VERSION", (void *)_cffi_const_X509_V_ERR_SUITE_B_INVALID_VERSION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED", (void *)_cffi_const_X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY", (void *)_cffi_const_X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE", (void *)_cffi_const_X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE", (void *)_cffi_const_X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNABLE_TO_GET_CRL", (void *)_cffi_const_X509_V_ERR_UNABLE_TO_GET_CRL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER", (void *)_cffi_const_X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT", (void *)_cffi_const_X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY", (void *)_cffi_const_X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE", (void *)_cffi_const_X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION", (void *)_cffi_const_X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION", (void *)_cffi_const_X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNNESTED_RESOURCE", (void *)_cffi_const_X509_V_ERR_UNNESTED_RESOURCE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX", (void *)_cffi_const_X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE", (void *)_cffi_const_X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE", (void *)_cffi_const_X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_ERR_UNSUPPORTED_NAME_SYNTAX", (void *)_cffi_const_X509_V_ERR_UNSUPPORTED_NAME_SYNTAX, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_ALLOW_PROXY_CERTS", (void *)_cffi_const_X509_V_FLAG_ALLOW_PROXY_CERTS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_CB_ISSUER_CHECK", (void *)_cffi_const_X509_V_FLAG_CB_ISSUER_CHECK, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_CHECK_SS_SIGNATURE", (void *)_cffi_const_X509_V_FLAG_CHECK_SS_SIGNATURE, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_CRL_CHECK", (void *)_cffi_const_X509_V_FLAG_CRL_CHECK, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_CRL_CHECK_ALL", (void *)_cffi_const_X509_V_FLAG_CRL_CHECK_ALL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_EXPLICIT_POLICY", (void *)_cffi_const_X509_V_FLAG_EXPLICIT_POLICY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_EXTENDED_CRL_SUPPORT", (void *)_cffi_const_X509_V_FLAG_EXTENDED_CRL_SUPPORT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_IGNORE_CRITICAL", (void *)_cffi_const_X509_V_FLAG_IGNORE_CRITICAL, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_INHIBIT_ANY", (void *)_cffi_const_X509_V_FLAG_INHIBIT_ANY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_INHIBIT_MAP", (void *)_cffi_const_X509_V_FLAG_INHIBIT_MAP, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_NOTIFY_POLICY", (void *)_cffi_const_X509_V_FLAG_NOTIFY_POLICY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_PARTIAL_CHAIN", (void *)_cffi_const_X509_V_FLAG_PARTIAL_CHAIN, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_POLICY_CHECK", (void *)_cffi_const_X509_V_FLAG_POLICY_CHECK, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_SUITEB_128_LOS", (void *)_cffi_const_X509_V_FLAG_SUITEB_128_LOS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_SUITEB_128_LOS_ONLY", (void *)_cffi_const_X509_V_FLAG_SUITEB_128_LOS_ONLY, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_SUITEB_192_LOS", (void *)_cffi_const_X509_V_FLAG_SUITEB_192_LOS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_TRUSTED_FIRST", (void *)_cffi_const_X509_V_FLAG_TRUSTED_FIRST, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_USE_CHECK_TIME", (void *)_cffi_const_X509_V_FLAG_USE_CHECK_TIME, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_USE_DELTAS", (void *)_cffi_const_X509_V_FLAG_USE_DELTAS, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_FLAG_X509_STRICT", (void *)_cffi_const_X509_V_FLAG_X509_STRICT, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_V_OK", (void *)_cffi_const_X509_V_OK, _CFFI_OP(_CFFI_OP_CONSTANT_INT, -1), (void *)0 }, + { "X509_add_ext", (void *)_cffi_f_X509_add_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1863), (void *)_cffi_d_X509_add_ext }, + { "X509_alias_get0", (void *)_cffi_f_X509_alias_get0, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2419), (void *)_cffi_d_X509_alias_get0 }, + { "X509_check_ca", (void *)_cffi_f_X509_check_ca, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1843), (void *)_cffi_d_X509_check_ca }, + { "X509_cmp", (void *)_cffi_f_X509_cmp, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1889), (void *)_cffi_d_X509_cmp }, + { "X509_digest", (void *)_cffi_f_X509_digest, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1883), (void *)_cffi_d_X509_digest }, + { "X509_dup", (void *)_cffi_f_X509_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 533), (void *)_cffi_d_X509_dup }, + { "X509_free", (void *)_cffi_f_X509_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2875), (void *)_cffi_d_X509_free }, + { "X509_get0_signature", (void *)_cffi_f_X509_get0_signature, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2551), (void *)_cffi_d_X509_get0_signature }, + { "X509_get0_tbs_sigalg", (void *)_cffi_f_X509_get0_tbs_sigalg, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 547), (void *)_cffi_d_X509_get0_tbs_sigalg }, + { "X509_get_default_cert_dir", (void *)_cffi_f_X509_get_default_cert_dir, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 744), (void *)_cffi_d_X509_get_default_cert_dir }, + { "X509_get_default_cert_dir_env", (void *)_cffi_f_X509_get_default_cert_dir_env, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 744), (void *)_cffi_d_X509_get_default_cert_dir_env }, + { "X509_get_default_cert_file", (void *)_cffi_f_X509_get_default_cert_file, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 744), (void *)_cffi_d_X509_get_default_cert_file }, + { "X509_get_default_cert_file_env", (void *)_cffi_f_X509_get_default_cert_file_env, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 744), (void *)_cffi_d_X509_get_default_cert_file_env }, + { "X509_get_ext", (void *)_cffi_f_X509_get_ext, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 597), (void *)_cffi_d_X509_get_ext }, + { "X509_get_ext_count", (void *)_cffi_f_X509_get_ext_count, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1843), (void *)_cffi_d_X509_get_ext_count }, + { "X509_get_ext_d2i", (void *)_cffi_f_X509_get_ext_d2i, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2486), (void *)_cffi_d_X509_get_ext_d2i }, + { "X509_get_issuer_name", (void *)_cffi_f_X509_get_issuer_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 636), (void *)_cffi_d_X509_get_issuer_name }, + { "X509_get_notAfter", (void *)_cffi_f_X509_get_notAfter, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 53), (void *)_cffi_d_X509_get_notAfter }, + { "X509_get_notBefore", (void *)_cffi_f_X509_get_notBefore, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 53), (void *)_cffi_d_X509_get_notBefore }, + { "X509_get_pubkey", (void *)_cffi_f_X509_get_pubkey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 290), (void *)_cffi_d_X509_get_pubkey }, + { "X509_get_serialNumber", (void *)_cffi_f_X509_get_serialNumber, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 27), (void *)_cffi_d_X509_get_serialNumber }, + { "X509_get_signature_nid", (void *)_cffi_f_X509_get_signature_nid, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1880), (void *)_cffi_d_X509_get_signature_nid }, + { "X509_get_subject_name", (void *)_cffi_f_X509_get_subject_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 636), (void *)_cffi_d_X509_get_subject_name }, + { "X509_get_version", (void *)_cffi_f_X509_get_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2357), (void *)_cffi_d_X509_get_version }, + { "X509_getm_notAfter", (void *)_cffi_f_X509_getm_notAfter, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 53), (void *)_cffi_d_X509_getm_notAfter }, + { "X509_getm_notBefore", (void *)_cffi_f_X509_getm_notBefore, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 53), (void *)_cffi_d_X509_getm_notBefore }, + { "X509_gmtime_adj", (void *)_cffi_f_X509_gmtime_adj, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 49), (void *)_cffi_d_X509_gmtime_adj }, + { "X509_new", (void *)_cffi_f_X509_new, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 542), (void *)_cffi_d_X509_new }, + { "X509_print_ex", (void *)_cffi_f_X509_print_ex, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 978), (void *)_cffi_d_X509_print_ex }, + { "X509_set1_notAfter", (void *)_cffi_f_X509_set1_notAfter, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1850), (void *)_cffi_d_X509_set1_notAfter }, + { "X509_set1_notBefore", (void *)_cffi_f_X509_set1_notBefore, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1850), (void *)_cffi_d_X509_set1_notBefore }, + { "X509_set_issuer_name", (void *)_cffi_f_X509_set_issuer_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1868), (void *)_cffi_d_X509_set_issuer_name }, + { "X509_set_notAfter", (void *)_cffi_f_X509_set_notAfter, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1850), (void *)_cffi_d_X509_set_notAfter }, + { "X509_set_notBefore", (void *)_cffi_f_X509_set_notBefore, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1850), (void *)_cffi_d_X509_set_notBefore }, + { "X509_set_pubkey", (void *)_cffi_f_X509_set_pubkey, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1854), (void *)_cffi_d_X509_set_pubkey }, + { "X509_set_serialNumber", (void *)_cffi_f_X509_set_serialNumber, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1846), (void *)_cffi_d_X509_set_serialNumber }, + { "X509_set_subject_name", (void *)_cffi_f_X509_set_subject_name, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1868), (void *)_cffi_d_X509_set_subject_name }, + { "X509_set_version", (void *)_cffi_f_X509_set_version, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1872), (void *)_cffi_d_X509_set_version }, + { "X509_sign", (void *)_cffi_f_X509_sign, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1858), (void *)_cffi_d_X509_sign }, + { "X509_subject_name_hash", (void *)_cffi_f_X509_subject_name_hash, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2467), (void *)_cffi_d_X509_subject_name_hash }, + { "X509_up_ref", (void *)_cffi_f_X509_up_ref, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1843), (void *)_cffi_d_X509_up_ref }, + { "X509_verify_cert", (void *)_cffi_f_X509_verify_cert, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2096), (void *)_cffi_d_X509_verify_cert }, + { "X509_verify_cert_error_string", (void *)_cffi_f_X509_verify_cert_error_string, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 738), (void *)_cffi_d_X509_verify_cert_error_string }, + { "d2i_ASN1_TYPE", (void *)_cffi_f_d2i_ASN1_TYPE, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 73), (void *)_cffi_d_d2i_ASN1_TYPE }, + { "d2i_DHparams_bio", (void *)_cffi_f_d2i_DHparams_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 185), (void *)_cffi_d_d2i_DHparams_bio }, + { "d2i_ECPrivateKey_bio", (void *)_cffi_f_d2i_ECPrivateKey_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 225), (void *)_cffi_d_d2i_ECPrivateKey_bio }, + { "d2i_EC_PUBKEY_bio", (void *)_cffi_f_d2i_EC_PUBKEY_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 225), (void *)_cffi_d_d2i_EC_PUBKEY_bio }, + { "d2i_GENERAL_NAMES", (void *)_cffi_f_d2i_GENERAL_NAMES, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 321), (void *)_cffi_d_d2i_GENERAL_NAMES }, + { "d2i_OCSP_REQUEST_bio", (void *)_cffi_f_d2i_OCSP_REQUEST_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 372), (void *)_cffi_d_d2i_OCSP_REQUEST_bio }, + { "d2i_OCSP_RESPONSE_bio", (void *)_cffi_f_d2i_OCSP_RESPONSE_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 381), (void *)_cffi_d_d2i_OCSP_RESPONSE_bio }, + { "d2i_PKCS12_bio", (void *)_cffi_f_d2i_PKCS12_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 404), (void *)_cffi_d_d2i_PKCS12_bio }, + { "d2i_PKCS7_bio", (void *)_cffi_f_d2i_PKCS7_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 424), (void *)_cffi_d_d2i_PKCS7_bio }, + { "d2i_PKCS8PrivateKey_bio", (void *)_cffi_f_d2i_PKCS8PrivateKey_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 275), (void *)_cffi_d_d2i_PKCS8PrivateKey_bio }, + { "d2i_PUBKEY_bio", (void *)_cffi_f_d2i_PUBKEY_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 271), (void *)_cffi_d_d2i_PUBKEY_bio }, + { "d2i_PrivateKey_bio", (void *)_cffi_f_d2i_PrivateKey_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 271), (void *)_cffi_d_d2i_PrivateKey_bio }, + { "d2i_RSAPublicKey_bio", (void *)_cffi_f_d2i_RSAPublicKey_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 462), (void *)_cffi_d_d2i_RSAPublicKey_bio }, + { "d2i_X509_CRL_bio", (void *)_cffi_f_d2i_X509_CRL_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 554), (void *)_cffi_d_d2i_X509_CRL_bio }, + { "d2i_X509_REQ_bio", (void *)_cffi_f_d2i_X509_REQ_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 669), (void *)_cffi_d_d2i_X509_REQ_bio }, + { "d2i_X509_bio", (void *)_cffi_f_d2i_X509_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 516), (void *)_cffi_d_d2i_X509_bio }, + { "i2a_ASN1_INTEGER", (void *)_cffi_f_i2a_ASN1_INTEGER, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 870), (void *)_cffi_d_i2a_ASN1_INTEGER }, + { "i2d_ASN1_TYPE", (void *)_cffi_f_i2d_ASN1_TYPE, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 800), (void *)_cffi_d_i2d_ASN1_TYPE }, + { "i2d_DHparams_bio", (void *)_cffi_f_i2d_DHparams_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 874), (void *)_cffi_d_i2d_DHparams_bio }, + { "i2d_DSAPrivateKey_bio", (void *)_cffi_f_i2d_DSAPrivateKey_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 878), (void *)_cffi_d_i2d_DSAPrivateKey_bio }, + { "i2d_ECPrivateKey_bio", (void *)_cffi_f_i2d_ECPrivateKey_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 891), (void *)_cffi_d_i2d_ECPrivateKey_bio }, + { "i2d_EC_PUBKEY_bio", (void *)_cffi_f_i2d_EC_PUBKEY_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 891), (void *)_cffi_d_i2d_EC_PUBKEY_bio }, + { "i2d_GENERAL_NAMES", (void *)_cffi_f_i2d_GENERAL_NAMES, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1510), (void *)_cffi_d_i2d_GENERAL_NAMES }, + { "i2d_OCSP_REQUEST_bio", (void *)_cffi_f_i2d_OCSP_REQUEST_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 930), (void *)_cffi_d_i2d_OCSP_REQUEST_bio }, + { "i2d_OCSP_RESPDATA", (void *)_cffi_f_i2d_OCSP_RESPDATA, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1577), (void *)_cffi_d_i2d_OCSP_RESPDATA }, + { "i2d_OCSP_RESPONSE_bio", (void *)_cffi_f_i2d_OCSP_RESPONSE_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 934), (void *)_cffi_d_i2d_OCSP_RESPONSE_bio }, + { "i2d_PKCS12_bio", (void *)_cffi_f_i2d_PKCS12_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 938), (void *)_cffi_d_i2d_PKCS12_bio }, + { "i2d_PKCS7_bio", (void *)_cffi_f_i2d_PKCS7_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 942), (void *)_cffi_d_i2d_PKCS7_bio }, + { "i2d_PKCS8PrivateKey_bio", (void *)_cffi_f_i2d_PKCS8PrivateKey_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 908), (void *)_cffi_d_i2d_PKCS8PrivateKey_bio }, + { "i2d_PUBKEY_bio", (void *)_cffi_f_i2d_PUBKEY_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 904), (void *)_cffi_d_i2d_PUBKEY_bio }, + { "i2d_PrivateKey_bio", (void *)_cffi_f_i2d_PrivateKey_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 904), (void *)_cffi_d_i2d_PrivateKey_bio }, + { "i2d_RSAPrivateKey_bio", (void *)_cffi_f_i2d_RSAPrivateKey_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 952), (void *)_cffi_d_i2d_RSAPrivateKey_bio }, + { "i2d_RSAPublicKey_bio", (void *)_cffi_f_i2d_RSAPublicKey_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 952), (void *)_cffi_d_i2d_RSAPublicKey_bio }, + { "i2d_X509_CRL_bio", (void *)_cffi_f_i2d_X509_CRL_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 984), (void *)_cffi_d_i2d_X509_CRL_bio }, + { "i2d_X509_NAME", (void *)_cffi_f_i2d_X509_NAME, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1998), (void *)_cffi_d_i2d_X509_NAME }, + { "i2d_X509_REQ_bio", (void *)_cffi_f_i2d_X509_REQ_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1000), (void *)_cffi_d_i2d_X509_REQ_bio }, + { "i2d_X509_bio", (void *)_cffi_f_i2d_X509_bio, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 974), (void *)_cffi_d_i2d_X509_bio }, + { "i2d_re_X509_CRL_tbs", (void *)_cffi_f_i2d_re_X509_CRL_tbs, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1934), (void *)_cffi_d_i2d_re_X509_CRL_tbs }, + { "i2d_re_X509_REQ_tbs", (void *)_cffi_f_i2d_re_X509_REQ_tbs, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2040), (void *)_cffi_d_i2d_re_X509_REQ_tbs }, + { "i2d_re_X509_tbs", (void *)_cffi_f_i2d_re_X509_tbs, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1876), (void *)_cffi_d_i2d_re_X509_tbs }, + { "sk_ACCESS_DESCRIPTION_free", (void *)_cffi_f_sk_ACCESS_DESCRIPTION_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2581), (void *)_cffi_d_sk_ACCESS_DESCRIPTION_free }, + { "sk_ACCESS_DESCRIPTION_new_null", (void *)_cffi_f_sk_ACCESS_DESCRIPTION_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 137), (void *)_cffi_d_sk_ACCESS_DESCRIPTION_new_null }, + { "sk_ACCESS_DESCRIPTION_num", (void *)_cffi_f_sk_ACCESS_DESCRIPTION_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1051), (void *)_cffi_d_sk_ACCESS_DESCRIPTION_num }, + { "sk_ACCESS_DESCRIPTION_pop_free", (void *)_cffi_f_sk_ACCESS_DESCRIPTION_pop_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2584), (void *)_cffi_d_sk_ACCESS_DESCRIPTION_pop_free }, + { "sk_ACCESS_DESCRIPTION_push", (void *)_cffi_f_sk_ACCESS_DESCRIPTION_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1054), (void *)_cffi_d_sk_ACCESS_DESCRIPTION_push }, + { "sk_ACCESS_DESCRIPTION_value", (void *)_cffi_f_sk_ACCESS_DESCRIPTION_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 0), (void *)_cffi_d_sk_ACCESS_DESCRIPTION_value }, + { "sk_ASN1_INTEGER_free", (void *)_cffi_f_sk_ASN1_INTEGER_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2588), (void *)_cffi_d_sk_ASN1_INTEGER_free }, + { "sk_ASN1_INTEGER_new_null", (void *)_cffi_f_sk_ASN1_INTEGER_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 139), (void *)_cffi_d_sk_ASN1_INTEGER_new_null }, + { "sk_ASN1_INTEGER_num", (void *)_cffi_f_sk_ASN1_INTEGER_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1058), (void *)_cffi_d_sk_ASN1_INTEGER_num }, + { "sk_ASN1_INTEGER_push", (void *)_cffi_f_sk_ASN1_INTEGER_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1061), (void *)_cffi_d_sk_ASN1_INTEGER_push }, + { "sk_ASN1_INTEGER_value", (void *)_cffi_f_sk_ASN1_INTEGER_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 23), (void *)_cffi_d_sk_ASN1_INTEGER_value }, + { "sk_ASN1_OBJECT_free", (void *)_cffi_f_sk_ASN1_OBJECT_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2591), (void *)_cffi_d_sk_ASN1_OBJECT_free }, + { "sk_ASN1_OBJECT_new_null", (void *)_cffi_f_sk_ASN1_OBJECT_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 141), (void *)_cffi_d_sk_ASN1_OBJECT_new_null }, + { "sk_ASN1_OBJECT_num", (void *)_cffi_f_sk_ASN1_OBJECT_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1065), (void *)_cffi_d_sk_ASN1_OBJECT_num }, + { "sk_ASN1_OBJECT_push", (void *)_cffi_f_sk_ASN1_OBJECT_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1068), (void *)_cffi_d_sk_ASN1_OBJECT_push }, + { "sk_ASN1_OBJECT_value", (void *)_cffi_f_sk_ASN1_OBJECT_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 35), (void *)_cffi_d_sk_ASN1_OBJECT_value }, + { "sk_DIST_POINT_free", (void *)_cffi_f_sk_DIST_POINT_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2594), (void *)_cffi_d_sk_DIST_POINT_free }, + { "sk_DIST_POINT_new_null", (void *)_cffi_f_sk_DIST_POINT_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 143), (void *)_cffi_d_sk_DIST_POINT_new_null }, + { "sk_DIST_POINT_num", (void *)_cffi_f_sk_DIST_POINT_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1072), (void *)_cffi_d_sk_DIST_POINT_num }, + { "sk_DIST_POINT_pop_free", (void *)_cffi_f_sk_DIST_POINT_pop_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2597), (void *)_cffi_d_sk_DIST_POINT_pop_free }, + { "sk_DIST_POINT_push", (void *)_cffi_f_sk_DIST_POINT_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1075), (void *)_cffi_d_sk_DIST_POINT_push }, + { "sk_DIST_POINT_value", (void *)_cffi_f_sk_DIST_POINT_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 203), (void *)_cffi_d_sk_DIST_POINT_value }, + { "sk_GENERAL_NAME_num", (void *)_cffi_f_sk_GENERAL_NAME_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1503), (void *)_cffi_d_sk_GENERAL_NAME_num }, + { "sk_GENERAL_NAME_pop_free", (void *)_cffi_f_sk_GENERAL_NAME_pop_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2694), (void *)_cffi_d_sk_GENERAL_NAME_pop_free }, + { "sk_GENERAL_NAME_push", (void *)_cffi_f_sk_GENERAL_NAME_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1506), (void *)_cffi_d_sk_GENERAL_NAME_push }, + { "sk_GENERAL_NAME_value", (void *)_cffi_f_sk_GENERAL_NAME_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 315), (void *)_cffi_d_sk_GENERAL_NAME_value }, + { "sk_GENERAL_SUBTREE_free", (void *)_cffi_f_sk_GENERAL_SUBTREE_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2601), (void *)_cffi_d_sk_GENERAL_SUBTREE_free }, + { "sk_GENERAL_SUBTREE_new_null", (void *)_cffi_f_sk_GENERAL_SUBTREE_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 145), (void *)_cffi_d_sk_GENERAL_SUBTREE_new_null }, + { "sk_GENERAL_SUBTREE_num", (void *)_cffi_f_sk_GENERAL_SUBTREE_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1079), (void *)_cffi_d_sk_GENERAL_SUBTREE_num }, + { "sk_GENERAL_SUBTREE_push", (void *)_cffi_f_sk_GENERAL_SUBTREE_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1082), (void *)_cffi_d_sk_GENERAL_SUBTREE_push }, + { "sk_GENERAL_SUBTREE_value", (void *)_cffi_f_sk_GENERAL_SUBTREE_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 328), (void *)_cffi_d_sk_GENERAL_SUBTREE_value }, + { "sk_POLICYINFO_free", (void *)_cffi_f_sk_POLICYINFO_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2604), (void *)_cffi_d_sk_POLICYINFO_free }, + { "sk_POLICYINFO_new_null", (void *)_cffi_f_sk_POLICYINFO_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 147), (void *)_cffi_d_sk_POLICYINFO_new_null }, + { "sk_POLICYINFO_num", (void *)_cffi_f_sk_POLICYINFO_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1086), (void *)_cffi_d_sk_POLICYINFO_num }, + { "sk_POLICYINFO_pop_free", (void *)_cffi_f_sk_POLICYINFO_pop_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2607), (void *)_cffi_d_sk_POLICYINFO_pop_free }, + { "sk_POLICYINFO_push", (void *)_cffi_f_sk_POLICYINFO_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1089), (void *)_cffi_d_sk_POLICYINFO_push }, + { "sk_POLICYINFO_value", (void *)_cffi_f_sk_POLICYINFO_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 448), (void *)_cffi_d_sk_POLICYINFO_value }, + { "sk_POLICYQUALINFO_free", (void *)_cffi_f_sk_POLICYQUALINFO_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2611), (void *)_cffi_d_sk_POLICYQUALINFO_free }, + { "sk_POLICYQUALINFO_new_null", (void *)_cffi_f_sk_POLICYQUALINFO_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 149), (void *)_cffi_d_sk_POLICYQUALINFO_new_null }, + { "sk_POLICYQUALINFO_num", (void *)_cffi_f_sk_POLICYQUALINFO_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1093), (void *)_cffi_d_sk_POLICYQUALINFO_num }, + { "sk_POLICYQUALINFO_push", (void *)_cffi_f_sk_POLICYQUALINFO_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1096), (void *)_cffi_d_sk_POLICYQUALINFO_push }, + { "sk_POLICYQUALINFO_value", (void *)_cffi_f_sk_POLICYQUALINFO_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 454), (void *)_cffi_d_sk_POLICYQUALINFO_value }, + { "sk_SCT_free", (void *)_cffi_f_sk_SCT_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2614), (void *)_cffi_d_sk_SCT_free }, + { "sk_SCT_new_null", (void *)_cffi_f_sk_SCT_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 151), (void *)_cffi_d_sk_SCT_new_null }, + { "sk_SCT_num", (void *)_cffi_f_sk_SCT_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1104), (void *)_cffi_d_sk_SCT_num }, + { "sk_SCT_push", (void *)_cffi_f_sk_SCT_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1100), (void *)_cffi_d_sk_SCT_push }, + { "sk_SCT_value", (void *)_cffi_f_sk_SCT_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 480), (void *)_cffi_d_sk_SCT_value }, + { "sk_SSL_CIPHER_num", (void *)_cffi_f_sk_SSL_CIPHER_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1107), (void *)_cffi_d_sk_SSL_CIPHER_num }, + { "sk_SSL_CIPHER_value", (void *)_cffi_f_sk_SSL_CIPHER_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 492), (void *)_cffi_d_sk_SSL_CIPHER_value }, + { "sk_X509_CRL_free", (void *)_cffi_f_sk_X509_CRL_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2620), (void *)_cffi_d_sk_X509_CRL_free }, + { "sk_X509_CRL_new_null", (void *)_cffi_f_sk_X509_CRL_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 164), (void *)_cffi_d_sk_X509_CRL_new_null }, + { "sk_X509_CRL_num", (void *)_cffi_f_sk_X509_CRL_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1117), (void *)_cffi_d_sk_X509_CRL_num }, + { "sk_X509_CRL_push", (void *)_cffi_f_sk_X509_CRL_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1120), (void *)_cffi_d_sk_X509_CRL_push }, + { "sk_X509_CRL_value", (void *)_cffi_f_sk_X509_CRL_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 564), (void *)_cffi_d_sk_X509_CRL_value }, + { "sk_X509_EXTENSION_delete", (void *)_cffi_f_sk_X509_EXTENSION_delete, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 614), (void *)_cffi_d_sk_X509_EXTENSION_delete }, + { "sk_X509_EXTENSION_free", (void *)_cffi_f_sk_X509_EXTENSION_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2897), (void *)_cffi_d_sk_X509_EXTENSION_free }, + { "sk_X509_EXTENSION_insert", (void *)_cffi_f_sk_X509_EXTENSION_insert, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1952), (void *)_cffi_d_sk_X509_EXTENSION_insert }, + { "sk_X509_EXTENSION_new_null", (void *)_cffi_f_sk_X509_EXTENSION_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 630), (void *)_cffi_d_sk_X509_EXTENSION_new_null }, + { "sk_X509_EXTENSION_num", (void *)_cffi_f_sk_X509_EXTENSION_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1945), (void *)_cffi_d_sk_X509_EXTENSION_num }, + { "sk_X509_EXTENSION_pop_free", (void *)_cffi_f_sk_X509_EXTENSION_pop_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 2900), (void *)_cffi_d_sk_X509_EXTENSION_pop_free }, + { "sk_X509_EXTENSION_push", (void *)_cffi_f_sk_X509_EXTENSION_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1948), (void *)_cffi_d_sk_X509_EXTENSION_push }, + { "sk_X509_EXTENSION_value", (void *)_cffi_f_sk_X509_EXTENSION_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 614), (void *)_cffi_d_sk_X509_EXTENSION_value }, + { "sk_X509_NAME_ENTRY_dup", (void *)_cffi_f_sk_X509_NAME_ENTRY_dup, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 174), (void *)_cffi_d_sk_X509_NAME_ENTRY_dup }, + { "sk_X509_NAME_ENTRY_new_null", (void *)_cffi_f_sk_X509_NAME_ENTRY_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 177), (void *)_cffi_d_sk_X509_NAME_ENTRY_new_null }, + { "sk_X509_NAME_ENTRY_num", (void *)_cffi_f_sk_X509_NAME_ENTRY_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1131), (void *)_cffi_d_sk_X509_NAME_ENTRY_num }, + { "sk_X509_NAME_ENTRY_push", (void *)_cffi_f_sk_X509_NAME_ENTRY_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1134), (void *)_cffi_d_sk_X509_NAME_ENTRY_push }, + { "sk_X509_NAME_ENTRY_value", (void *)_cffi_f_sk_X509_NAME_ENTRY_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 650), (void *)_cffi_d_sk_X509_NAME_ENTRY_value }, + { "sk_X509_NAME_free", (void *)_cffi_f_sk_X509_NAME_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2623), (void *)_cffi_d_sk_X509_NAME_free }, + { "sk_X509_NAME_new_null", (void *)_cffi_f_sk_X509_NAME_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 172), (void *)_cffi_d_sk_X509_NAME_new_null }, + { "sk_X509_NAME_num", (void *)_cffi_f_sk_X509_NAME_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1124), (void *)_cffi_d_sk_X509_NAME_num }, + { "sk_X509_NAME_push", (void *)_cffi_f_sk_X509_NAME_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1127), (void *)_cffi_d_sk_X509_NAME_push }, + { "sk_X509_NAME_value", (void *)_cffi_f_sk_X509_NAME_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 632), (void *)_cffi_d_sk_X509_NAME_value }, + { "sk_X509_OBJECT_num", (void *)_cffi_f_sk_X509_OBJECT_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1138), (void *)_cffi_d_sk_X509_OBJECT_num }, + { "sk_X509_OBJECT_value", (void *)_cffi_f_sk_X509_OBJECT_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 665), (void *)_cffi_d_sk_X509_OBJECT_value }, + { "sk_X509_REVOKED_num", (void *)_cffi_f_sk_X509_REVOKED_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1141), (void *)_cffi_d_sk_X509_REVOKED_num }, + { "sk_X509_REVOKED_value", (void *)_cffi_f_sk_X509_REVOKED_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 681), (void *)_cffi_d_sk_X509_REVOKED_value }, + { "sk_X509_free", (void *)_cffi_f_sk_X509_free, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 2617), (void *)_cffi_d_sk_X509_free }, + { "sk_X509_new_null", (void *)_cffi_f_sk_X509_new_null, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_N, 162), (void *)_cffi_d_sk_X509_new_null }, + { "sk_X509_num", (void *)_cffi_f_sk_X509_num, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_O, 1110), (void *)_cffi_d_sk_X509_num }, + { "sk_X509_push", (void *)_cffi_f_sk_X509_push, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 1113), (void *)_cffi_d_sk_X509_push }, + { "sk_X509_value", (void *)_cffi_f_sk_X509_value, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 526), (void *)_cffi_d_sk_X509_value }, +}; + +static const struct _cffi_field_s _cffi_fields[] = { + { "method", offsetof(ACCESS_DESCRIPTION, method), + sizeof(((ACCESS_DESCRIPTION *)0)->method), + _CFFI_OP(_CFFI_OP_NOOP, 607) }, + { "location", offsetof(ACCESS_DESCRIPTION, location), + sizeof(((ACCESS_DESCRIPTION *)0)->location), + _CFFI_OP(_CFFI_OP_NOOP, 928) }, + { "type", offsetof(ASN1_TYPE, type), + sizeof(((ASN1_TYPE *)0)->type), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "keyid", offsetof(AUTHORITY_KEYID, keyid), + sizeof(((AUTHORITY_KEYID *)0)->keyid), + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "issuer", offsetof(AUTHORITY_KEYID, issuer), + sizeof(((AUTHORITY_KEYID *)0)->issuer), + _CFFI_OP(_CFFI_OP_NOOP, 316) }, + { "serial", offsetof(AUTHORITY_KEYID, serial), + sizeof(((AUTHORITY_KEYID *)0)->serial), + _CFFI_OP(_CFFI_OP_NOOP, 21) }, + { "ca", offsetof(BASIC_CONSTRAINTS, ca), + sizeof(((BASIC_CONSTRAINTS *)0)->ca), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "pathlen", offsetof(BASIC_CONSTRAINTS, pathlen), + sizeof(((BASIC_CONSTRAINTS *)0)->pathlen), + _CFFI_OP(_CFFI_OP_NOOP, 21) }, + { "password", offsetof(CRYPTOGRAPHY_PASSWORD_DATA, password), + sizeof(((CRYPTOGRAPHY_PASSWORD_DATA *)0)->password), + _CFFI_OP(_CFFI_OP_NOOP, 409) }, + { "length", offsetof(CRYPTOGRAPHY_PASSWORD_DATA, length), + sizeof(((CRYPTOGRAPHY_PASSWORD_DATA *)0)->length), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "called", offsetof(CRYPTOGRAPHY_PASSWORD_DATA, called), + sizeof(((CRYPTOGRAPHY_PASSWORD_DATA *)0)->called), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "error", offsetof(CRYPTOGRAPHY_PASSWORD_DATA, error), + sizeof(((CRYPTOGRAPHY_PASSWORD_DATA *)0)->error), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "maxsize", offsetof(CRYPTOGRAPHY_PASSWORD_DATA, maxsize), + sizeof(((CRYPTOGRAPHY_PASSWORD_DATA *)0)->maxsize), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "distpoint", offsetof(DIST_POINT, distpoint), + sizeof(((DIST_POINT *)0)->distpoint), + _CFFI_OP(_CFFI_OP_NOOP, 2644) }, + { "reasons", offsetof(DIST_POINT, reasons), + sizeof(((DIST_POINT *)0)->reasons), + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "CRLissuer", offsetof(DIST_POINT, CRLissuer), + sizeof(((DIST_POINT *)0)->CRLissuer), + _CFFI_OP(_CFFI_OP_NOOP, 316) }, + { "type", offsetof(DIST_POINT_NAME, type), + sizeof(((DIST_POINT_NAME *)0)->type), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "name", offsetof(DIST_POINT_NAME, name), + sizeof(((DIST_POINT_NAME *)0)->name), + _CFFI_OP(_CFFI_OP_NOOP, 3137) }, + { "nid", offsetof(EC_builtin_curve, nid), + sizeof(((EC_builtin_curve *)0)->nid), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "comment", offsetof(EC_builtin_curve, comment), + sizeof(((EC_builtin_curve *)0)->comment), + _CFFI_OP(_CFFI_OP_NOOP, 46) }, + { "type", offsetof(GENERAL_NAME, type), + sizeof(((GENERAL_NAME *)0)->type), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "d", offsetof(GENERAL_NAME, d), + sizeof(((GENERAL_NAME *)0)->d), + _CFFI_OP(_CFFI_OP_NOOP, 3136) }, + { "base", offsetof(GENERAL_SUBTREE, base), + sizeof(((GENERAL_SUBTREE *)0)->base), + _CFFI_OP(_CFFI_OP_NOOP, 928) }, + { "minimum", offsetof(GENERAL_SUBTREE, minimum), + sizeof(((GENERAL_SUBTREE *)0)->minimum), + _CFFI_OP(_CFFI_OP_NOOP, 21) }, + { "maximum", offsetof(GENERAL_SUBTREE, maximum), + sizeof(((GENERAL_SUBTREE *)0)->maximum), + _CFFI_OP(_CFFI_OP_NOOP, 21) }, + { "distpoint", offsetof(ISSUING_DIST_POINT, distpoint), + sizeof(((ISSUING_DIST_POINT *)0)->distpoint), + _CFFI_OP(_CFFI_OP_NOOP, 2644) }, + { "onlyuser", offsetof(ISSUING_DIST_POINT, onlyuser), + sizeof(((ISSUING_DIST_POINT *)0)->onlyuser), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "onlyCA", offsetof(ISSUING_DIST_POINT, onlyCA), + sizeof(((ISSUING_DIST_POINT *)0)->onlyCA), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "onlysomereasons", offsetof(ISSUING_DIST_POINT, onlysomereasons), + sizeof(((ISSUING_DIST_POINT *)0)->onlysomereasons), + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "indirectCRL", offsetof(ISSUING_DIST_POINT, indirectCRL), + sizeof(((ISSUING_DIST_POINT *)0)->indirectCRL), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "onlyattr", offsetof(ISSUING_DIST_POINT, onlyattr), + sizeof(((ISSUING_DIST_POINT *)0)->onlyattr), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "permittedSubtrees", offsetof(NAME_CONSTRAINTS, permittedSubtrees), + sizeof(((NAME_CONSTRAINTS *)0)->permittedSubtrees), + _CFFI_OP(_CFFI_OP_NOOP, 329) }, + { "excludedSubtrees", offsetof(NAME_CONSTRAINTS, excludedSubtrees), + sizeof(((NAME_CONSTRAINTS *)0)->excludedSubtrees), + _CFFI_OP(_CFFI_OP_NOOP, 329) }, + { "organization", offsetof(NOTICEREF, organization), + sizeof(((NOTICEREF *)0)->organization), + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "noticenos", offsetof(NOTICEREF, noticenos), + sizeof(((NOTICEREF *)0)->noticenos), + _CFFI_OP(_CFFI_OP_NOOP, 24) }, + { "type", offsetof(OBJ_NAME, type), + sizeof(((OBJ_NAME *)0)->type), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "alias", offsetof(OBJ_NAME, alias), + sizeof(((OBJ_NAME *)0)->alias), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "name", offsetof(OBJ_NAME, name), + sizeof(((OBJ_NAME *)0)->name), + _CFFI_OP(_CFFI_OP_NOOP, 46) }, + { "data", offsetof(OBJ_NAME, data), + sizeof(((OBJ_NAME *)0)->data), + _CFFI_OP(_CFFI_OP_NOOP, 46) }, + { "type_id", offsetof(OTHERNAME, type_id), + sizeof(((OTHERNAME *)0)->type_id), + _CFFI_OP(_CFFI_OP_NOOP, 607) }, + { "value", offsetof(OTHERNAME, value), + sizeof(((OTHERNAME *)0)->value), + _CFFI_OP(_CFFI_OP_NOOP, 801) }, + { "type", offsetof(PKCS7, type), + sizeof(((PKCS7 *)0)->type), + _CFFI_OP(_CFFI_OP_NOOP, 607) }, + { "d", offsetof(PKCS7, d), + sizeof(((PKCS7 *)0)->d), + _CFFI_OP(_CFFI_OP_NOOP, 3139) }, + { "cert", offsetof(PKCS7_SIGNED, cert), + sizeof(((PKCS7_SIGNED *)0)->cert), + _CFFI_OP(_CFFI_OP_NOOP, 413) }, + { "crl", offsetof(PKCS7_SIGNED, crl), + sizeof(((PKCS7_SIGNED *)0)->crl), + _CFFI_OP(_CFFI_OP_NOOP, 565) }, + { "cert", offsetof(PKCS7_SIGN_ENVELOPE, cert), + sizeof(((PKCS7_SIGN_ENVELOPE *)0)->cert), + _CFFI_OP(_CFFI_OP_NOOP, 413) }, + { "crl", offsetof(PKCS7_SIGN_ENVELOPE, crl), + sizeof(((PKCS7_SIGN_ENVELOPE *)0)->crl), + _CFFI_OP(_CFFI_OP_NOOP, 565) }, + { "policyid", offsetof(POLICYINFO, policyid), + sizeof(((POLICYINFO *)0)->policyid), + _CFFI_OP(_CFFI_OP_NOOP, 607) }, + { "qualifiers", offsetof(POLICYINFO, qualifiers), + sizeof(((POLICYINFO *)0)->qualifiers), + _CFFI_OP(_CFFI_OP_NOOP, 455) }, + { "pqualid", offsetof(POLICYQUALINFO, pqualid), + sizeof(((POLICYQUALINFO *)0)->pqualid), + _CFFI_OP(_CFFI_OP_NOOP, 607) }, + { "d", offsetof(POLICYQUALINFO, d), + sizeof(((POLICYQUALINFO *)0)->d), + _CFFI_OP(_CFFI_OP_NOOP, 3138) }, + { "requireExplicitPolicy", offsetof(POLICY_CONSTRAINTS, requireExplicitPolicy), + sizeof(((POLICY_CONSTRAINTS *)0)->requireExplicitPolicy), + _CFFI_OP(_CFFI_OP_NOOP, 21) }, + { "inhibitPolicyMapping", offsetof(POLICY_CONSTRAINTS, inhibitPolicyMapping), + sizeof(((POLICY_CONSTRAINTS *)0)->inhibitPolicyMapping), + _CFFI_OP(_CFFI_OP_NOOP, 21) }, + { "name", offsetof(SRTP_PROTECTION_PROFILE, name), + sizeof(((SRTP_PROTECTION_PROFILE *)0)->name), + _CFFI_OP(_CFFI_OP_NOOP, 46) }, + { "id", offsetof(SRTP_PROTECTION_PROFILE, id), + sizeof(((SRTP_PROTECTION_PROFILE *)0)->id), + _CFFI_OP(_CFFI_OP_NOOP, 742) }, + { "noticeref", offsetof(USERNOTICE, noticeref), + sizeof(((USERNOTICE *)0)->noticeref), + _CFFI_OP(_CFFI_OP_NOOP, 2711) }, + { "exptext", offsetof(USERNOTICE, exptext), + sizeof(((USERNOTICE *)0)->exptext), + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "issuer_cert", offsetof(X509V3_CTX, issuer_cert), + sizeof(((X509V3_CTX *)0)->issuer_cert), + _CFFI_OP(_CFFI_OP_NOOP, 28) }, + { "subject_cert", offsetof(X509V3_CTX, subject_cert), + sizeof(((X509V3_CTX *)0)->subject_cert), + _CFFI_OP(_CFFI_OP_NOOP, 28) }, + { "algorithm", offsetof(X509_ALGOR, algorithm), + sizeof(((X509_ALGOR *)0)->algorithm), + _CFFI_OP(_CFFI_OP_NOOP, 607) }, + { "length", offsetof(ASN1_OCTET_STRING, length), + sizeof(((ASN1_OCTET_STRING *)0)->length), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "type", offsetof(ASN1_OCTET_STRING, type), + sizeof(((ASN1_OCTET_STRING *)0)->type), + _CFFI_OP(_CFFI_OP_NOOP, 2) }, + { "data", offsetof(ASN1_OCTET_STRING, data), + sizeof(((ASN1_OCTET_STRING *)0)->data), + _CFFI_OP(_CFFI_OP_NOOP, 752) }, + { "flags", offsetof(ASN1_OCTET_STRING, flags), + sizeof(((ASN1_OCTET_STRING *)0)->flags), + _CFFI_OP(_CFFI_OP_NOOP, 51) }, + { "ptr", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 409) }, + { "otherName", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 2726) }, + { "rfc822Name", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "dNSName", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "x400Address", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 801) }, + { "directoryName", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 643) }, + { "ediPartyName", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 3059) }, + { "uniformResourceIdentifier", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "iPAddress", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "registeredID", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 607) }, + { "ip", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "dirn", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 643) }, + { "ia5", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "rid", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 607) }, + { "other", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 801) }, + { "fullname", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 316) }, + { "relativename", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 175) }, + { "cpsuri", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "usernotice", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 2873) }, + { "other", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 801) }, + { "ptr", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 409) }, + { "data", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 13) }, + { "sign", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 3096) }, + { "enveloped", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 3094) }, + { "signed_and_enveloped", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 3100) }, + { "digest", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 3090) }, + { "encrypted", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 3092) }, + { "other", (size_t)-1, + (size_t)-1, + _CFFI_OP(_CFFI_OP_NOOP, 801) }, +}; + +static const struct _cffi_struct_union_s _cffi_struct_unions[] = { + { "$1", 3136, _CFFI_F_UNION|_CFFI_F_CHECK_FIELDS, + (size_t)-2, -2, 64, 15 /* unnamed */ }, + { "$2", 3137, _CFFI_F_UNION|_CFFI_F_CHECK_FIELDS, + (size_t)-2, -2, 79, 2 /* unnamed */ }, + { "$3", 3138, _CFFI_F_UNION|_CFFI_F_CHECK_FIELDS, + (size_t)-2, -2, 81, 3 /* unnamed */ }, + { "$4", 3139, _CFFI_F_UNION|_CFFI_F_CHECK_FIELDS, + (size_t)-2, -2, 84, 8 /* unnamed */ }, + { "$ACCESS_DESCRIPTION", 3006, _CFFI_F_CHECK_FIELDS, + sizeof(ACCESS_DESCRIPTION), offsetof(struct _cffi_align_typedef_ACCESS_DESCRIPTION, y), 0, 2 }, + { "$AES_KEY", 3007, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$ASN1_ENUMERATED", 3008, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$ASN1_GENERALIZEDTIME", 3010, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$ASN1_INTEGER", 3012, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$ASN1_NULL", 3014, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$ASN1_OBJECT", 3015, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$ASN1_TYPE", 3018, 0, + sizeof(ASN1_TYPE), offsetof(struct _cffi_align_typedef_ASN1_TYPE, y), 2, 1 }, + { "$AUTHORITY_KEYID", 3019, _CFFI_F_CHECK_FIELDS, + sizeof(AUTHORITY_KEYID), offsetof(struct _cffi_align_typedef_AUTHORITY_KEYID, y), 3, 3 }, + { "$BASIC_CONSTRAINTS", 3020, _CFFI_F_CHECK_FIELDS, + sizeof(BASIC_CONSTRAINTS), offsetof(struct _cffi_align_typedef_BASIC_CONSTRAINTS, y), 6, 2 }, + { "$BIGNUM", 3021, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$BIO", 3022, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$BIO_METHOD", 3023, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$BN_CTX", 3024, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$BN_GENCB", 3025, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$BN_MONT_CTX", 3026, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$CMAC_CTX", 3027, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$CONF", 3028, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$CRYPTOGRAPHY_PASSWORD_DATA", 3029, _CFFI_F_CHECK_FIELDS, + sizeof(CRYPTOGRAPHY_PASSWORD_DATA), offsetof(struct _cffi_align_typedef_CRYPTOGRAPHY_PASSWORD_DATA, y), 8, 5 }, + { "$CRYPTO_EX_dup", 3030, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$CRYPTO_EX_free", 3031, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$CRYPTO_EX_new", 3032, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_LHASH_OF_CONF_VALUE", 3033, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_ACCESS_DESCRIPTION", 3034, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_ASN1_INTEGER", 3035, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_ASN1_OBJECT", 3036, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_DIST_POINT", 3037, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_GENERAL_SUBTREE", 3038, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_POLICYINFO", 3039, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_POLICYQUALINFO", 3040, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_SCT", 3041, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_SSL_CIPHER", 3042, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_X509", 3043, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_X509_CRL", 3044, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_X509_NAME", 3045, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_X509_NAME_ENTRY", 3046, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_X509_OBJECT", 3047, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$Cryptography_STACK_OF_X509_REVOKED", 3048, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$DH", 3049, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$DIST_POINT", 3050, 0, + sizeof(DIST_POINT), offsetof(struct _cffi_align_typedef_DIST_POINT, y), 13, 3 }, + { "$DIST_POINT_NAME", 3051, 0, + sizeof(DIST_POINT_NAME), offsetof(struct _cffi_align_typedef_DIST_POINT_NAME, y), 16, 2 }, + { "$DSA", 3052, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$ECDSA_SIG", 3053, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EC_GROUP", 3054, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EC_KEY", 3055, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EC_METHOD", 3056, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EC_POINT", 3057, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EC_builtin_curve", 3058, _CFFI_F_CHECK_FIELDS, + sizeof(EC_builtin_curve), offsetof(struct _cffi_align_typedef_EC_builtin_curve, y), 18, 2 }, + { "$EDIPARTYNAME", 3060, 0, + sizeof(EDIPARTYNAME), offsetof(struct _cffi_align_typedef_EDIPARTYNAME, y), 20, 0 }, + { "$ENGINE", 3061, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EVP_CIPHER", 3062, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EVP_CIPHER_CTX", 3063, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EVP_MD", 3064, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EVP_MD_CTX", 3065, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EVP_PKEY", 3066, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EVP_PKEY_CTX", 3067, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$EXTENDED_KEY_USAGE", 3068, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$GENERAL_NAME", 3069, 0, + sizeof(GENERAL_NAME), offsetof(struct _cffi_align_typedef_GENERAL_NAME, y), 20, 2 }, + { "$GENERAL_SUBTREE", 3071, _CFFI_F_CHECK_FIELDS, + sizeof(GENERAL_SUBTREE), offsetof(struct _cffi_align_typedef_GENERAL_SUBTREE, y), 22, 3 }, + { "$HMAC_CTX", 3072, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$ISSUING_DIST_POINT", 3073, _CFFI_F_CHECK_FIELDS, + sizeof(ISSUING_DIST_POINT), offsetof(struct _cffi_align_typedef_ISSUING_DIST_POINT, y), 25, 6 }, + { "$NAME_CONSTRAINTS", 3074, _CFFI_F_CHECK_FIELDS, + sizeof(NAME_CONSTRAINTS), offsetof(struct _cffi_align_typedef_NAME_CONSTRAINTS, y), 31, 2 }, + { "$NETSCAPE_SPKI", 3075, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$NOTICEREF", 3076, _CFFI_F_CHECK_FIELDS, + sizeof(NOTICEREF), offsetof(struct _cffi_align_typedef_NOTICEREF, y), 33, 2 }, + { "$OBJ_NAME", 3077, _CFFI_F_CHECK_FIELDS, + sizeof(OBJ_NAME), offsetof(struct _cffi_align_typedef_OBJ_NAME, y), 35, 4 }, + { "$OCSP_BASICRESP", 3078, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$OCSP_CERTID", 3080, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$OCSP_ONEREQ", 3081, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$OCSP_REQUEST", 3082, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$OCSP_RESPDATA", 3084, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$OCSP_RESPONSE", 3085, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$OCSP_SINGLERESP", 3086, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$OTHERNAME", 3087, _CFFI_F_CHECK_FIELDS, + sizeof(OTHERNAME), offsetof(struct _cffi_align_typedef_OTHERNAME, y), 39, 2 }, + { "$PKCS12", 3088, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$PKCS7", 3089, 0, + sizeof(PKCS7), offsetof(struct _cffi_align_typedef_PKCS7, y), 41, 2 }, + { "$PKCS7_DIGEST", 3091, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$PKCS7_ENCRYPT", 3093, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$PKCS7_ENVELOPE", 3095, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$PKCS7_SIGNED", 3097, 0, + sizeof(PKCS7_SIGNED), offsetof(struct _cffi_align_typedef_PKCS7_SIGNED, y), 43, 2 }, + { "$PKCS7_SIGNER_INFO", 3099, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$PKCS7_SIGN_ENVELOPE", 3101, 0, + sizeof(PKCS7_SIGN_ENVELOPE), offsetof(struct _cffi_align_typedef_PKCS7_SIGN_ENVELOPE, y), 45, 2 }, + { "$PKCS8_PRIV_KEY_INFO", 3102, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$POLICYINFO", 3103, _CFFI_F_CHECK_FIELDS, + sizeof(POLICYINFO), offsetof(struct _cffi_align_typedef_POLICYINFO, y), 47, 2 }, + { "$POLICYQUALINFO", 3104, _CFFI_F_CHECK_FIELDS, + sizeof(POLICYQUALINFO), offsetof(struct _cffi_align_typedef_POLICYQUALINFO, y), 49, 2 }, + { "$POLICY_CONSTRAINTS", 3105, _CFFI_F_CHECK_FIELDS, + sizeof(POLICY_CONSTRAINTS), offsetof(struct _cffi_align_typedef_POLICY_CONSTRAINTS, y), 51, 2 }, + { "$RAND_METHOD", 3106, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$RSA", 3107, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$SCT", 3108, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$SRTP_PROTECTION_PROFILE", 3110, _CFFI_F_CHECK_FIELDS, + sizeof(SRTP_PROTECTION_PROFILE), offsetof(struct _cffi_align_typedef_SRTP_PROTECTION_PROFILE, y), 53, 2 }, + { "$SSL", 3111, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$SSL_CIPHER", 3112, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$SSL_CTX", 3113, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$SSL_METHOD", 3115, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$SSL_SESSION", 3116, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$UI_METHOD", 3117, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$USERNOTICE", 3118, _CFFI_F_CHECK_FIELDS, + sizeof(USERNOTICE), offsetof(struct _cffi_align_typedef_USERNOTICE, y), 55, 2 }, + { "$X509", 3119, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509V3_CTX", 3120, 0, + sizeof(X509V3_CTX), offsetof(struct _cffi_align_typedef_X509V3_CTX, y), 57, 2 }, + { "$X509_ALGOR", 3122, 0, + sizeof(X509_ALGOR), offsetof(struct _cffi_align_typedef_X509_ALGOR, y), 59, 1 }, + { "$X509_ATTRIBUTE", 3123, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509_CRL", 3124, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509_EXTENSION", 3125, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509_EXTENSIONS", 3126, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509_NAME", 3127, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509_NAME_ENTRY", 3128, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509_OBJECT", 3129, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509_REQ", 3130, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509_REVOKED", 3131, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509_STORE", 3132, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509_STORE_CTX", 3133, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "$X509_VERIFY_PARAM", 3134, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, + { "asn1_string_st", 3017, _CFFI_F_CHECK_FIELDS, + sizeof(ASN1_OCTET_STRING), offsetof(struct _cffi_align__ASN1_OCTET_STRING, y), 60, 4 }, + { "stack_st_GENERAL_NAME", 3070, _CFFI_F_OPAQUE, + (size_t)-1, -1, -1, 0 /* opaque */ }, +}; + +static const struct _cffi_enum_s _cffi_enums[] = { + { "$ct_log_entry_type_t", 1646, _cffi_prim_int(sizeof(ct_log_entry_type_t), ((ct_log_entry_type_t)-1) <= 0), + "CT_LOG_ENTRY_TYPE_NOT_SET,CT_LOG_ENTRY_TYPE_X509,CT_LOG_ENTRY_TYPE_PRECERT" }, + { "$point_conversion_form_t", 2375, _cffi_prim_int(sizeof(point_conversion_form_t), ((point_conversion_form_t)-1) <= 0), + "POINT_CONVERSION_COMPRESSED,POINT_CONVERSION_UNCOMPRESSED" }, + { "$sct_source_t", 1650, _cffi_prim_int(sizeof(sct_source_t), ((sct_source_t)-1) <= 0), + "SCT_SOURCE_UNKNOWN,SCT_SOURCE_TLS_EXTENSION,SCT_SOURCE_X509V3_EXTENSION,SCT_SOURCE_OCSP_STAPLED_RESPONSE" }, + { "$sct_version_t", 1654, _cffi_prim_int(sizeof(sct_version_t), ((sct_version_t)-1) <= 0), + "SCT_VERSION_NOT_SET,SCT_VERSION_V1" }, +}; + +static const struct _cffi_typename_s _cffi_typenames[] = { + { "ACCESS_DESCRIPTION", 3006 }, + { "AES_KEY", 3007 }, + { "ASN1_BIT_STRING", 3017 }, + { "ASN1_ENUMERATED", 3008 }, + { "ASN1_GENERALIZEDTIME", 3010 }, + { "ASN1_IA5STRING", 3017 }, + { "ASN1_INTEGER", 3012 }, + { "ASN1_NULL", 3014 }, + { "ASN1_OBJECT", 3015 }, + { "ASN1_OCTET_STRING", 3017 }, + { "ASN1_STRING", 3017 }, + { "ASN1_TIME", 3017 }, + { "ASN1_TYPE", 3018 }, + { "ASN1_UTF8STRING", 3017 }, + { "AUTHORITY_KEYID", 3019 }, + { "BASIC_CONSTRAINTS", 3020 }, + { "BIGNUM", 3021 }, + { "BIO", 3022 }, + { "BIO_METHOD", 3023 }, + { "BN_CTX", 3024 }, + { "BN_GENCB", 3025 }, + { "BN_MONT_CTX", 3026 }, + { "BN_ULONG", 840 }, + { "CMAC_CTX", 3027 }, + { "CONF", 3028 }, + { "CRYPTOGRAPHY_PASSWORD_DATA", 3029 }, + { "CRYPTO_EX_dup", 3030 }, + { "CRYPTO_EX_free", 3031 }, + { "CRYPTO_EX_new", 3032 }, + { "Cryptography_LHASH_OF_CONF_VALUE", 3033 }, + { "Cryptography_STACK_OF_ACCESS_DESCRIPTION", 3034 }, + { "Cryptography_STACK_OF_ASN1_INTEGER", 3035 }, + { "Cryptography_STACK_OF_ASN1_OBJECT", 3036 }, + { "Cryptography_STACK_OF_DIST_POINT", 3037 }, + { "Cryptography_STACK_OF_GENERAL_SUBTREE", 3038 }, + { "Cryptography_STACK_OF_POLICYINFO", 3039 }, + { "Cryptography_STACK_OF_POLICYQUALINFO", 3040 }, + { "Cryptography_STACK_OF_SCT", 3041 }, + { "Cryptography_STACK_OF_SSL_CIPHER", 3042 }, + { "Cryptography_STACK_OF_X509", 3043 }, + { "Cryptography_STACK_OF_X509_CRL", 3044 }, + { "Cryptography_STACK_OF_X509_NAME", 3045 }, + { "Cryptography_STACK_OF_X509_NAME_ENTRY", 3046 }, + { "Cryptography_STACK_OF_X509_OBJECT", 3047 }, + { "Cryptography_STACK_OF_X509_REVOKED", 3048 }, + { "DH", 3049 }, + { "DIST_POINT", 3050 }, + { "DIST_POINT_NAME", 3051 }, + { "DSA", 3052 }, + { "ECDSA_SIG", 3053 }, + { "EC_GROUP", 3054 }, + { "EC_KEY", 3055 }, + { "EC_METHOD", 3056 }, + { "EC_POINT", 3057 }, + { "EC_builtin_curve", 3058 }, + { "EDIPARTYNAME", 3060 }, + { "ENGINE", 3061 }, + { "EVP_CIPHER", 3062 }, + { "EVP_CIPHER_CTX", 3063 }, + { "EVP_MD", 3064 }, + { "EVP_MD_CTX", 3065 }, + { "EVP_PKEY", 3066 }, + { "EVP_PKEY_CTX", 3067 }, + { "EXTENDED_KEY_USAGE", 3068 }, + { "GENERAL_NAME", 3069 }, + { "GENERAL_NAMES", 3070 }, + { "GENERAL_SUBTREE", 3071 }, + { "HMAC_CTX", 3072 }, + { "ISSUING_DIST_POINT", 3073 }, + { "NAME_CONSTRAINTS", 3074 }, + { "NETSCAPE_SPKI", 3075 }, + { "NOTICEREF", 3076 }, + { "OBJ_NAME", 3077 }, + { "OCSP_BASICRESP", 3078 }, + { "OCSP_CERTID", 3080 }, + { "OCSP_ONEREQ", 3081 }, + { "OCSP_REQUEST", 3082 }, + { "OCSP_RESPDATA", 3084 }, + { "OCSP_RESPONSE", 3085 }, + { "OCSP_SINGLERESP", 3086 }, + { "OTHERNAME", 3087 }, + { "PKCS12", 3088 }, + { "PKCS7", 3089 }, + { "PKCS7_DIGEST", 3091 }, + { "PKCS7_ENCRYPT", 3093 }, + { "PKCS7_ENVELOPE", 3095 }, + { "PKCS7_SIGNED", 3097 }, + { "PKCS7_SIGNER_INFO", 3099 }, + { "PKCS7_SIGN_ENVELOPE", 3101 }, + { "PKCS8_PRIV_KEY_INFO", 3102 }, + { "POLICYINFO", 3103 }, + { "POLICYQUALINFO", 3104 }, + { "POLICY_CONSTRAINTS", 3105 }, + { "RAND_METHOD", 3106 }, + { "RSA", 3107 }, + { "SCT", 3108 }, + { "SRTP_PROTECTION_PROFILE", 3110 }, + { "SSL", 3111 }, + { "SSL_CIPHER", 3112 }, + { "SSL_CTX", 3113 }, + { "SSL_METHOD", 3115 }, + { "SSL_SESSION", 3116 }, + { "UI_METHOD", 3117 }, + { "USERNOTICE", 3118 }, + { "X509", 3119 }, + { "X509V3_CTX", 3120 }, + { "X509V3_EXT_D2I", 3141 }, + { "X509_ALGOR", 3122 }, + { "X509_ATTRIBUTE", 3123 }, + { "X509_CRL", 3124 }, + { "X509_EXTENSION", 3125 }, + { "X509_EXTENSIONS", 3126 }, + { "X509_NAME", 3127 }, + { "X509_NAME_ENTRY", 3128 }, + { "X509_OBJECT", 3129 }, + { "X509_REQ", 3130 }, + { "X509_REVOKED", 3131 }, + { "X509_STORE", 3132 }, + { "X509_STORE_CTX", 3133 }, + { "X509_STORE_CTX_get_issuer_fn", 2926 }, + { "X509_VERIFY_PARAM", 3134 }, + { "ct_log_entry_type_t", 1646 }, + { "custom_ext_add_cb", 1821 }, + { "custom_ext_free_cb", 1822 }, + { "custom_ext_parse_cb", 1824 }, + { "pem_password_cb", 2160 }, + { "point_conversion_form_t", 2375 }, + { "sct_source_t", 1650 }, + { "sct_version_t", 1654 }, + { "sk_ACCESS_DESCRIPTION_freefunc", 2586 }, + { "sk_DIST_POINT_freefunc", 2599 }, + { "sk_GENERAL_NAME_freefunc", 2696 }, + { "sk_POLICYINFO_freefunc", 2609 }, + { "sk_X509_EXTENSION_freefunc", 2902 }, + { "time_t", 10 }, +}; + +static const struct _cffi_type_context_s _cffi_type_context = { + _cffi_types, + _cffi_globals, + _cffi_fields, + _cffi_struct_unions, + _cffi_enums, + _cffi_typenames, + 1295, /* num_globals */ + 117, /* num_struct_unions */ + 4, /* num_enums */ + 135, /* num_typenames */ + NULL, /* no includes */ + 3143, /* num_types */ + 0, /* flags */ +}; + +#ifdef PYPY_VERSION +PyMODINIT_FUNC +_cffi_pypyinit__openssl(const void *p[]) +{ + p[0] = (const void *)0x2601; + p[1] = &_cffi_type_context; +} +# ifdef _MSC_VER + PyMODINIT_FUNC +# if PY_MAJOR_VERSION >= 3 + PyInit__openssl(void) { return NULL; } +# else + init_openssl(void) { } +# endif +# endif +#elif PY_MAJOR_VERSION >= 3 +PyMODINIT_FUNC +PyInit__openssl(void) +{ + return _cffi_init("_openssl", 0x2601, &_cffi_type_context); +} +#else +PyMODINIT_FUNC +init_openssl(void) +{ + _cffi_init("_openssl", 0x2601, &_cffi_type_context); +} +#endif diff --git a/contrib/python/cryptography/py3/build/temp.linux-x86_64-2.7/_padding.c b/contrib/python/cryptography/py3/build/temp.linux-x86_64-2.7/_padding.c new file mode 100644 index 0000000000..aa3f1b819d --- /dev/null +++ b/contrib/python/cryptography/py3/build/temp.linux-x86_64-2.7/_padding.c @@ -0,0 +1,658 @@ +#define _CFFI_ + +/* We try to define Py_LIMITED_API before including Python.h. + + Mess: we can only define it if Py_DEBUG, Py_TRACE_REFS and + Py_REF_DEBUG are not defined. This is a best-effort approximation: + we can learn about Py_DEBUG from pyconfig.h, but it is unclear if + the same works for the other two macros. Py_DEBUG implies them, + but not the other way around. +*/ +#ifndef _CFFI_USE_EMBEDDING +# include <pyconfig.h> +# if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) +# define Py_LIMITED_API +# endif +#endif + +#include <Python.h> +#ifdef __cplusplus +extern "C" { +#endif +#include <stddef.h> + +/* This part is from file 'cffi/parse_c_type.h'. It is copied at the + beginning of C sources generated by CFFI's ffi.set_source(). */ + +typedef void *_cffi_opcode_t; + +#define _CFFI_OP(opcode, arg) (_cffi_opcode_t)(opcode | (((uintptr_t)(arg)) << 8)) +#define _CFFI_GETOP(cffi_opcode) ((unsigned char)(uintptr_t)cffi_opcode) +#define _CFFI_GETARG(cffi_opcode) (((intptr_t)cffi_opcode) >> 8) + +#define _CFFI_OP_PRIMITIVE 1 +#define _CFFI_OP_POINTER 3 +#define _CFFI_OP_ARRAY 5 +#define _CFFI_OP_OPEN_ARRAY 7 +#define _CFFI_OP_STRUCT_UNION 9 +#define _CFFI_OP_ENUM 11 +#define _CFFI_OP_FUNCTION 13 +#define _CFFI_OP_FUNCTION_END 15 +#define _CFFI_OP_NOOP 17 +#define _CFFI_OP_BITFIELD 19 +#define _CFFI_OP_TYPENAME 21 +#define _CFFI_OP_CPYTHON_BLTN_V 23 // varargs +#define _CFFI_OP_CPYTHON_BLTN_N 25 // noargs +#define _CFFI_OP_CPYTHON_BLTN_O 27 // O (i.e. a single arg) +#define _CFFI_OP_CONSTANT 29 +#define _CFFI_OP_CONSTANT_INT 31 +#define _CFFI_OP_GLOBAL_VAR 33 +#define _CFFI_OP_DLOPEN_FUNC 35 +#define _CFFI_OP_DLOPEN_CONST 37 +#define _CFFI_OP_GLOBAL_VAR_F 39 +#define _CFFI_OP_EXTERN_PYTHON 41 + +#define _CFFI_PRIM_VOID 0 +#define _CFFI_PRIM_BOOL 1 +#define _CFFI_PRIM_CHAR 2 +#define _CFFI_PRIM_SCHAR 3 +#define _CFFI_PRIM_UCHAR 4 +#define _CFFI_PRIM_SHORT 5 +#define _CFFI_PRIM_USHORT 6 +#define _CFFI_PRIM_INT 7 +#define _CFFI_PRIM_UINT 8 +#define _CFFI_PRIM_LONG 9 +#define _CFFI_PRIM_ULONG 10 +#define _CFFI_PRIM_LONGLONG 11 +#define _CFFI_PRIM_ULONGLONG 12 +#define _CFFI_PRIM_FLOAT 13 +#define _CFFI_PRIM_DOUBLE 14 +#define _CFFI_PRIM_LONGDOUBLE 15 + +#define _CFFI_PRIM_WCHAR 16 +#define _CFFI_PRIM_INT8 17 +#define _CFFI_PRIM_UINT8 18 +#define _CFFI_PRIM_INT16 19 +#define _CFFI_PRIM_UINT16 20 +#define _CFFI_PRIM_INT32 21 +#define _CFFI_PRIM_UINT32 22 +#define _CFFI_PRIM_INT64 23 +#define _CFFI_PRIM_UINT64 24 +#define _CFFI_PRIM_INTPTR 25 +#define _CFFI_PRIM_UINTPTR 26 +#define _CFFI_PRIM_PTRDIFF 27 +#define _CFFI_PRIM_SIZE 28 +#define _CFFI_PRIM_SSIZE 29 +#define _CFFI_PRIM_INT_LEAST8 30 +#define _CFFI_PRIM_UINT_LEAST8 31 +#define _CFFI_PRIM_INT_LEAST16 32 +#define _CFFI_PRIM_UINT_LEAST16 33 +#define _CFFI_PRIM_INT_LEAST32 34 +#define _CFFI_PRIM_UINT_LEAST32 35 +#define _CFFI_PRIM_INT_LEAST64 36 +#define _CFFI_PRIM_UINT_LEAST64 37 +#define _CFFI_PRIM_INT_FAST8 38 +#define _CFFI_PRIM_UINT_FAST8 39 +#define _CFFI_PRIM_INT_FAST16 40 +#define _CFFI_PRIM_UINT_FAST16 41 +#define _CFFI_PRIM_INT_FAST32 42 +#define _CFFI_PRIM_UINT_FAST32 43 +#define _CFFI_PRIM_INT_FAST64 44 +#define _CFFI_PRIM_UINT_FAST64 45 +#define _CFFI_PRIM_INTMAX 46 +#define _CFFI_PRIM_UINTMAX 47 + +#define _CFFI__NUM_PRIM 48 +#define _CFFI__UNKNOWN_PRIM (-1) +#define _CFFI__UNKNOWN_FLOAT_PRIM (-2) +#define _CFFI__UNKNOWN_LONG_DOUBLE (-3) + +#define _CFFI__IO_FILE_STRUCT (-1) + + +struct _cffi_global_s { + const char *name; + void *address; + _cffi_opcode_t type_op; + void *size_or_direct_fn; // OP_GLOBAL_VAR: size, or 0 if unknown + // OP_CPYTHON_BLTN_*: addr of direct function +}; + +struct _cffi_getconst_s { + unsigned long long value; + const struct _cffi_type_context_s *ctx; + int gindex; +}; + +struct _cffi_struct_union_s { + const char *name; + int type_index; // -> _cffi_types, on a OP_STRUCT_UNION + int flags; // _CFFI_F_* flags below + size_t size; + int alignment; + int first_field_index; // -> _cffi_fields array + int num_fields; +}; +#define _CFFI_F_UNION 0x01 // is a union, not a struct +#define _CFFI_F_CHECK_FIELDS 0x02 // complain if fields are not in the + // "standard layout" or if some are missing +#define _CFFI_F_PACKED 0x04 // for CHECK_FIELDS, assume a packed struct +#define _CFFI_F_EXTERNAL 0x08 // in some other ffi.include() +#define _CFFI_F_OPAQUE 0x10 // opaque + +struct _cffi_field_s { + const char *name; + size_t field_offset; + size_t field_size; + _cffi_opcode_t field_type_op; +}; + +struct _cffi_enum_s { + const char *name; + int type_index; // -> _cffi_types, on a OP_ENUM + int type_prim; // _CFFI_PRIM_xxx + const char *enumerators; // comma-delimited string +}; + +struct _cffi_typename_s { + const char *name; + int type_index; /* if opaque, points to a possibly artificial + OP_STRUCT which is itself opaque */ +}; + +struct _cffi_type_context_s { + _cffi_opcode_t *types; + const struct _cffi_global_s *globals; + const struct _cffi_field_s *fields; + const struct _cffi_struct_union_s *struct_unions; + const struct _cffi_enum_s *enums; + const struct _cffi_typename_s *typenames; + int num_globals; + int num_struct_unions; + int num_enums; + int num_typenames; + const char *const *includes; + int num_types; + int flags; /* future extension */ +}; + +struct _cffi_parse_info_s { + const struct _cffi_type_context_s *ctx; + _cffi_opcode_t *output; + unsigned int output_size; + size_t error_location; + const char *error_message; +}; + +struct _cffi_externpy_s { + const char *name; + size_t size_of_result; + void *reserved1, *reserved2; +}; + +#ifdef _CFFI_INTERNAL +static int parse_c_type(struct _cffi_parse_info_s *info, const char *input); +static int search_in_globals(const struct _cffi_type_context_s *ctx, + const char *search, size_t search_len); +static int search_in_struct_unions(const struct _cffi_type_context_s *ctx, + const char *search, size_t search_len); +#endif + +/* this block of #ifs should be kept exactly identical between + c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py + and cffi/_cffi_include.h */ +#if defined(_MSC_VER) +# include <malloc.h> /* for alloca() */ +# if _MSC_VER < 1600 /* MSVC < 2010 */ + typedef __int8 int8_t; + typedef __int16 int16_t; + typedef __int32 int32_t; + typedef __int64 int64_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int64 uint64_t; + typedef __int8 int_least8_t; + typedef __int16 int_least16_t; + typedef __int32 int_least32_t; + typedef __int64 int_least64_t; + typedef unsigned __int8 uint_least8_t; + typedef unsigned __int16 uint_least16_t; + typedef unsigned __int32 uint_least32_t; + typedef unsigned __int64 uint_least64_t; + typedef __int8 int_fast8_t; + typedef __int16 int_fast16_t; + typedef __int32 int_fast32_t; + typedef __int64 int_fast64_t; + typedef unsigned __int8 uint_fast8_t; + typedef unsigned __int16 uint_fast16_t; + typedef unsigned __int32 uint_fast32_t; + typedef unsigned __int64 uint_fast64_t; + typedef __int64 intmax_t; + typedef unsigned __int64 uintmax_t; +# else +# include <stdint.h> +# endif +# if _MSC_VER < 1800 /* MSVC < 2013 */ +# ifndef __cplusplus + typedef unsigned char _Bool; +# endif +# endif +#else +# include <stdint.h> +# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) +# include <alloca.h> +# endif +#endif + +#ifdef __GNUC__ +# define _CFFI_UNUSED_FN __attribute__((unused)) +#else +# define _CFFI_UNUSED_FN /* nothing */ +#endif + +#ifdef __cplusplus +# ifndef _Bool + typedef bool _Bool; /* semi-hackish: C++ has no _Bool; bool is builtin */ +# endif +#endif + +/********** CPython-specific section **********/ +#ifndef PYPY_VERSION + + +#if PY_MAJOR_VERSION >= 3 +# define PyInt_FromLong PyLong_FromLong +#endif + +#define _cffi_from_c_double PyFloat_FromDouble +#define _cffi_from_c_float PyFloat_FromDouble +#define _cffi_from_c_long PyInt_FromLong +#define _cffi_from_c_ulong PyLong_FromUnsignedLong +#define _cffi_from_c_longlong PyLong_FromLongLong +#define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong + +#define _cffi_to_c_double PyFloat_AsDouble +#define _cffi_to_c_float PyFloat_AsDouble + +#define _cffi_from_c_int(x, type) \ + (((type)-1) > 0 ? /* unsigned */ \ + (sizeof(type) < sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + sizeof(type) == sizeof(long) ? \ + PyLong_FromUnsignedLong((unsigned long)x) : \ + PyLong_FromUnsignedLongLong((unsigned long long)x)) : \ + (sizeof(type) <= sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + PyLong_FromLongLong((long long)x))) + +#define _cffi_to_c_int(o, type) \ + ((type)( \ + sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o) \ + : (type)_cffi_to_c_i8(o)) : \ + sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o) \ + : (type)_cffi_to_c_i16(o)) : \ + sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o) \ + : (type)_cffi_to_c_i32(o)) : \ + sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o) \ + : (type)_cffi_to_c_i64(o)) : \ + (Py_FatalError("unsupported size for type " #type), (type)0))) + +#define _cffi_to_c_i8 \ + ((int(*)(PyObject *))_cffi_exports[1]) +#define _cffi_to_c_u8 \ + ((int(*)(PyObject *))_cffi_exports[2]) +#define _cffi_to_c_i16 \ + ((int(*)(PyObject *))_cffi_exports[3]) +#define _cffi_to_c_u16 \ + ((int(*)(PyObject *))_cffi_exports[4]) +#define _cffi_to_c_i32 \ + ((int(*)(PyObject *))_cffi_exports[5]) +#define _cffi_to_c_u32 \ + ((unsigned int(*)(PyObject *))_cffi_exports[6]) +#define _cffi_to_c_i64 \ + ((long long(*)(PyObject *))_cffi_exports[7]) +#define _cffi_to_c_u64 \ + ((unsigned long long(*)(PyObject *))_cffi_exports[8]) +#define _cffi_to_c_char \ + ((int(*)(PyObject *))_cffi_exports[9]) +#define _cffi_from_c_pointer \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[10]) +#define _cffi_to_c_pointer \ + ((char *(*)(PyObject *, struct _cffi_ctypedescr *))_cffi_exports[11]) +#define _cffi_get_struct_layout \ + not used any more +#define _cffi_restore_errno \ + ((void(*)(void))_cffi_exports[13]) +#define _cffi_save_errno \ + ((void(*)(void))_cffi_exports[14]) +#define _cffi_from_c_char \ + ((PyObject *(*)(char))_cffi_exports[15]) +#define _cffi_from_c_deref \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[16]) +#define _cffi_to_c \ + ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[17]) +#define _cffi_from_c_struct \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[18]) +#define _cffi_to_c_wchar_t \ + ((wchar_t(*)(PyObject *))_cffi_exports[19]) +#define _cffi_from_c_wchar_t \ + ((PyObject *(*)(wchar_t))_cffi_exports[20]) +#define _cffi_to_c_long_double \ + ((long double(*)(PyObject *))_cffi_exports[21]) +#define _cffi_to_c__Bool \ + ((_Bool(*)(PyObject *))_cffi_exports[22]) +#define _cffi_prepare_pointer_call_argument \ + ((Py_ssize_t(*)(struct _cffi_ctypedescr *, \ + PyObject *, char **))_cffi_exports[23]) +#define _cffi_convert_array_from_object \ + ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[24]) +#define _CFFI_CPIDX 25 +#define _cffi_call_python \ + ((void(*)(struct _cffi_externpy_s *, char *))_cffi_exports[_CFFI_CPIDX]) +#define _CFFI_NUM_EXPORTS 26 + +struct _cffi_ctypedescr; + +static void *_cffi_exports[_CFFI_NUM_EXPORTS]; + +#define _cffi_type(index) ( \ + assert((((uintptr_t)_cffi_types[index]) & 1) == 0), \ + (struct _cffi_ctypedescr *)_cffi_types[index]) + +static PyObject *_cffi_init(const char *module_name, Py_ssize_t version, + const struct _cffi_type_context_s *ctx) +{ + PyObject *module, *o_arg, *new_module; + void *raw[] = { + (void *)module_name, + (void *)version, + (void *)_cffi_exports, + (void *)ctx, + }; + + module = PyImport_ImportModule("_cffi_backend"); + if (module == NULL) + goto failure; + + o_arg = PyLong_FromVoidPtr((void *)raw); + if (o_arg == NULL) + goto failure; + + new_module = PyObject_CallMethod( + module, (char *)"_init_cffi_1_0_external_module", (char *)"O", o_arg); + + Py_DECREF(o_arg); + Py_DECREF(module); + return new_module; + + failure: + Py_XDECREF(module); + return NULL; +} + +/********** end CPython-specific section **********/ +#else +_CFFI_UNUSED_FN +static void (*_cffi_call_python_org)(struct _cffi_externpy_s *, char *); +# define _cffi_call_python _cffi_call_python_org +#endif + + +#define _cffi_array_len(array) (sizeof(array) / sizeof((array)[0])) + +#define _cffi_prim_int(size, sign) \ + ((size) == 1 ? ((sign) ? _CFFI_PRIM_INT8 : _CFFI_PRIM_UINT8) : \ + (size) == 2 ? ((sign) ? _CFFI_PRIM_INT16 : _CFFI_PRIM_UINT16) : \ + (size) == 4 ? ((sign) ? _CFFI_PRIM_INT32 : _CFFI_PRIM_UINT32) : \ + (size) == 8 ? ((sign) ? _CFFI_PRIM_INT64 : _CFFI_PRIM_UINT64) : \ + _CFFI__UNKNOWN_PRIM) + +#define _cffi_prim_float(size) \ + ((size) == sizeof(float) ? _CFFI_PRIM_FLOAT : \ + (size) == sizeof(double) ? _CFFI_PRIM_DOUBLE : \ + (size) == sizeof(long double) ? _CFFI__UNKNOWN_LONG_DOUBLE : \ + _CFFI__UNKNOWN_FLOAT_PRIM) + +#define _cffi_check_int(got, got_nonpos, expected) \ + ((got_nonpos) == (expected <= 0) && \ + (got) == (unsigned long long)expected) + +#ifdef MS_WIN32 +# define _cffi_stdcall __stdcall +#else +# define _cffi_stdcall /* nothing */ +#endif + +#ifdef __cplusplus +} +#endif + +/************************************************************/ + +// This file is dual licensed under the terms of the Apache License, Version +// 2.0, and the BSD License. See the LICENSE file in the root of this +// repository for complete details. + +/* Returns the value of the input with the most-significant-bit copied to all + of the bits. */ +static uint16_t Cryptography_DUPLICATE_MSB_TO_ALL(uint16_t a) { + return (1 - (a >> (sizeof(uint16_t) * 8 - 1))) - 1; +} + +/* This returns 0xFFFF if a < b else 0x0000, but does so in a constant time + fashion */ +static uint16_t Cryptography_constant_time_lt(uint16_t a, uint16_t b) { + a -= b; + return Cryptography_DUPLICATE_MSB_TO_ALL(a); +} + +uint8_t Cryptography_check_pkcs7_padding(const uint8_t *data, + uint16_t block_len) { + uint16_t i; + uint16_t pad_size = data[block_len - 1]; + uint16_t mismatch = 0; + for (i = 0; i < block_len; i++) { + unsigned int mask = Cryptography_constant_time_lt(i, pad_size); + uint16_t b = data[block_len - 1 - i]; + mismatch |= (mask & (pad_size ^ b)); + } + + /* Check to make sure the pad_size was within the valid range. */ + mismatch |= ~Cryptography_constant_time_lt(0, pad_size); + mismatch |= Cryptography_constant_time_lt(block_len, pad_size); + + /* Make sure any bits set are copied to the lowest bit */ + mismatch |= mismatch >> 8; + mismatch |= mismatch >> 4; + mismatch |= mismatch >> 2; + mismatch |= mismatch >> 1; + /* Now check the low bit to see if it's set */ + return (mismatch & 1) == 0; +} + +uint8_t Cryptography_check_ansix923_padding(const uint8_t *data, + uint16_t block_len) { + uint16_t i; + uint16_t pad_size = data[block_len - 1]; + uint16_t mismatch = 0; + /* Skip the first one with the pad size */ + for (i = 1; i < block_len; i++) { + unsigned int mask = Cryptography_constant_time_lt(i, pad_size); + uint16_t b = data[block_len - 1 - i]; + mismatch |= (mask & b); + } + + /* Check to make sure the pad_size was within the valid range. */ + mismatch |= ~Cryptography_constant_time_lt(0, pad_size); + mismatch |= Cryptography_constant_time_lt(block_len, pad_size); + + /* Make sure any bits set are copied to the lowest bit */ + mismatch |= mismatch >> 8; + mismatch |= mismatch >> 4; + mismatch |= mismatch >> 2; + mismatch |= mismatch >> 1; + /* Now check the low bit to see if it's set */ + return (mismatch & 1) == 0; +} + +#define CRYPTOGRAPHY_PACKAGE_VERSION "3.3.2" + +/************************************************************/ + +static void *_cffi_types[] = { +/* 0 */ _CFFI_OP(_CFFI_OP_FUNCTION, 2), // uint8_t()(uint8_t const *, uint8_t) +/* 1 */ _CFFI_OP(_CFFI_OP_POINTER, 2), // uint8_t const * +/* 2 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 18), // uint8_t +/* 3 */ _CFFI_OP(_CFFI_OP_FUNCTION_END, 0), +/* 4 */ _CFFI_OP(_CFFI_OP_POINTER, 5), // char const * +/* 5 */ _CFFI_OP(_CFFI_OP_PRIMITIVE, 2), // char +}; + +static void _cffi_const_CRYPTOGRAPHY_PACKAGE_VERSION(char *o) +{ + *(char const * *)o = CRYPTOGRAPHY_PACKAGE_VERSION; +} + +static uint8_t _cffi_d_Cryptography_check_ansix923_padding(uint8_t const * x0, uint8_t x1) +{ + return Cryptography_check_ansix923_padding(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_check_ansix923_padding(PyObject *self, PyObject *args) +{ + uint8_t const * x0; + uint8_t x1; + Py_ssize_t datasize; + uint8_t result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "Cryptography_check_ansix923_padding", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (uint8_t const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, uint8_t); + if (x1 == (uint8_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_check_ansix923_padding(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, uint8_t); +} +#else +# define _cffi_f_Cryptography_check_ansix923_padding _cffi_d_Cryptography_check_ansix923_padding +#endif + +static uint8_t _cffi_d_Cryptography_check_pkcs7_padding(uint8_t const * x0, uint8_t x1) +{ + return Cryptography_check_pkcs7_padding(x0, x1); +} +#ifndef PYPY_VERSION +static PyObject * +_cffi_f_Cryptography_check_pkcs7_padding(PyObject *self, PyObject *args) +{ + uint8_t const * x0; + uint8_t x1; + Py_ssize_t datasize; + uint8_t result; + PyObject *arg0; + PyObject *arg1; + + if (!PyArg_UnpackTuple(args, "Cryptography_check_pkcs7_padding", 2, 2, &arg0, &arg1)) + return NULL; + + datasize = _cffi_prepare_pointer_call_argument( + _cffi_type(1), arg0, (char **)&x0); + if (datasize != 0) { + if (datasize < 0) + return NULL; + x0 = (uint8_t const *)alloca((size_t)datasize); + memset((void *)x0, 0, (size_t)datasize); + if (_cffi_convert_array_from_object((char *)x0, _cffi_type(1), arg0) < 0) + return NULL; + } + + x1 = _cffi_to_c_int(arg1, uint8_t); + if (x1 == (uint8_t)-1 && PyErr_Occurred()) + return NULL; + + Py_BEGIN_ALLOW_THREADS + _cffi_restore_errno(); + { result = Cryptography_check_pkcs7_padding(x0, x1); } + _cffi_save_errno(); + Py_END_ALLOW_THREADS + + (void)self; /* unused */ + return _cffi_from_c_int(result, uint8_t); +} +#else +# define _cffi_f_Cryptography_check_pkcs7_padding _cffi_d_Cryptography_check_pkcs7_padding +#endif + +static const struct _cffi_global_s _cffi_globals[] = { + { "CRYPTOGRAPHY_PACKAGE_VERSION", (void *)_cffi_const_CRYPTOGRAPHY_PACKAGE_VERSION, _CFFI_OP(_CFFI_OP_CONSTANT, 4), (void *)0 }, + { "Cryptography_check_ansix923_padding", (void *)_cffi_f_Cryptography_check_ansix923_padding, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 0), (void *)_cffi_d_Cryptography_check_ansix923_padding }, + { "Cryptography_check_pkcs7_padding", (void *)_cffi_f_Cryptography_check_pkcs7_padding, _CFFI_OP(_CFFI_OP_CPYTHON_BLTN_V, 0), (void *)_cffi_d_Cryptography_check_pkcs7_padding }, +}; + +static const struct _cffi_type_context_s _cffi_type_context = { + _cffi_types, + _cffi_globals, + NULL, /* no fields */ + NULL, /* no struct_unions */ + NULL, /* no enums */ + NULL, /* no typenames */ + 3, /* num_globals */ + 0, /* num_struct_unions */ + 0, /* num_enums */ + 0, /* num_typenames */ + NULL, /* no includes */ + 6, /* num_types */ + 0, /* flags */ +}; + +#ifdef PYPY_VERSION +PyMODINIT_FUNC +_cffi_pypyinit__padding(const void *p[]) +{ + p[0] = (const void *)0x2601; + p[1] = &_cffi_type_context; +} +# ifdef _MSC_VER + PyMODINIT_FUNC +# if PY_MAJOR_VERSION >= 3 + PyInit__padding(void) { return NULL; } +# else + init_padding(void) { } +# endif +# endif +#elif PY_MAJOR_VERSION >= 3 +PyMODINIT_FUNC +PyInit__padding(void) +{ + return _cffi_init("_padding", 0x2601, &_cffi_type_context); +} +#else +PyMODINIT_FUNC +init_padding(void) +{ + _cffi_init("_padding", 0x2601, &_cffi_type_context); +} +#endif diff --git a/contrib/python/cryptography/py3/cryptography/__about__.py b/contrib/python/cryptography/py3/cryptography/__about__.py new file mode 100644 index 0000000000..f816509257 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/__about__.py @@ -0,0 +1,31 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +__all__ = [ + "__title__", + "__summary__", + "__uri__", + "__version__", + "__author__", + "__email__", + "__license__", + "__copyright__", +] + +__title__ = "cryptography" +__summary__ = ( + "cryptography is a package which provides cryptographic recipes" + " and primitives to Python developers." +) +__uri__ = "https://github.com/pyca/cryptography" + +__version__ = "3.3.2" + +__author__ = "The cryptography developers" +__email__ = "cryptography-dev@python.org" + +__license__ = "BSD or Apache License, Version 2.0" +__copyright__ = "Copyright 2013-2021 {}".format(__author__) diff --git a/contrib/python/cryptography/py3/cryptography/__init__.py b/contrib/python/cryptography/py3/cryptography/__init__.py new file mode 100644 index 0000000000..0fcaef8370 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/__init__.py @@ -0,0 +1,32 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import sys +import warnings + +from cryptography.__about__ import ( + __author__, + __copyright__, + __email__, + __license__, + __summary__, + __title__, + __uri__, + __version__, +) +from cryptography.utils import CryptographyDeprecationWarning + + +__all__ = [ + "__title__", + "__summary__", + "__uri__", + "__version__", + "__author__", + "__email__", + "__license__", + "__copyright__", +] diff --git a/contrib/python/cryptography/py3/cryptography/exceptions.py b/contrib/python/cryptography/py3/cryptography/exceptions.py new file mode 100644 index 0000000000..1d52d7dcfc --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/exceptions.py @@ -0,0 +1,58 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from enum import Enum + + +class _Reasons(Enum): + BACKEND_MISSING_INTERFACE = 0 + UNSUPPORTED_HASH = 1 + UNSUPPORTED_CIPHER = 2 + UNSUPPORTED_PADDING = 3 + UNSUPPORTED_MGF = 4 + UNSUPPORTED_PUBLIC_KEY_ALGORITHM = 5 + UNSUPPORTED_ELLIPTIC_CURVE = 6 + UNSUPPORTED_SERIALIZATION = 7 + UNSUPPORTED_X509 = 8 + UNSUPPORTED_EXCHANGE_ALGORITHM = 9 + UNSUPPORTED_DIFFIE_HELLMAN = 10 + UNSUPPORTED_MAC = 11 + + +class UnsupportedAlgorithm(Exception): + def __init__(self, message, reason=None): + super(UnsupportedAlgorithm, self).__init__(message) + self._reason = reason + + +class AlreadyFinalized(Exception): + pass + + +class AlreadyUpdated(Exception): + pass + + +class NotYetFinalized(Exception): + pass + + +class InvalidTag(Exception): + pass + + +class InvalidSignature(Exception): + pass + + +class InternalError(Exception): + def __init__(self, msg, err_code): + super(InternalError, self).__init__(msg) + self.err_code = err_code + + +class InvalidKey(Exception): + pass diff --git a/contrib/python/cryptography/py3/cryptography/fernet.py b/contrib/python/cryptography/py3/cryptography/fernet.py new file mode 100644 index 0000000000..00c2528671 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/fernet.py @@ -0,0 +1,190 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import base64 +import binascii +import os +import struct +import time + +import six + +from cryptography import utils +from cryptography.exceptions import InvalidSignature +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.primitives import hashes, padding +from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes +from cryptography.hazmat.primitives.hmac import HMAC + + +class InvalidToken(Exception): + pass + + +_MAX_CLOCK_SKEW = 60 + + +class Fernet(object): + def __init__(self, key, backend=None): + backend = _get_backend(backend) + + key = base64.urlsafe_b64decode(key) + if len(key) != 32: + raise ValueError( + "Fernet key must be 32 url-safe base64-encoded bytes." + ) + + self._signing_key = key[:16] + self._encryption_key = key[16:] + self._backend = backend + + @classmethod + def generate_key(cls): + return base64.urlsafe_b64encode(os.urandom(32)) + + def encrypt(self, data): + return self.encrypt_at_time(data, int(time.time())) + + def encrypt_at_time(self, data, current_time): + iv = os.urandom(16) + return self._encrypt_from_parts(data, current_time, iv) + + def _encrypt_from_parts(self, data, current_time, iv): + utils._check_bytes("data", data) + + padder = padding.PKCS7(algorithms.AES.block_size).padder() + padded_data = padder.update(data) + padder.finalize() + encryptor = Cipher( + algorithms.AES(self._encryption_key), modes.CBC(iv), self._backend + ).encryptor() + ciphertext = encryptor.update(padded_data) + encryptor.finalize() + + basic_parts = ( + b"\x80" + struct.pack(">Q", current_time) + iv + ciphertext + ) + + h = HMAC(self._signing_key, hashes.SHA256(), backend=self._backend) + h.update(basic_parts) + hmac = h.finalize() + return base64.urlsafe_b64encode(basic_parts + hmac) + + def decrypt(self, token, ttl=None): + timestamp, data = Fernet._get_unverified_token_data(token) + return self._decrypt_data(data, timestamp, ttl, int(time.time())) + + def decrypt_at_time(self, token, ttl, current_time): + if ttl is None: + raise ValueError( + "decrypt_at_time() can only be used with a non-None ttl" + ) + timestamp, data = Fernet._get_unverified_token_data(token) + return self._decrypt_data(data, timestamp, ttl, current_time) + + def extract_timestamp(self, token): + timestamp, data = Fernet._get_unverified_token_data(token) + # Verify the token was not tampered with. + self._verify_signature(data) + return timestamp + + @staticmethod + def _get_unverified_token_data(token): + utils._check_bytes("token", token) + try: + data = base64.urlsafe_b64decode(token) + except (TypeError, binascii.Error): + raise InvalidToken + + if not data or six.indexbytes(data, 0) != 0x80: + raise InvalidToken + + try: + (timestamp,) = struct.unpack(">Q", data[1:9]) + except struct.error: + raise InvalidToken + return timestamp, data + + def _verify_signature(self, data): + h = HMAC(self._signing_key, hashes.SHA256(), backend=self._backend) + h.update(data[:-32]) + try: + h.verify(data[-32:]) + except InvalidSignature: + raise InvalidToken + + def _decrypt_data(self, data, timestamp, ttl, current_time): + if ttl is not None: + if timestamp + ttl < current_time: + raise InvalidToken + + if current_time + _MAX_CLOCK_SKEW < timestamp: + raise InvalidToken + + self._verify_signature(data) + + iv = data[9:25] + ciphertext = data[25:-32] + decryptor = Cipher( + algorithms.AES(self._encryption_key), modes.CBC(iv), self._backend + ).decryptor() + plaintext_padded = decryptor.update(ciphertext) + try: + plaintext_padded += decryptor.finalize() + except ValueError: + raise InvalidToken + unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder() + + unpadded = unpadder.update(plaintext_padded) + try: + unpadded += unpadder.finalize() + except ValueError: + raise InvalidToken + return unpadded + + +class MultiFernet(object): + def __init__(self, fernets): + fernets = list(fernets) + if not fernets: + raise ValueError( + "MultiFernet requires at least one Fernet instance" + ) + self._fernets = fernets + + def encrypt(self, msg): + return self.encrypt_at_time(msg, int(time.time())) + + def encrypt_at_time(self, msg, current_time): + return self._fernets[0].encrypt_at_time(msg, current_time) + + def rotate(self, msg): + timestamp, data = Fernet._get_unverified_token_data(msg) + for f in self._fernets: + try: + p = f._decrypt_data(data, timestamp, None, None) + break + except InvalidToken: + pass + else: + raise InvalidToken + + iv = os.urandom(16) + return self._fernets[0]._encrypt_from_parts(p, timestamp, iv) + + def decrypt(self, msg, ttl=None): + for f in self._fernets: + try: + return f.decrypt(msg, ttl) + except InvalidToken: + pass + raise InvalidToken + + def decrypt_at_time(self, msg, ttl, current_time): + for f in self._fernets: + try: + return f.decrypt_at_time(msg, ttl, current_time) + except InvalidToken: + pass + raise InvalidToken diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/__init__.py b/contrib/python/cryptography/py3/cryptography/hazmat/__init__.py new file mode 100644 index 0000000000..9f06a9949a --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/__init__.py @@ -0,0 +1,11 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. +""" +Hazardous Materials + +This is a "Hazardous Materials" module. You should ONLY use it if you're +100% absolutely sure that you know what you're doing because this module +is full of land mines, dragons, and dinosaurs with laser guns. +""" +from __future__ import absolute_import, division, print_function diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/_der.py b/contrib/python/cryptography/py3/cryptography/hazmat/_der.py new file mode 100644 index 0000000000..462b911b45 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/_der.py @@ -0,0 +1,156 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import six + +from cryptography.utils import int_from_bytes, int_to_bytes + + +# This module contains a lightweight DER encoder and decoder. See X.690 for the +# specification. This module intentionally does not implement the more complex +# BER encoding, only DER. +# +# Note this implementation treats an element's constructed bit as part of the +# tag. This is fine for DER, where the bit is always computable from the type. + + +CONSTRUCTED = 0x20 +CONTEXT_SPECIFIC = 0x80 + +INTEGER = 0x02 +BIT_STRING = 0x03 +OCTET_STRING = 0x04 +NULL = 0x05 +OBJECT_IDENTIFIER = 0x06 +SEQUENCE = 0x10 | CONSTRUCTED +SET = 0x11 | CONSTRUCTED +PRINTABLE_STRING = 0x13 +UTC_TIME = 0x17 +GENERALIZED_TIME = 0x18 + + +class DERReader(object): + def __init__(self, data): + self.data = memoryview(data) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, tb): + if exc_value is None: + self.check_empty() + + def is_empty(self): + return len(self.data) == 0 + + def check_empty(self): + if not self.is_empty(): + raise ValueError("Invalid DER input: trailing data") + + def read_byte(self): + if len(self.data) < 1: + raise ValueError("Invalid DER input: insufficient data") + ret = six.indexbytes(self.data, 0) + self.data = self.data[1:] + return ret + + def read_bytes(self, n): + if len(self.data) < n: + raise ValueError("Invalid DER input: insufficient data") + ret = self.data[:n] + self.data = self.data[n:] + return ret + + def read_any_element(self): + tag = self.read_byte() + # Tag numbers 31 or higher are stored in multiple bytes. No supported + # ASN.1 types use such tags, so reject these. + if tag & 0x1F == 0x1F: + raise ValueError("Invalid DER input: unexpected high tag number") + length_byte = self.read_byte() + if length_byte & 0x80 == 0: + # If the high bit is clear, the first length byte is the length. + length = length_byte + else: + # If the high bit is set, the first length byte encodes the length + # of the length. + length_byte &= 0x7F + if length_byte == 0: + raise ValueError( + "Invalid DER input: indefinite length form is not allowed " + "in DER" + ) + length = 0 + for i in range(length_byte): + length <<= 8 + length |= self.read_byte() + if length == 0: + raise ValueError( + "Invalid DER input: length was not minimally-encoded" + ) + if length < 0x80: + # If the length could have been encoded in short form, it must + # not use long form. + raise ValueError( + "Invalid DER input: length was not minimally-encoded" + ) + body = self.read_bytes(length) + return tag, DERReader(body) + + def read_element(self, expected_tag): + tag, body = self.read_any_element() + if tag != expected_tag: + raise ValueError("Invalid DER input: unexpected tag") + return body + + def read_single_element(self, expected_tag): + with self: + return self.read_element(expected_tag) + + def read_optional_element(self, expected_tag): + if len(self.data) > 0 and six.indexbytes(self.data, 0) == expected_tag: + return self.read_element(expected_tag) + return None + + def as_integer(self): + if len(self.data) == 0: + raise ValueError("Invalid DER input: empty integer contents") + first = six.indexbytes(self.data, 0) + if first & 0x80 == 0x80: + raise ValueError("Negative DER integers are not supported") + # The first 9 bits must not all be zero or all be ones. Otherwise, the + # encoding should have been one byte shorter. + if len(self.data) > 1: + second = six.indexbytes(self.data, 1) + if first == 0 and second & 0x80 == 0: + raise ValueError( + "Invalid DER input: integer not minimally-encoded" + ) + return int_from_bytes(self.data, "big") + + +def encode_der_integer(x): + if not isinstance(x, six.integer_types): + raise ValueError("Value must be an integer") + if x < 0: + raise ValueError("Negative integers are not supported") + n = x.bit_length() // 8 + 1 + return int_to_bytes(x, n) + + +def encode_der(tag, *children): + length = 0 + for child in children: + length += len(child) + chunks = [six.int2byte(tag)] + if length < 0x80: + chunks.append(six.int2byte(length)) + else: + length_bytes = int_to_bytes(length) + chunks.append(six.int2byte(0x80 | len(length_bytes))) + chunks.append(length_bytes) + chunks.extend(children) + return b"".join(chunks) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/_oid.py b/contrib/python/cryptography/py3/cryptography/hazmat/_oid.py new file mode 100644 index 0000000000..de2771a737 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/_oid.py @@ -0,0 +1,77 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils + + +class ObjectIdentifier(object): + def __init__(self, dotted_string): + self._dotted_string = dotted_string + + nodes = self._dotted_string.split(".") + intnodes = [] + + # There must be at least 2 nodes, the first node must be 0..2, and + # if less than 2, the second node cannot have a value outside the + # range 0..39. All nodes must be integers. + for node in nodes: + try: + node_value = int(node, 10) + except ValueError: + raise ValueError( + "Malformed OID: %s (non-integer nodes)" + % (self._dotted_string) + ) + if node_value < 0: + raise ValueError( + "Malformed OID: %s (negative-integer nodes)" + % (self._dotted_string) + ) + intnodes.append(node_value) + + if len(nodes) < 2: + raise ValueError( + "Malformed OID: %s (insufficient number of nodes)" + % (self._dotted_string) + ) + + if intnodes[0] > 2: + raise ValueError( + "Malformed OID: %s (first node outside valid range)" + % (self._dotted_string) + ) + + if intnodes[0] < 2 and intnodes[1] >= 40: + raise ValueError( + "Malformed OID: %s (second node outside valid range)" + % (self._dotted_string) + ) + + def __eq__(self, other): + if not isinstance(other, ObjectIdentifier): + return NotImplemented + + return self.dotted_string == other.dotted_string + + def __ne__(self, other): + return not self == other + + def __repr__(self): + return "<ObjectIdentifier(oid={}, name={})>".format( + self.dotted_string, self._name + ) + + def __hash__(self): + return hash(self.dotted_string) + + @property + def _name(self): + # Lazy import to avoid an import cycle + from cryptography.x509.oid import _OID_NAMES + + return _OID_NAMES.get(self, "Unknown OID") + + dotted_string = utils.read_only_property("_dotted_string") diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/__init__.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/__init__.py new file mode 100644 index 0000000000..1563936dde --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/__init__.py @@ -0,0 +1,26 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + + +_default_backend = None + + +def default_backend(): + global _default_backend + + if _default_backend is None: + from cryptography.hazmat.backends.openssl.backend import backend + + _default_backend = backend + + return _default_backend + + +def _get_backend(backend): + if backend is None: + return default_backend() + else: + return backend diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/interfaces.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/interfaces.py new file mode 100644 index 0000000000..418980a34e --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/interfaces.py @@ -0,0 +1,396 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + + +@six.add_metaclass(abc.ABCMeta) +class CipherBackend(object): + @abc.abstractmethod + def cipher_supported(self, cipher, mode): + """ + Return True if the given cipher and mode are supported. + """ + + @abc.abstractmethod + def create_symmetric_encryption_ctx(self, cipher, mode): + """ + Get a CipherContext that can be used for encryption. + """ + + @abc.abstractmethod + def create_symmetric_decryption_ctx(self, cipher, mode): + """ + Get a CipherContext that can be used for decryption. + """ + + +@six.add_metaclass(abc.ABCMeta) +class HashBackend(object): + @abc.abstractmethod + def hash_supported(self, algorithm): + """ + Return True if the hash algorithm is supported by this backend. + """ + + @abc.abstractmethod + def create_hash_ctx(self, algorithm): + """ + Create a HashContext for calculating a message digest. + """ + + +@six.add_metaclass(abc.ABCMeta) +class HMACBackend(object): + @abc.abstractmethod + def hmac_supported(self, algorithm): + """ + Return True if the hash algorithm is supported for HMAC by this + backend. + """ + + @abc.abstractmethod + def create_hmac_ctx(self, key, algorithm): + """ + Create a context for calculating a message authentication code. + """ + + +@six.add_metaclass(abc.ABCMeta) +class CMACBackend(object): + @abc.abstractmethod + def cmac_algorithm_supported(self, algorithm): + """ + Returns True if the block cipher is supported for CMAC by this backend + """ + + @abc.abstractmethod + def create_cmac_ctx(self, algorithm): + """ + Create a context for calculating a message authentication code. + """ + + +@six.add_metaclass(abc.ABCMeta) +class PBKDF2HMACBackend(object): + @abc.abstractmethod + def pbkdf2_hmac_supported(self, algorithm): + """ + Return True if the hash algorithm is supported for PBKDF2 by this + backend. + """ + + @abc.abstractmethod + def derive_pbkdf2_hmac( + self, algorithm, length, salt, iterations, key_material + ): + """ + Return length bytes derived from provided PBKDF2 parameters. + """ + + +@six.add_metaclass(abc.ABCMeta) +class RSABackend(object): + @abc.abstractmethod + def generate_rsa_private_key(self, public_exponent, key_size): + """ + Generate an RSAPrivateKey instance with public_exponent and a modulus + of key_size bits. + """ + + @abc.abstractmethod + def rsa_padding_supported(self, padding): + """ + Returns True if the backend supports the given padding options. + """ + + @abc.abstractmethod + def generate_rsa_parameters_supported(self, public_exponent, key_size): + """ + Returns True if the backend supports the given parameters for key + generation. + """ + + @abc.abstractmethod + def load_rsa_private_numbers(self, numbers): + """ + Returns an RSAPrivateKey provider. + """ + + @abc.abstractmethod + def load_rsa_public_numbers(self, numbers): + """ + Returns an RSAPublicKey provider. + """ + + +@six.add_metaclass(abc.ABCMeta) +class DSABackend(object): + @abc.abstractmethod + def generate_dsa_parameters(self, key_size): + """ + Generate a DSAParameters instance with a modulus of key_size bits. + """ + + @abc.abstractmethod + def generate_dsa_private_key(self, parameters): + """ + Generate a DSAPrivateKey instance with parameters as a DSAParameters + object. + """ + + @abc.abstractmethod + def generate_dsa_private_key_and_parameters(self, key_size): + """ + Generate a DSAPrivateKey instance using key size only. + """ + + @abc.abstractmethod + def dsa_hash_supported(self, algorithm): + """ + Return True if the hash algorithm is supported by the backend for DSA. + """ + + @abc.abstractmethod + def dsa_parameters_supported(self, p, q, g): + """ + Return True if the parameters are supported by the backend for DSA. + """ + + @abc.abstractmethod + def load_dsa_private_numbers(self, numbers): + """ + Returns a DSAPrivateKey provider. + """ + + @abc.abstractmethod + def load_dsa_public_numbers(self, numbers): + """ + Returns a DSAPublicKey provider. + """ + + @abc.abstractmethod + def load_dsa_parameter_numbers(self, numbers): + """ + Returns a DSAParameters provider. + """ + + +@six.add_metaclass(abc.ABCMeta) +class EllipticCurveBackend(object): + @abc.abstractmethod + def elliptic_curve_signature_algorithm_supported( + self, signature_algorithm, curve + ): + """ + Returns True if the backend supports the named elliptic curve with the + specified signature algorithm. + """ + + @abc.abstractmethod + def elliptic_curve_supported(self, curve): + """ + Returns True if the backend supports the named elliptic curve. + """ + + @abc.abstractmethod + def generate_elliptic_curve_private_key(self, curve): + """ + Return an object conforming to the EllipticCurvePrivateKey interface. + """ + + @abc.abstractmethod + def load_elliptic_curve_public_numbers(self, numbers): + """ + Return an EllipticCurvePublicKey provider using the given numbers. + """ + + @abc.abstractmethod + def load_elliptic_curve_private_numbers(self, numbers): + """ + Return an EllipticCurvePrivateKey provider using the given numbers. + """ + + @abc.abstractmethod + def elliptic_curve_exchange_algorithm_supported(self, algorithm, curve): + """ + Returns whether the exchange algorithm is supported by this backend. + """ + + @abc.abstractmethod + def derive_elliptic_curve_private_key(self, private_value, curve): + """ + Compute the private key given the private value and curve. + """ + + +@six.add_metaclass(abc.ABCMeta) +class PEMSerializationBackend(object): + @abc.abstractmethod + def load_pem_private_key(self, data, password): + """ + Loads a private key from PEM encoded data, using the provided password + if the data is encrypted. + """ + + @abc.abstractmethod + def load_pem_public_key(self, data): + """ + Loads a public key from PEM encoded data. + """ + + @abc.abstractmethod + def load_pem_parameters(self, data): + """ + Load encryption parameters from PEM encoded data. + """ + + +@six.add_metaclass(abc.ABCMeta) +class DERSerializationBackend(object): + @abc.abstractmethod + def load_der_private_key(self, data, password): + """ + Loads a private key from DER encoded data. Uses the provided password + if the data is encrypted. + """ + + @abc.abstractmethod + def load_der_public_key(self, data): + """ + Loads a public key from DER encoded data. + """ + + @abc.abstractmethod + def load_der_parameters(self, data): + """ + Load encryption parameters from DER encoded data. + """ + + +@six.add_metaclass(abc.ABCMeta) +class X509Backend(object): + @abc.abstractmethod + def load_pem_x509_certificate(self, data): + """ + Load an X.509 certificate from PEM encoded data. + """ + + @abc.abstractmethod + def load_der_x509_certificate(self, data): + """ + Load an X.509 certificate from DER encoded data. + """ + + @abc.abstractmethod + def load_der_x509_csr(self, data): + """ + Load an X.509 CSR from DER encoded data. + """ + + @abc.abstractmethod + def load_pem_x509_csr(self, data): + """ + Load an X.509 CSR from PEM encoded data. + """ + + @abc.abstractmethod + def create_x509_csr(self, builder, private_key, algorithm): + """ + Create and sign an X.509 CSR from a CSR builder object. + """ + + @abc.abstractmethod + def create_x509_certificate(self, builder, private_key, algorithm): + """ + Create and sign an X.509 certificate from a CertificateBuilder object. + """ + + @abc.abstractmethod + def create_x509_crl(self, builder, private_key, algorithm): + """ + Create and sign an X.509 CertificateRevocationList from a + CertificateRevocationListBuilder object. + """ + + @abc.abstractmethod + def create_x509_revoked_certificate(self, builder): + """ + Create a RevokedCertificate object from a RevokedCertificateBuilder + object. + """ + + @abc.abstractmethod + def x509_name_bytes(self, name): + """ + Compute the DER encoded bytes of an X509 Name object. + """ + + +@six.add_metaclass(abc.ABCMeta) +class DHBackend(object): + @abc.abstractmethod + def generate_dh_parameters(self, generator, key_size): + """ + Generate a DHParameters instance with a modulus of key_size bits. + Using the given generator. Often 2 or 5. + """ + + @abc.abstractmethod + def generate_dh_private_key(self, parameters): + """ + Generate a DHPrivateKey instance with parameters as a DHParameters + object. + """ + + @abc.abstractmethod + def generate_dh_private_key_and_parameters(self, generator, key_size): + """ + Generate a DHPrivateKey instance using key size only. + Using the given generator. Often 2 or 5. + """ + + @abc.abstractmethod + def load_dh_private_numbers(self, numbers): + """ + Load a DHPrivateKey from DHPrivateNumbers + """ + + @abc.abstractmethod + def load_dh_public_numbers(self, numbers): + """ + Load a DHPublicKey from DHPublicNumbers. + """ + + @abc.abstractmethod + def load_dh_parameter_numbers(self, numbers): + """ + Load DHParameters from DHParameterNumbers. + """ + + @abc.abstractmethod + def dh_parameters_supported(self, p, g, q=None): + """ + Returns whether the backend supports DH with these parameter values. + """ + + @abc.abstractmethod + def dh_x942_serialization_supported(self): + """ + Returns True if the backend supports the serialization of DH objects + with subgroup order (q). + """ + + +@six.add_metaclass(abc.ABCMeta) +class ScryptBackend(object): + @abc.abstractmethod + def derive_scrypt(self, key_material, salt, length, n, r, p): + """ + Return bytes derived from provided Scrypt parameters. + """ diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/__init__.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/__init__.py new file mode 100644 index 0000000000..8eadeb6e18 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/__init__.py @@ -0,0 +1,10 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography.hazmat.backends.openssl.backend import backend + + +__all__ = ["backend"] diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/aead.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/aead.py new file mode 100644 index 0000000000..4494916852 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/aead.py @@ -0,0 +1,166 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography.exceptions import InvalidTag + + +_ENCRYPT = 1 +_DECRYPT = 0 + + +def _aead_cipher_name(cipher): + from cryptography.hazmat.primitives.ciphers.aead import ( + AESCCM, + AESGCM, + ChaCha20Poly1305, + ) + + if isinstance(cipher, ChaCha20Poly1305): + return b"chacha20-poly1305" + elif isinstance(cipher, AESCCM): + return "aes-{}-ccm".format(len(cipher._key) * 8).encode("ascii") + else: + assert isinstance(cipher, AESGCM) + return "aes-{}-gcm".format(len(cipher._key) * 8).encode("ascii") + + +def _aead_setup(backend, cipher_name, key, nonce, tag, tag_len, operation): + evp_cipher = backend._lib.EVP_get_cipherbyname(cipher_name) + backend.openssl_assert(evp_cipher != backend._ffi.NULL) + ctx = backend._lib.EVP_CIPHER_CTX_new() + ctx = backend._ffi.gc(ctx, backend._lib.EVP_CIPHER_CTX_free) + res = backend._lib.EVP_CipherInit_ex( + ctx, + evp_cipher, + backend._ffi.NULL, + backend._ffi.NULL, + backend._ffi.NULL, + int(operation == _ENCRYPT), + ) + backend.openssl_assert(res != 0) + res = backend._lib.EVP_CIPHER_CTX_set_key_length(ctx, len(key)) + backend.openssl_assert(res != 0) + res = backend._lib.EVP_CIPHER_CTX_ctrl( + ctx, + backend._lib.EVP_CTRL_AEAD_SET_IVLEN, + len(nonce), + backend._ffi.NULL, + ) + backend.openssl_assert(res != 0) + if operation == _DECRYPT: + res = backend._lib.EVP_CIPHER_CTX_ctrl( + ctx, backend._lib.EVP_CTRL_AEAD_SET_TAG, len(tag), tag + ) + backend.openssl_assert(res != 0) + elif cipher_name.endswith(b"-ccm"): + res = backend._lib.EVP_CIPHER_CTX_ctrl( + ctx, backend._lib.EVP_CTRL_AEAD_SET_TAG, tag_len, backend._ffi.NULL + ) + backend.openssl_assert(res != 0) + + nonce_ptr = backend._ffi.from_buffer(nonce) + key_ptr = backend._ffi.from_buffer(key) + res = backend._lib.EVP_CipherInit_ex( + ctx, + backend._ffi.NULL, + backend._ffi.NULL, + key_ptr, + nonce_ptr, + int(operation == _ENCRYPT), + ) + backend.openssl_assert(res != 0) + return ctx + + +def _set_length(backend, ctx, data_len): + intptr = backend._ffi.new("int *") + res = backend._lib.EVP_CipherUpdate( + ctx, backend._ffi.NULL, intptr, backend._ffi.NULL, data_len + ) + backend.openssl_assert(res != 0) + + +def _process_aad(backend, ctx, associated_data): + outlen = backend._ffi.new("int *") + res = backend._lib.EVP_CipherUpdate( + ctx, backend._ffi.NULL, outlen, associated_data, len(associated_data) + ) + backend.openssl_assert(res != 0) + + +def _process_data(backend, ctx, data): + outlen = backend._ffi.new("int *") + buf = backend._ffi.new("unsigned char[]", len(data)) + res = backend._lib.EVP_CipherUpdate(ctx, buf, outlen, data, len(data)) + backend.openssl_assert(res != 0) + return backend._ffi.buffer(buf, outlen[0])[:] + + +def _encrypt(backend, cipher, nonce, data, associated_data, tag_length): + from cryptography.hazmat.primitives.ciphers.aead import AESCCM + + cipher_name = _aead_cipher_name(cipher) + ctx = _aead_setup( + backend, cipher_name, cipher._key, nonce, None, tag_length, _ENCRYPT + ) + # CCM requires us to pass the length of the data before processing anything + # However calling this with any other AEAD results in an error + if isinstance(cipher, AESCCM): + _set_length(backend, ctx, len(data)) + + _process_aad(backend, ctx, associated_data) + processed_data = _process_data(backend, ctx, data) + outlen = backend._ffi.new("int *") + res = backend._lib.EVP_CipherFinal_ex(ctx, backend._ffi.NULL, outlen) + backend.openssl_assert(res != 0) + backend.openssl_assert(outlen[0] == 0) + tag_buf = backend._ffi.new("unsigned char[]", tag_length) + res = backend._lib.EVP_CIPHER_CTX_ctrl( + ctx, backend._lib.EVP_CTRL_AEAD_GET_TAG, tag_length, tag_buf + ) + backend.openssl_assert(res != 0) + tag = backend._ffi.buffer(tag_buf)[:] + + return processed_data + tag + + +def _decrypt(backend, cipher, nonce, data, associated_data, tag_length): + from cryptography.hazmat.primitives.ciphers.aead import AESCCM + + if len(data) < tag_length: + raise InvalidTag + tag = data[-tag_length:] + data = data[:-tag_length] + cipher_name = _aead_cipher_name(cipher) + ctx = _aead_setup( + backend, cipher_name, cipher._key, nonce, tag, tag_length, _DECRYPT + ) + # CCM requires us to pass the length of the data before processing anything + # However calling this with any other AEAD results in an error + if isinstance(cipher, AESCCM): + _set_length(backend, ctx, len(data)) + + _process_aad(backend, ctx, associated_data) + # CCM has a different error path if the tag doesn't match. Errors are + # raised in Update and Final is irrelevant. + if isinstance(cipher, AESCCM): + outlen = backend._ffi.new("int *") + buf = backend._ffi.new("unsigned char[]", len(data)) + res = backend._lib.EVP_CipherUpdate(ctx, buf, outlen, data, len(data)) + if res != 1: + backend._consume_errors() + raise InvalidTag + + processed_data = backend._ffi.buffer(buf, outlen[0])[:] + else: + processed_data = _process_data(backend, ctx, data) + outlen = backend._ffi.new("int *") + res = backend._lib.EVP_CipherFinal_ex(ctx, backend._ffi.NULL, outlen) + if res == 0: + backend._consume_errors() + raise InvalidTag + + return processed_data diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/backend.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/backend.py new file mode 100644 index 0000000000..45d4a1a1ee --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/backend.py @@ -0,0 +1,2776 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import collections +import contextlib +import itertools +import warnings +from contextlib import contextmanager + +import six +from six.moves import range + +from cryptography import utils, x509 +from cryptography.exceptions import UnsupportedAlgorithm, _Reasons +from cryptography.hazmat._der import ( + INTEGER, + NULL, + SEQUENCE, + encode_der, + encode_der_integer, +) +from cryptography.hazmat.backends.interfaces import ( + CMACBackend, + CipherBackend, + DERSerializationBackend, + DHBackend, + DSABackend, + EllipticCurveBackend, + HMACBackend, + HashBackend, + PBKDF2HMACBackend, + PEMSerializationBackend, + RSABackend, + ScryptBackend, + X509Backend, +) +from cryptography.hazmat.backends.openssl import aead +from cryptography.hazmat.backends.openssl.ciphers import _CipherContext +from cryptography.hazmat.backends.openssl.cmac import _CMACContext +from cryptography.hazmat.backends.openssl.decode_asn1 import ( + _CRL_ENTRY_REASON_ENUM_TO_CODE, + _CRL_EXTENSION_HANDLERS, + _EXTENSION_HANDLERS_BASE, + _EXTENSION_HANDLERS_SCT, + _OCSP_BASICRESP_EXTENSION_HANDLERS, + _OCSP_REQ_EXTENSION_HANDLERS, + _OCSP_SINGLERESP_EXTENSION_HANDLERS_SCT, + _REVOKED_EXTENSION_HANDLERS, + _X509ExtensionParser, +) +from cryptography.hazmat.backends.openssl.dh import ( + _DHParameters, + _DHPrivateKey, + _DHPublicKey, + _dh_params_dup, +) +from cryptography.hazmat.backends.openssl.dsa import ( + _DSAParameters, + _DSAPrivateKey, + _DSAPublicKey, +) +from cryptography.hazmat.backends.openssl.ec import ( + _EllipticCurvePrivateKey, + _EllipticCurvePublicKey, +) +from cryptography.hazmat.backends.openssl.ed25519 import ( + _Ed25519PrivateKey, + _Ed25519PublicKey, +) +from cryptography.hazmat.backends.openssl.ed448 import ( + _ED448_KEY_SIZE, + _Ed448PrivateKey, + _Ed448PublicKey, +) +from cryptography.hazmat.backends.openssl.encode_asn1 import ( + _CRL_ENTRY_EXTENSION_ENCODE_HANDLERS, + _CRL_EXTENSION_ENCODE_HANDLERS, + _EXTENSION_ENCODE_HANDLERS, + _OCSP_BASICRESP_EXTENSION_ENCODE_HANDLERS, + _OCSP_REQUEST_EXTENSION_ENCODE_HANDLERS, + _encode_asn1_int_gc, + _encode_asn1_str_gc, + _encode_name_gc, + _txt2obj_gc, +) +from cryptography.hazmat.backends.openssl.hashes import _HashContext +from cryptography.hazmat.backends.openssl.hmac import _HMACContext +from cryptography.hazmat.backends.openssl.ocsp import ( + _OCSPRequest, + _OCSPResponse, +) +from cryptography.hazmat.backends.openssl.poly1305 import ( + _POLY1305_KEY_SIZE, + _Poly1305Context, +) +from cryptography.hazmat.backends.openssl.rsa import ( + _RSAPrivateKey, + _RSAPublicKey, +) +from cryptography.hazmat.backends.openssl.x25519 import ( + _X25519PrivateKey, + _X25519PublicKey, +) +from cryptography.hazmat.backends.openssl.x448 import ( + _X448PrivateKey, + _X448PublicKey, +) +from cryptography.hazmat.backends.openssl.x509 import ( + _Certificate, + _CertificateRevocationList, + _CertificateSigningRequest, + _RevokedCertificate, +) +from cryptography.hazmat.bindings.openssl import binding +from cryptography.hazmat.primitives import hashes, serialization +from cryptography.hazmat.primitives.asymmetric import ( + dh, + dsa, + ec, + ed25519, + ed448, + rsa, +) +from cryptography.hazmat.primitives.asymmetric.padding import ( + MGF1, + OAEP, + PKCS1v15, + PSS, +) +from cryptography.hazmat.primitives.ciphers.algorithms import ( + AES, + ARC4, + Blowfish, + CAST5, + Camellia, + ChaCha20, + IDEA, + SEED, + TripleDES, +) +from cryptography.hazmat.primitives.ciphers.modes import ( + CBC, + CFB, + CFB8, + CTR, + ECB, + GCM, + OFB, + XTS, +) +from cryptography.hazmat.primitives.kdf import scrypt +from cryptography.hazmat.primitives.serialization import pkcs7, ssh +from cryptography.x509 import ocsp + + +_MemoryBIO = collections.namedtuple("_MemoryBIO", ["bio", "char_ptr"]) + + +# Not actually supported, just used as a marker for some serialization tests. +class _RC2(object): + pass + + +@utils.register_interface(CipherBackend) +@utils.register_interface(CMACBackend) +@utils.register_interface(DERSerializationBackend) +@utils.register_interface(DHBackend) +@utils.register_interface(DSABackend) +@utils.register_interface(EllipticCurveBackend) +@utils.register_interface(HashBackend) +@utils.register_interface(HMACBackend) +@utils.register_interface(PBKDF2HMACBackend) +@utils.register_interface(RSABackend) +@utils.register_interface(PEMSerializationBackend) +@utils.register_interface(X509Backend) +@utils.register_interface_if( + binding.Binding().lib.Cryptography_HAS_SCRYPT, ScryptBackend +) +class Backend(object): + """ + OpenSSL API binding interfaces. + """ + + name = "openssl" + + # FIPS has opinions about acceptable algorithms and key sizes, but the + # disallowed algorithms are still present in OpenSSL. They just error if + # you try to use them. To avoid that we allowlist the algorithms in + # FIPS 140-3. This isn't ideal, but FIPS 140-3 is trash so here we are. + _fips_aead = { + b"aes-128-ccm", + b"aes-192-ccm", + b"aes-256-ccm", + b"aes-128-gcm", + b"aes-192-gcm", + b"aes-256-gcm", + } + _fips_ciphers = (AES, TripleDES) + _fips_hashes = ( + hashes.SHA1, + hashes.SHA224, + hashes.SHA256, + hashes.SHA384, + hashes.SHA512, + hashes.SHA512_224, + hashes.SHA512_256, + hashes.SHA3_224, + hashes.SHA3_256, + hashes.SHA3_384, + hashes.SHA3_512, + hashes.SHAKE128, + hashes.SHAKE256, + ) + _fips_rsa_min_key_size = 2048 + _fips_rsa_min_public_exponent = 65537 + _fips_dsa_min_modulus = 1 << 2048 + _fips_dh_min_key_size = 2048 + _fips_dh_min_modulus = 1 << _fips_dh_min_key_size + + def __init__(self): + self._binding = binding.Binding() + self._ffi = self._binding.ffi + self._lib = self._binding.lib + self._fips_enabled = self._is_fips_enabled() + + self._cipher_registry = {} + self._register_default_ciphers() + self._register_x509_ext_parsers() + self._register_x509_encoders() + if self._fips_enabled and self._lib.CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE: + warnings.warn( + "OpenSSL FIPS mode is enabled. Can't enable DRBG fork safety.", + UserWarning, + ) + else: + self.activate_osrandom_engine() + self._dh_types = [self._lib.EVP_PKEY_DH] + if self._lib.Cryptography_HAS_EVP_PKEY_DHX: + self._dh_types.append(self._lib.EVP_PKEY_DHX) + + def openssl_assert(self, ok, errors=None): + return binding._openssl_assert(self._lib, ok, errors=errors) + + def _is_fips_enabled(self): + fips_mode = getattr(self._lib, "FIPS_mode", lambda: 0) + mode = fips_mode() + if mode == 0: + # OpenSSL without FIPS pushes an error on the error stack + self._lib.ERR_clear_error() + return bool(mode) + + def activate_builtin_random(self): + if self._lib.CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE: + # Obtain a new structural reference. + e = self._lib.ENGINE_get_default_RAND() + if e != self._ffi.NULL: + self._lib.ENGINE_unregister_RAND(e) + # Reset the RNG to use the built-in. + res = self._lib.RAND_set_rand_method(self._ffi.NULL) + self.openssl_assert(res == 1) + # decrement the structural reference from get_default_RAND + res = self._lib.ENGINE_finish(e) + self.openssl_assert(res == 1) + + @contextlib.contextmanager + def _get_osurandom_engine(self): + # Fetches an engine by id and returns it. This creates a structural + # reference. + e = self._lib.ENGINE_by_id(self._lib.Cryptography_osrandom_engine_id) + self.openssl_assert(e != self._ffi.NULL) + # Initialize the engine for use. This adds a functional reference. + res = self._lib.ENGINE_init(e) + self.openssl_assert(res == 1) + + try: + yield e + finally: + # Decrement the structural ref incremented by ENGINE_by_id. + res = self._lib.ENGINE_free(e) + self.openssl_assert(res == 1) + # Decrement the functional ref incremented by ENGINE_init. + res = self._lib.ENGINE_finish(e) + self.openssl_assert(res == 1) + + def activate_osrandom_engine(self): + if self._lib.CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE: + # Unregister and free the current engine. + self.activate_builtin_random() + with self._get_osurandom_engine() as e: + # Set the engine as the default RAND provider. + res = self._lib.ENGINE_set_default_RAND(e) + self.openssl_assert(res == 1) + # Reset the RNG to use the engine + res = self._lib.RAND_set_rand_method(self._ffi.NULL) + self.openssl_assert(res == 1) + + def osrandom_engine_implementation(self): + buf = self._ffi.new("char[]", 64) + with self._get_osurandom_engine() as e: + res = self._lib.ENGINE_ctrl_cmd( + e, b"get_implementation", len(buf), buf, self._ffi.NULL, 0 + ) + self.openssl_assert(res > 0) + return self._ffi.string(buf).decode("ascii") + + def openssl_version_text(self): + """ + Friendly string name of the loaded OpenSSL library. This is not + necessarily the same version as it was compiled against. + + Example: OpenSSL 1.1.1d 10 Sep 2019 + """ + return self._ffi.string( + self._lib.OpenSSL_version(self._lib.OPENSSL_VERSION) + ).decode("ascii") + + def openssl_version_number(self): + return self._lib.OpenSSL_version_num() + + def create_hmac_ctx(self, key, algorithm): + return _HMACContext(self, key, algorithm) + + def _evp_md_from_algorithm(self, algorithm): + if algorithm.name == "blake2b" or algorithm.name == "blake2s": + alg = "{}{}".format( + algorithm.name, algorithm.digest_size * 8 + ).encode("ascii") + else: + alg = algorithm.name.encode("ascii") + + evp_md = self._lib.EVP_get_digestbyname(alg) + return evp_md + + def _evp_md_non_null_from_algorithm(self, algorithm): + evp_md = self._evp_md_from_algorithm(algorithm) + self.openssl_assert(evp_md != self._ffi.NULL) + return evp_md + + def hash_supported(self, algorithm): + if self._fips_enabled and not isinstance(algorithm, self._fips_hashes): + return False + + evp_md = self._evp_md_from_algorithm(algorithm) + return evp_md != self._ffi.NULL + + def hmac_supported(self, algorithm): + return self.hash_supported(algorithm) + + def create_hash_ctx(self, algorithm): + return _HashContext(self, algorithm) + + def cipher_supported(self, cipher, mode): + if self._fips_enabled and not isinstance(cipher, self._fips_ciphers): + return False + try: + adapter = self._cipher_registry[type(cipher), type(mode)] + except KeyError: + return False + evp_cipher = adapter(self, cipher, mode) + return self._ffi.NULL != evp_cipher + + def register_cipher_adapter(self, cipher_cls, mode_cls, adapter): + if (cipher_cls, mode_cls) in self._cipher_registry: + raise ValueError( + "Duplicate registration for: {} {}.".format( + cipher_cls, mode_cls + ) + ) + self._cipher_registry[cipher_cls, mode_cls] = adapter + + def _register_default_ciphers(self): + for mode_cls in [CBC, CTR, ECB, OFB, CFB, CFB8, GCM]: + self.register_cipher_adapter( + AES, + mode_cls, + GetCipherByName("{cipher.name}-{cipher.key_size}-{mode.name}"), + ) + for mode_cls in [CBC, CTR, ECB, OFB, CFB]: + self.register_cipher_adapter( + Camellia, + mode_cls, + GetCipherByName("{cipher.name}-{cipher.key_size}-{mode.name}"), + ) + for mode_cls in [CBC, CFB, CFB8, OFB]: + self.register_cipher_adapter( + TripleDES, mode_cls, GetCipherByName("des-ede3-{mode.name}") + ) + self.register_cipher_adapter( + TripleDES, ECB, GetCipherByName("des-ede3") + ) + for mode_cls in [CBC, CFB, OFB, ECB]: + self.register_cipher_adapter( + Blowfish, mode_cls, GetCipherByName("bf-{mode.name}") + ) + for mode_cls in [CBC, CFB, OFB, ECB]: + self.register_cipher_adapter( + SEED, mode_cls, GetCipherByName("seed-{mode.name}") + ) + for cipher_cls, mode_cls in itertools.product( + [CAST5, IDEA], + [CBC, OFB, CFB, ECB], + ): + self.register_cipher_adapter( + cipher_cls, + mode_cls, + GetCipherByName("{cipher.name}-{mode.name}"), + ) + self.register_cipher_adapter(ARC4, type(None), GetCipherByName("rc4")) + # We don't actually support RC2, this is just used by some tests. + self.register_cipher_adapter(_RC2, type(None), GetCipherByName("rc2")) + self.register_cipher_adapter( + ChaCha20, type(None), GetCipherByName("chacha20") + ) + self.register_cipher_adapter(AES, XTS, _get_xts_cipher) + + def _register_x509_ext_parsers(self): + ext_handlers = _EXTENSION_HANDLERS_BASE.copy() + # All revoked extensions are valid single response extensions, see: + # https://tools.ietf.org/html/rfc6960#section-4.4.5 + singleresp_handlers = _REVOKED_EXTENSION_HANDLERS.copy() + + if self._lib.Cryptography_HAS_SCT: + ext_handlers.update(_EXTENSION_HANDLERS_SCT) + singleresp_handlers.update(_OCSP_SINGLERESP_EXTENSION_HANDLERS_SCT) + + self._certificate_extension_parser = _X509ExtensionParser( + self, + ext_count=self._lib.X509_get_ext_count, + get_ext=self._lib.X509_get_ext, + handlers=ext_handlers, + ) + self._csr_extension_parser = _X509ExtensionParser( + self, + ext_count=self._lib.sk_X509_EXTENSION_num, + get_ext=self._lib.sk_X509_EXTENSION_value, + handlers=ext_handlers, + ) + self._revoked_cert_extension_parser = _X509ExtensionParser( + self, + ext_count=self._lib.X509_REVOKED_get_ext_count, + get_ext=self._lib.X509_REVOKED_get_ext, + handlers=_REVOKED_EXTENSION_HANDLERS, + ) + self._crl_extension_parser = _X509ExtensionParser( + self, + ext_count=self._lib.X509_CRL_get_ext_count, + get_ext=self._lib.X509_CRL_get_ext, + handlers=_CRL_EXTENSION_HANDLERS, + ) + self._ocsp_req_ext_parser = _X509ExtensionParser( + self, + ext_count=self._lib.OCSP_REQUEST_get_ext_count, + get_ext=self._lib.OCSP_REQUEST_get_ext, + handlers=_OCSP_REQ_EXTENSION_HANDLERS, + ) + self._ocsp_basicresp_ext_parser = _X509ExtensionParser( + self, + ext_count=self._lib.OCSP_BASICRESP_get_ext_count, + get_ext=self._lib.OCSP_BASICRESP_get_ext, + handlers=_OCSP_BASICRESP_EXTENSION_HANDLERS, + ) + self._ocsp_singleresp_ext_parser = _X509ExtensionParser( + self, + ext_count=self._lib.OCSP_SINGLERESP_get_ext_count, + get_ext=self._lib.OCSP_SINGLERESP_get_ext, + handlers=singleresp_handlers, + ) + + def _register_x509_encoders(self): + self._extension_encode_handlers = _EXTENSION_ENCODE_HANDLERS.copy() + self._crl_extension_encode_handlers = ( + _CRL_EXTENSION_ENCODE_HANDLERS.copy() + ) + self._crl_entry_extension_encode_handlers = ( + _CRL_ENTRY_EXTENSION_ENCODE_HANDLERS.copy() + ) + self._ocsp_request_extension_encode_handlers = ( + _OCSP_REQUEST_EXTENSION_ENCODE_HANDLERS.copy() + ) + self._ocsp_basicresp_extension_encode_handlers = ( + _OCSP_BASICRESP_EXTENSION_ENCODE_HANDLERS.copy() + ) + + def create_symmetric_encryption_ctx(self, cipher, mode): + return _CipherContext(self, cipher, mode, _CipherContext._ENCRYPT) + + def create_symmetric_decryption_ctx(self, cipher, mode): + return _CipherContext(self, cipher, mode, _CipherContext._DECRYPT) + + def pbkdf2_hmac_supported(self, algorithm): + return self.hmac_supported(algorithm) + + def derive_pbkdf2_hmac( + self, algorithm, length, salt, iterations, key_material + ): + buf = self._ffi.new("unsigned char[]", length) + evp_md = self._evp_md_non_null_from_algorithm(algorithm) + key_material_ptr = self._ffi.from_buffer(key_material) + res = self._lib.PKCS5_PBKDF2_HMAC( + key_material_ptr, + len(key_material), + salt, + len(salt), + iterations, + evp_md, + length, + buf, + ) + self.openssl_assert(res == 1) + return self._ffi.buffer(buf)[:] + + def _consume_errors(self): + return binding._consume_errors(self._lib) + + def _consume_errors_with_text(self): + return binding._consume_errors_with_text(self._lib) + + def _bn_to_int(self, bn): + assert bn != self._ffi.NULL + + if not six.PY2: + # Python 3 has constant time from_bytes, so use that. + bn_num_bytes = self._lib.BN_num_bytes(bn) + bin_ptr = self._ffi.new("unsigned char[]", bn_num_bytes) + bin_len = self._lib.BN_bn2bin(bn, bin_ptr) + # A zero length means the BN has value 0 + self.openssl_assert(bin_len >= 0) + val = int.from_bytes(self._ffi.buffer(bin_ptr)[:bin_len], "big") + if self._lib.BN_is_negative(bn): + val = -val + return val + else: + # Under Python 2 the best we can do is hex() + hex_cdata = self._lib.BN_bn2hex(bn) + self.openssl_assert(hex_cdata != self._ffi.NULL) + hex_str = self._ffi.string(hex_cdata) + self._lib.OPENSSL_free(hex_cdata) + return int(hex_str, 16) + + def _int_to_bn(self, num, bn=None): + """ + Converts a python integer to a BIGNUM. The returned BIGNUM will not + be garbage collected (to support adding them to structs that take + ownership of the object). Be sure to register it for GC if it will + be discarded after use. + """ + assert bn is None or bn != self._ffi.NULL + + if bn is None: + bn = self._ffi.NULL + + if not six.PY2: + # Python 3 has constant time to_bytes, so use that. + + binary = num.to_bytes(int(num.bit_length() / 8.0 + 1), "big") + bn_ptr = self._lib.BN_bin2bn(binary, len(binary), bn) + self.openssl_assert(bn_ptr != self._ffi.NULL) + return bn_ptr + + else: + # Under Python 2 the best we can do is hex(), [2:] removes the 0x + # prefix. + hex_num = hex(num).rstrip("L")[2:].encode("ascii") + bn_ptr = self._ffi.new("BIGNUM **") + bn_ptr[0] = bn + res = self._lib.BN_hex2bn(bn_ptr, hex_num) + self.openssl_assert(res != 0) + self.openssl_assert(bn_ptr[0] != self._ffi.NULL) + return bn_ptr[0] + + def generate_rsa_private_key(self, public_exponent, key_size): + rsa._verify_rsa_parameters(public_exponent, key_size) + + rsa_cdata = self._lib.RSA_new() + self.openssl_assert(rsa_cdata != self._ffi.NULL) + rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free) + + bn = self._int_to_bn(public_exponent) + bn = self._ffi.gc(bn, self._lib.BN_free) + + res = self._lib.RSA_generate_key_ex( + rsa_cdata, key_size, bn, self._ffi.NULL + ) + self.openssl_assert(res == 1) + evp_pkey = self._rsa_cdata_to_evp_pkey(rsa_cdata) + + return _RSAPrivateKey(self, rsa_cdata, evp_pkey) + + def generate_rsa_parameters_supported(self, public_exponent, key_size): + return ( + public_exponent >= 3 + and public_exponent & 1 != 0 + and key_size >= 512 + ) + + def load_rsa_private_numbers(self, numbers): + rsa._check_private_key_components( + numbers.p, + numbers.q, + numbers.d, + numbers.dmp1, + numbers.dmq1, + numbers.iqmp, + numbers.public_numbers.e, + numbers.public_numbers.n, + ) + rsa_cdata = self._lib.RSA_new() + self.openssl_assert(rsa_cdata != self._ffi.NULL) + rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free) + p = self._int_to_bn(numbers.p) + q = self._int_to_bn(numbers.q) + d = self._int_to_bn(numbers.d) + dmp1 = self._int_to_bn(numbers.dmp1) + dmq1 = self._int_to_bn(numbers.dmq1) + iqmp = self._int_to_bn(numbers.iqmp) + e = self._int_to_bn(numbers.public_numbers.e) + n = self._int_to_bn(numbers.public_numbers.n) + res = self._lib.RSA_set0_factors(rsa_cdata, p, q) + self.openssl_assert(res == 1) + res = self._lib.RSA_set0_key(rsa_cdata, n, e, d) + self.openssl_assert(res == 1) + res = self._lib.RSA_set0_crt_params(rsa_cdata, dmp1, dmq1, iqmp) + self.openssl_assert(res == 1) + evp_pkey = self._rsa_cdata_to_evp_pkey(rsa_cdata) + + return _RSAPrivateKey(self, rsa_cdata, evp_pkey) + + def load_rsa_public_numbers(self, numbers): + rsa._check_public_key_components(numbers.e, numbers.n) + rsa_cdata = self._lib.RSA_new() + self.openssl_assert(rsa_cdata != self._ffi.NULL) + rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free) + e = self._int_to_bn(numbers.e) + n = self._int_to_bn(numbers.n) + res = self._lib.RSA_set0_key(rsa_cdata, n, e, self._ffi.NULL) + self.openssl_assert(res == 1) + evp_pkey = self._rsa_cdata_to_evp_pkey(rsa_cdata) + + return _RSAPublicKey(self, rsa_cdata, evp_pkey) + + def _create_evp_pkey_gc(self): + evp_pkey = self._lib.EVP_PKEY_new() + self.openssl_assert(evp_pkey != self._ffi.NULL) + evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free) + return evp_pkey + + def _rsa_cdata_to_evp_pkey(self, rsa_cdata): + evp_pkey = self._create_evp_pkey_gc() + res = self._lib.EVP_PKEY_set1_RSA(evp_pkey, rsa_cdata) + self.openssl_assert(res == 1) + return evp_pkey + + def _bytes_to_bio(self, data): + """ + Return a _MemoryBIO namedtuple of (BIO, char*). + + The char* is the storage for the BIO and it must stay alive until the + BIO is finished with. + """ + data_ptr = self._ffi.from_buffer(data) + bio = self._lib.BIO_new_mem_buf(data_ptr, len(data)) + self.openssl_assert(bio != self._ffi.NULL) + + return _MemoryBIO(self._ffi.gc(bio, self._lib.BIO_free), data_ptr) + + def _create_mem_bio_gc(self): + """ + Creates an empty memory BIO. + """ + bio_method = self._lib.BIO_s_mem() + self.openssl_assert(bio_method != self._ffi.NULL) + bio = self._lib.BIO_new(bio_method) + self.openssl_assert(bio != self._ffi.NULL) + bio = self._ffi.gc(bio, self._lib.BIO_free) + return bio + + def _read_mem_bio(self, bio): + """ + Reads a memory BIO. This only works on memory BIOs. + """ + buf = self._ffi.new("char **") + buf_len = self._lib.BIO_get_mem_data(bio, buf) + self.openssl_assert(buf_len > 0) + self.openssl_assert(buf[0] != self._ffi.NULL) + bio_data = self._ffi.buffer(buf[0], buf_len)[:] + return bio_data + + def _evp_pkey_to_private_key(self, evp_pkey): + """ + Return the appropriate type of PrivateKey given an evp_pkey cdata + pointer. + """ + + key_type = self._lib.EVP_PKEY_id(evp_pkey) + + if key_type == self._lib.EVP_PKEY_RSA: + rsa_cdata = self._lib.EVP_PKEY_get1_RSA(evp_pkey) + self.openssl_assert(rsa_cdata != self._ffi.NULL) + rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free) + return _RSAPrivateKey(self, rsa_cdata, evp_pkey) + elif key_type == self._lib.EVP_PKEY_DSA: + dsa_cdata = self._lib.EVP_PKEY_get1_DSA(evp_pkey) + self.openssl_assert(dsa_cdata != self._ffi.NULL) + dsa_cdata = self._ffi.gc(dsa_cdata, self._lib.DSA_free) + return _DSAPrivateKey(self, dsa_cdata, evp_pkey) + elif key_type == self._lib.EVP_PKEY_EC: + ec_cdata = self._lib.EVP_PKEY_get1_EC_KEY(evp_pkey) + self.openssl_assert(ec_cdata != self._ffi.NULL) + ec_cdata = self._ffi.gc(ec_cdata, self._lib.EC_KEY_free) + return _EllipticCurvePrivateKey(self, ec_cdata, evp_pkey) + elif key_type in self._dh_types: + dh_cdata = self._lib.EVP_PKEY_get1_DH(evp_pkey) + self.openssl_assert(dh_cdata != self._ffi.NULL) + dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free) + return _DHPrivateKey(self, dh_cdata, evp_pkey) + elif key_type == getattr(self._lib, "EVP_PKEY_ED25519", None): + # EVP_PKEY_ED25519 is not present in OpenSSL < 1.1.1 + return _Ed25519PrivateKey(self, evp_pkey) + elif key_type == getattr(self._lib, "EVP_PKEY_X448", None): + # EVP_PKEY_X448 is not present in OpenSSL < 1.1.1 + return _X448PrivateKey(self, evp_pkey) + elif key_type == getattr(self._lib, "EVP_PKEY_X25519", None): + # EVP_PKEY_X25519 is not present in OpenSSL < 1.1.0 + return _X25519PrivateKey(self, evp_pkey) + elif key_type == getattr(self._lib, "EVP_PKEY_ED448", None): + # EVP_PKEY_ED448 is not present in OpenSSL < 1.1.1 + return _Ed448PrivateKey(self, evp_pkey) + else: + raise UnsupportedAlgorithm("Unsupported key type.") + + def _evp_pkey_to_public_key(self, evp_pkey): + """ + Return the appropriate type of PublicKey given an evp_pkey cdata + pointer. + """ + + key_type = self._lib.EVP_PKEY_id(evp_pkey) + + if key_type == self._lib.EVP_PKEY_RSA: + rsa_cdata = self._lib.EVP_PKEY_get1_RSA(evp_pkey) + self.openssl_assert(rsa_cdata != self._ffi.NULL) + rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free) + return _RSAPublicKey(self, rsa_cdata, evp_pkey) + elif key_type == self._lib.EVP_PKEY_DSA: + dsa_cdata = self._lib.EVP_PKEY_get1_DSA(evp_pkey) + self.openssl_assert(dsa_cdata != self._ffi.NULL) + dsa_cdata = self._ffi.gc(dsa_cdata, self._lib.DSA_free) + return _DSAPublicKey(self, dsa_cdata, evp_pkey) + elif key_type == self._lib.EVP_PKEY_EC: + ec_cdata = self._lib.EVP_PKEY_get1_EC_KEY(evp_pkey) + self.openssl_assert(ec_cdata != self._ffi.NULL) + ec_cdata = self._ffi.gc(ec_cdata, self._lib.EC_KEY_free) + return _EllipticCurvePublicKey(self, ec_cdata, evp_pkey) + elif key_type in self._dh_types: + dh_cdata = self._lib.EVP_PKEY_get1_DH(evp_pkey) + self.openssl_assert(dh_cdata != self._ffi.NULL) + dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free) + return _DHPublicKey(self, dh_cdata, evp_pkey) + elif key_type == getattr(self._lib, "EVP_PKEY_ED25519", None): + # EVP_PKEY_ED25519 is not present in OpenSSL < 1.1.1 + return _Ed25519PublicKey(self, evp_pkey) + elif key_type == getattr(self._lib, "EVP_PKEY_X448", None): + # EVP_PKEY_X448 is not present in OpenSSL < 1.1.1 + return _X448PublicKey(self, evp_pkey) + elif key_type == getattr(self._lib, "EVP_PKEY_X25519", None): + # EVP_PKEY_X25519 is not present in OpenSSL < 1.1.0 + return _X25519PublicKey(self, evp_pkey) + elif key_type == getattr(self._lib, "EVP_PKEY_ED448", None): + # EVP_PKEY_X25519 is not present in OpenSSL < 1.1.1 + return _Ed448PublicKey(self, evp_pkey) + else: + raise UnsupportedAlgorithm("Unsupported key type.") + + def _oaep_hash_supported(self, algorithm): + if self._lib.Cryptography_HAS_RSA_OAEP_MD: + return isinstance( + algorithm, + ( + hashes.SHA1, + hashes.SHA224, + hashes.SHA256, + hashes.SHA384, + hashes.SHA512, + ), + ) + else: + return isinstance(algorithm, hashes.SHA1) + + def rsa_padding_supported(self, padding): + if isinstance(padding, PKCS1v15): + return True + elif isinstance(padding, PSS) and isinstance(padding._mgf, MGF1): + return self.hash_supported(padding._mgf._algorithm) + elif isinstance(padding, OAEP) and isinstance(padding._mgf, MGF1): + return ( + self._oaep_hash_supported(padding._mgf._algorithm) + and self._oaep_hash_supported(padding._algorithm) + and ( + (padding._label is None or len(padding._label) == 0) + or self._lib.Cryptography_HAS_RSA_OAEP_LABEL == 1 + ) + ) + else: + return False + + def generate_dsa_parameters(self, key_size): + if key_size not in (1024, 2048, 3072, 4096): + raise ValueError( + "Key size must be 1024, 2048, 3072, or 4096 bits." + ) + + ctx = self._lib.DSA_new() + self.openssl_assert(ctx != self._ffi.NULL) + ctx = self._ffi.gc(ctx, self._lib.DSA_free) + + res = self._lib.DSA_generate_parameters_ex( + ctx, + key_size, + self._ffi.NULL, + 0, + self._ffi.NULL, + self._ffi.NULL, + self._ffi.NULL, + ) + + self.openssl_assert(res == 1) + + return _DSAParameters(self, ctx) + + def generate_dsa_private_key(self, parameters): + ctx = self._lib.DSAparams_dup(parameters._dsa_cdata) + self.openssl_assert(ctx != self._ffi.NULL) + ctx = self._ffi.gc(ctx, self._lib.DSA_free) + self._lib.DSA_generate_key(ctx) + evp_pkey = self._dsa_cdata_to_evp_pkey(ctx) + + return _DSAPrivateKey(self, ctx, evp_pkey) + + def generate_dsa_private_key_and_parameters(self, key_size): + parameters = self.generate_dsa_parameters(key_size) + return self.generate_dsa_private_key(parameters) + + def _dsa_cdata_set_values(self, dsa_cdata, p, q, g, pub_key, priv_key): + res = self._lib.DSA_set0_pqg(dsa_cdata, p, q, g) + self.openssl_assert(res == 1) + res = self._lib.DSA_set0_key(dsa_cdata, pub_key, priv_key) + self.openssl_assert(res == 1) + + def load_dsa_private_numbers(self, numbers): + dsa._check_dsa_private_numbers(numbers) + parameter_numbers = numbers.public_numbers.parameter_numbers + + dsa_cdata = self._lib.DSA_new() + self.openssl_assert(dsa_cdata != self._ffi.NULL) + dsa_cdata = self._ffi.gc(dsa_cdata, self._lib.DSA_free) + + p = self._int_to_bn(parameter_numbers.p) + q = self._int_to_bn(parameter_numbers.q) + g = self._int_to_bn(parameter_numbers.g) + pub_key = self._int_to_bn(numbers.public_numbers.y) + priv_key = self._int_to_bn(numbers.x) + self._dsa_cdata_set_values(dsa_cdata, p, q, g, pub_key, priv_key) + + evp_pkey = self._dsa_cdata_to_evp_pkey(dsa_cdata) + + return _DSAPrivateKey(self, dsa_cdata, evp_pkey) + + def load_dsa_public_numbers(self, numbers): + dsa._check_dsa_parameters(numbers.parameter_numbers) + dsa_cdata = self._lib.DSA_new() + self.openssl_assert(dsa_cdata != self._ffi.NULL) + dsa_cdata = self._ffi.gc(dsa_cdata, self._lib.DSA_free) + + p = self._int_to_bn(numbers.parameter_numbers.p) + q = self._int_to_bn(numbers.parameter_numbers.q) + g = self._int_to_bn(numbers.parameter_numbers.g) + pub_key = self._int_to_bn(numbers.y) + priv_key = self._ffi.NULL + self._dsa_cdata_set_values(dsa_cdata, p, q, g, pub_key, priv_key) + + evp_pkey = self._dsa_cdata_to_evp_pkey(dsa_cdata) + + return _DSAPublicKey(self, dsa_cdata, evp_pkey) + + def load_dsa_parameter_numbers(self, numbers): + dsa._check_dsa_parameters(numbers) + dsa_cdata = self._lib.DSA_new() + self.openssl_assert(dsa_cdata != self._ffi.NULL) + dsa_cdata = self._ffi.gc(dsa_cdata, self._lib.DSA_free) + + p = self._int_to_bn(numbers.p) + q = self._int_to_bn(numbers.q) + g = self._int_to_bn(numbers.g) + res = self._lib.DSA_set0_pqg(dsa_cdata, p, q, g) + self.openssl_assert(res == 1) + + return _DSAParameters(self, dsa_cdata) + + def _dsa_cdata_to_evp_pkey(self, dsa_cdata): + evp_pkey = self._create_evp_pkey_gc() + res = self._lib.EVP_PKEY_set1_DSA(evp_pkey, dsa_cdata) + self.openssl_assert(res == 1) + return evp_pkey + + def dsa_hash_supported(self, algorithm): + return self.hash_supported(algorithm) + + def dsa_parameters_supported(self, p, q, g): + return True + + def cmac_algorithm_supported(self, algorithm): + return self.cipher_supported( + algorithm, CBC(b"\x00" * algorithm.block_size) + ) + + def create_cmac_ctx(self, algorithm): + return _CMACContext(self, algorithm) + + def _x509_check_signature_params(self, private_key, algorithm): + if isinstance( + private_key, (ed25519.Ed25519PrivateKey, ed448.Ed448PrivateKey) + ): + if algorithm is not None: + raise ValueError( + "algorithm must be None when signing via ed25519 or ed448" + ) + elif not isinstance( + private_key, + (rsa.RSAPrivateKey, dsa.DSAPrivateKey, ec.EllipticCurvePrivateKey), + ): + raise TypeError( + "Key must be an rsa, dsa, ec, ed25519, or ed448 private key." + ) + elif not isinstance(algorithm, hashes.HashAlgorithm): + raise TypeError("Algorithm must be a registered hash algorithm.") + elif isinstance(algorithm, hashes.MD5) and not isinstance( + private_key, rsa.RSAPrivateKey + ): + raise ValueError( + "MD5 hash algorithm is only supported with RSA keys" + ) + + def create_x509_csr(self, builder, private_key, algorithm): + if not isinstance(builder, x509.CertificateSigningRequestBuilder): + raise TypeError("Builder type mismatch.") + self._x509_check_signature_params(private_key, algorithm) + + # Resolve the signature algorithm. + evp_md = self._evp_md_x509_null_if_eddsa(private_key, algorithm) + + # Create an empty request. + x509_req = self._lib.X509_REQ_new() + self.openssl_assert(x509_req != self._ffi.NULL) + x509_req = self._ffi.gc(x509_req, self._lib.X509_REQ_free) + + # Set x509 version. + res = self._lib.X509_REQ_set_version(x509_req, x509.Version.v1.value) + self.openssl_assert(res == 1) + + # Set subject name. + res = self._lib.X509_REQ_set_subject_name( + x509_req, _encode_name_gc(self, builder._subject_name) + ) + self.openssl_assert(res == 1) + + # Set subject public key. + public_key = private_key.public_key() + res = self._lib.X509_REQ_set_pubkey(x509_req, public_key._evp_pkey) + self.openssl_assert(res == 1) + + # Add extensions. + sk_extension = self._lib.sk_X509_EXTENSION_new_null() + self.openssl_assert(sk_extension != self._ffi.NULL) + sk_extension = self._ffi.gc( + sk_extension, + lambda x: self._lib.sk_X509_EXTENSION_pop_free( + x, + self._ffi.addressof( + self._lib._original_lib, "X509_EXTENSION_free" + ), + ), + ) + # Don't GC individual extensions because the memory is owned by + # sk_extensions and will be freed along with it. + self._create_x509_extensions( + extensions=builder._extensions, + handlers=self._extension_encode_handlers, + x509_obj=sk_extension, + add_func=self._lib.sk_X509_EXTENSION_insert, + gc=False, + ) + res = self._lib.X509_REQ_add_extensions(x509_req, sk_extension) + self.openssl_assert(res == 1) + + # Add attributes (all bytes encoded as ASN1 UTF8_STRING) + for attr_oid, attr_val in builder._attributes: + obj = _txt2obj_gc(self, attr_oid.dotted_string) + res = self._lib.X509_REQ_add1_attr_by_OBJ( + x509_req, + obj, + x509.name._ASN1Type.UTF8String.value, + attr_val, + len(attr_val), + ) + self.openssl_assert(res == 1) + + # Sign the request using the requester's private key. + res = self._lib.X509_REQ_sign(x509_req, private_key._evp_pkey, evp_md) + if res == 0: + errors = self._consume_errors_with_text() + raise ValueError("Signing failed", errors) + + return _CertificateSigningRequest(self, x509_req) + + def create_x509_certificate(self, builder, private_key, algorithm): + if not isinstance(builder, x509.CertificateBuilder): + raise TypeError("Builder type mismatch.") + self._x509_check_signature_params(private_key, algorithm) + + # Resolve the signature algorithm. + evp_md = self._evp_md_x509_null_if_eddsa(private_key, algorithm) + + # Create an empty certificate. + x509_cert = self._lib.X509_new() + x509_cert = self._ffi.gc(x509_cert, self._lib.X509_free) + + # Set the x509 version. + res = self._lib.X509_set_version(x509_cert, builder._version.value) + self.openssl_assert(res == 1) + + # Set the subject's name. + res = self._lib.X509_set_subject_name( + x509_cert, _encode_name_gc(self, builder._subject_name) + ) + self.openssl_assert(res == 1) + + # Set the subject's public key. + res = self._lib.X509_set_pubkey( + x509_cert, builder._public_key._evp_pkey + ) + self.openssl_assert(res == 1) + + # Set the certificate serial number. + serial_number = _encode_asn1_int_gc(self, builder._serial_number) + res = self._lib.X509_set_serialNumber(x509_cert, serial_number) + self.openssl_assert(res == 1) + + # Set the "not before" time. + self._set_asn1_time( + self._lib.X509_getm_notBefore(x509_cert), builder._not_valid_before + ) + + # Set the "not after" time. + self._set_asn1_time( + self._lib.X509_getm_notAfter(x509_cert), builder._not_valid_after + ) + + # Add extensions. + self._create_x509_extensions( + extensions=builder._extensions, + handlers=self._extension_encode_handlers, + x509_obj=x509_cert, + add_func=self._lib.X509_add_ext, + gc=True, + ) + + # Set the issuer name. + res = self._lib.X509_set_issuer_name( + x509_cert, _encode_name_gc(self, builder._issuer_name) + ) + self.openssl_assert(res == 1) + + # Sign the certificate with the issuer's private key. + res = self._lib.X509_sign(x509_cert, private_key._evp_pkey, evp_md) + if res == 0: + errors = self._consume_errors_with_text() + raise ValueError("Signing failed", errors) + + return _Certificate(self, x509_cert) + + def _evp_md_x509_null_if_eddsa(self, private_key, algorithm): + if isinstance( + private_key, (ed25519.Ed25519PrivateKey, ed448.Ed448PrivateKey) + ): + # OpenSSL requires us to pass NULL for EVP_MD for ed25519/ed448 + return self._ffi.NULL + else: + return self._evp_md_non_null_from_algorithm(algorithm) + + def _set_asn1_time(self, asn1_time, time): + if time.year >= 2050: + asn1_str = time.strftime("%Y%m%d%H%M%SZ").encode("ascii") + else: + asn1_str = time.strftime("%y%m%d%H%M%SZ").encode("ascii") + res = self._lib.ASN1_TIME_set_string(asn1_time, asn1_str) + self.openssl_assert(res == 1) + + def _create_asn1_time(self, time): + asn1_time = self._lib.ASN1_TIME_new() + self.openssl_assert(asn1_time != self._ffi.NULL) + asn1_time = self._ffi.gc(asn1_time, self._lib.ASN1_TIME_free) + self._set_asn1_time(asn1_time, time) + return asn1_time + + def create_x509_crl(self, builder, private_key, algorithm): + if not isinstance(builder, x509.CertificateRevocationListBuilder): + raise TypeError("Builder type mismatch.") + self._x509_check_signature_params(private_key, algorithm) + + evp_md = self._evp_md_x509_null_if_eddsa(private_key, algorithm) + + # Create an empty CRL. + x509_crl = self._lib.X509_CRL_new() + x509_crl = self._ffi.gc(x509_crl, self._lib.X509_CRL_free) + + # Set the x509 CRL version. We only support v2 (integer value 1). + res = self._lib.X509_CRL_set_version(x509_crl, 1) + self.openssl_assert(res == 1) + + # Set the issuer name. + res = self._lib.X509_CRL_set_issuer_name( + x509_crl, _encode_name_gc(self, builder._issuer_name) + ) + self.openssl_assert(res == 1) + + # Set the last update time. + last_update = self._create_asn1_time(builder._last_update) + res = self._lib.X509_CRL_set_lastUpdate(x509_crl, last_update) + self.openssl_assert(res == 1) + + # Set the next update time. + next_update = self._create_asn1_time(builder._next_update) + res = self._lib.X509_CRL_set_nextUpdate(x509_crl, next_update) + self.openssl_assert(res == 1) + + # Add extensions. + self._create_x509_extensions( + extensions=builder._extensions, + handlers=self._crl_extension_encode_handlers, + x509_obj=x509_crl, + add_func=self._lib.X509_CRL_add_ext, + gc=True, + ) + + # add revoked certificates + for revoked_cert in builder._revoked_certificates: + # Duplicating because the X509_CRL takes ownership and will free + # this memory when X509_CRL_free is called. + revoked = self._lib.X509_REVOKED_dup(revoked_cert._x509_revoked) + self.openssl_assert(revoked != self._ffi.NULL) + res = self._lib.X509_CRL_add0_revoked(x509_crl, revoked) + self.openssl_assert(res == 1) + + res = self._lib.X509_CRL_sign(x509_crl, private_key._evp_pkey, evp_md) + if res == 0: + errors = self._consume_errors_with_text() + raise ValueError("Signing failed", errors) + + return _CertificateRevocationList(self, x509_crl) + + def _create_x509_extensions( + self, extensions, handlers, x509_obj, add_func, gc + ): + for i, extension in enumerate(extensions): + x509_extension = self._create_x509_extension(handlers, extension) + self.openssl_assert(x509_extension != self._ffi.NULL) + + if gc: + x509_extension = self._ffi.gc( + x509_extension, self._lib.X509_EXTENSION_free + ) + res = add_func(x509_obj, x509_extension, i) + self.openssl_assert(res >= 1) + + def _create_raw_x509_extension(self, extension, value): + obj = _txt2obj_gc(self, extension.oid.dotted_string) + return self._lib.X509_EXTENSION_create_by_OBJ( + self._ffi.NULL, obj, 1 if extension.critical else 0, value + ) + + def _create_x509_extension(self, handlers, extension): + if isinstance(extension.value, x509.UnrecognizedExtension): + value = _encode_asn1_str_gc(self, extension.value.value) + return self._create_raw_x509_extension(extension, value) + elif isinstance(extension.value, x509.TLSFeature): + asn1 = encode_der( + SEQUENCE, + *[ + encode_der(INTEGER, encode_der_integer(x.value)) + for x in extension.value + ] + ) + value = _encode_asn1_str_gc(self, asn1) + return self._create_raw_x509_extension(extension, value) + elif isinstance(extension.value, x509.PrecertPoison): + value = _encode_asn1_str_gc(self, encode_der(NULL)) + return self._create_raw_x509_extension(extension, value) + else: + try: + encode = handlers[extension.oid] + except KeyError: + raise NotImplementedError( + "Extension not supported: {}".format(extension.oid) + ) + + ext_struct = encode(self, extension.value) + nid = self._lib.OBJ_txt2nid( + extension.oid.dotted_string.encode("ascii") + ) + self.openssl_assert(nid != self._lib.NID_undef) + return self._lib.X509V3_EXT_i2d( + nid, 1 if extension.critical else 0, ext_struct + ) + + def create_x509_revoked_certificate(self, builder): + if not isinstance(builder, x509.RevokedCertificateBuilder): + raise TypeError("Builder type mismatch.") + + x509_revoked = self._lib.X509_REVOKED_new() + self.openssl_assert(x509_revoked != self._ffi.NULL) + x509_revoked = self._ffi.gc(x509_revoked, self._lib.X509_REVOKED_free) + serial_number = _encode_asn1_int_gc(self, builder._serial_number) + res = self._lib.X509_REVOKED_set_serialNumber( + x509_revoked, serial_number + ) + self.openssl_assert(res == 1) + rev_date = self._create_asn1_time(builder._revocation_date) + res = self._lib.X509_REVOKED_set_revocationDate(x509_revoked, rev_date) + self.openssl_assert(res == 1) + # add CRL entry extensions + self._create_x509_extensions( + extensions=builder._extensions, + handlers=self._crl_entry_extension_encode_handlers, + x509_obj=x509_revoked, + add_func=self._lib.X509_REVOKED_add_ext, + gc=True, + ) + return _RevokedCertificate(self, None, x509_revoked) + + def load_pem_private_key(self, data, password): + return self._load_key( + self._lib.PEM_read_bio_PrivateKey, + self._evp_pkey_to_private_key, + data, + password, + ) + + def load_pem_public_key(self, data): + mem_bio = self._bytes_to_bio(data) + evp_pkey = self._lib.PEM_read_bio_PUBKEY( + mem_bio.bio, self._ffi.NULL, self._ffi.NULL, self._ffi.NULL + ) + if evp_pkey != self._ffi.NULL: + evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free) + return self._evp_pkey_to_public_key(evp_pkey) + else: + # It's not a (RSA/DSA/ECDSA) subjectPublicKeyInfo, but we still + # need to check to see if it is a pure PKCS1 RSA public key (not + # embedded in a subjectPublicKeyInfo) + self._consume_errors() + res = self._lib.BIO_reset(mem_bio.bio) + self.openssl_assert(res == 1) + rsa_cdata = self._lib.PEM_read_bio_RSAPublicKey( + mem_bio.bio, self._ffi.NULL, self._ffi.NULL, self._ffi.NULL + ) + if rsa_cdata != self._ffi.NULL: + rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free) + evp_pkey = self._rsa_cdata_to_evp_pkey(rsa_cdata) + return _RSAPublicKey(self, rsa_cdata, evp_pkey) + else: + self._handle_key_loading_error() + + def load_pem_parameters(self, data): + mem_bio = self._bytes_to_bio(data) + # only DH is supported currently + dh_cdata = self._lib.PEM_read_bio_DHparams( + mem_bio.bio, self._ffi.NULL, self._ffi.NULL, self._ffi.NULL + ) + if dh_cdata != self._ffi.NULL: + dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free) + return _DHParameters(self, dh_cdata) + else: + self._handle_key_loading_error() + + def load_der_private_key(self, data, password): + # OpenSSL has a function called d2i_AutoPrivateKey that in theory + # handles this automatically, however it doesn't handle encrypted + # private keys. Instead we try to load the key two different ways. + # First we'll try to load it as a traditional key. + bio_data = self._bytes_to_bio(data) + key = self._evp_pkey_from_der_traditional_key(bio_data, password) + if key: + return self._evp_pkey_to_private_key(key) + else: + # Finally we try to load it with the method that handles encrypted + # PKCS8 properly. + return self._load_key( + self._lib.d2i_PKCS8PrivateKey_bio, + self._evp_pkey_to_private_key, + data, + password, + ) + + def _evp_pkey_from_der_traditional_key(self, bio_data, password): + key = self._lib.d2i_PrivateKey_bio(bio_data.bio, self._ffi.NULL) + if key != self._ffi.NULL: + key = self._ffi.gc(key, self._lib.EVP_PKEY_free) + if password is not None: + raise TypeError( + "Password was given but private key is not encrypted." + ) + + return key + else: + self._consume_errors() + return None + + def load_der_public_key(self, data): + mem_bio = self._bytes_to_bio(data) + evp_pkey = self._lib.d2i_PUBKEY_bio(mem_bio.bio, self._ffi.NULL) + if evp_pkey != self._ffi.NULL: + evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free) + return self._evp_pkey_to_public_key(evp_pkey) + else: + # It's not a (RSA/DSA/ECDSA) subjectPublicKeyInfo, but we still + # need to check to see if it is a pure PKCS1 RSA public key (not + # embedded in a subjectPublicKeyInfo) + self._consume_errors() + res = self._lib.BIO_reset(mem_bio.bio) + self.openssl_assert(res == 1) + rsa_cdata = self._lib.d2i_RSAPublicKey_bio( + mem_bio.bio, self._ffi.NULL + ) + if rsa_cdata != self._ffi.NULL: + rsa_cdata = self._ffi.gc(rsa_cdata, self._lib.RSA_free) + evp_pkey = self._rsa_cdata_to_evp_pkey(rsa_cdata) + return _RSAPublicKey(self, rsa_cdata, evp_pkey) + else: + self._handle_key_loading_error() + + def load_der_parameters(self, data): + mem_bio = self._bytes_to_bio(data) + dh_cdata = self._lib.d2i_DHparams_bio(mem_bio.bio, self._ffi.NULL) + if dh_cdata != self._ffi.NULL: + dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free) + return _DHParameters(self, dh_cdata) + elif self._lib.Cryptography_HAS_EVP_PKEY_DHX: + # We check to see if the is dhx. + self._consume_errors() + res = self._lib.BIO_reset(mem_bio.bio) + self.openssl_assert(res == 1) + dh_cdata = self._lib.Cryptography_d2i_DHxparams_bio( + mem_bio.bio, self._ffi.NULL + ) + if dh_cdata != self._ffi.NULL: + dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free) + return _DHParameters(self, dh_cdata) + + self._handle_key_loading_error() + + def load_pem_x509_certificate(self, data): + mem_bio = self._bytes_to_bio(data) + x509 = self._lib.PEM_read_bio_X509( + mem_bio.bio, self._ffi.NULL, self._ffi.NULL, self._ffi.NULL + ) + if x509 == self._ffi.NULL: + self._consume_errors() + raise ValueError( + "Unable to load certificate. See https://cryptography.io/en/" + "latest/faq.html#why-can-t-i-import-my-pem-file for more" + " details." + ) + + x509 = self._ffi.gc(x509, self._lib.X509_free) + return _Certificate(self, x509) + + def load_der_x509_certificate(self, data): + mem_bio = self._bytes_to_bio(data) + x509 = self._lib.d2i_X509_bio(mem_bio.bio, self._ffi.NULL) + if x509 == self._ffi.NULL: + self._consume_errors() + raise ValueError("Unable to load certificate") + + x509 = self._ffi.gc(x509, self._lib.X509_free) + return _Certificate(self, x509) + + def load_pem_x509_crl(self, data): + mem_bio = self._bytes_to_bio(data) + x509_crl = self._lib.PEM_read_bio_X509_CRL( + mem_bio.bio, self._ffi.NULL, self._ffi.NULL, self._ffi.NULL + ) + if x509_crl == self._ffi.NULL: + self._consume_errors() + raise ValueError( + "Unable to load CRL. See https://cryptography.io/en/la" + "test/faq.html#why-can-t-i-import-my-pem-file for more" + " details." + ) + + x509_crl = self._ffi.gc(x509_crl, self._lib.X509_CRL_free) + return _CertificateRevocationList(self, x509_crl) + + def load_der_x509_crl(self, data): + mem_bio = self._bytes_to_bio(data) + x509_crl = self._lib.d2i_X509_CRL_bio(mem_bio.bio, self._ffi.NULL) + if x509_crl == self._ffi.NULL: + self._consume_errors() + raise ValueError("Unable to load CRL") + + x509_crl = self._ffi.gc(x509_crl, self._lib.X509_CRL_free) + return _CertificateRevocationList(self, x509_crl) + + def load_pem_x509_csr(self, data): + mem_bio = self._bytes_to_bio(data) + x509_req = self._lib.PEM_read_bio_X509_REQ( + mem_bio.bio, self._ffi.NULL, self._ffi.NULL, self._ffi.NULL + ) + if x509_req == self._ffi.NULL: + self._consume_errors() + raise ValueError( + "Unable to load request. See https://cryptography.io/en/" + "latest/faq.html#why-can-t-i-import-my-pem-file for more" + " details." + ) + + x509_req = self._ffi.gc(x509_req, self._lib.X509_REQ_free) + return _CertificateSigningRequest(self, x509_req) + + def load_der_x509_csr(self, data): + mem_bio = self._bytes_to_bio(data) + x509_req = self._lib.d2i_X509_REQ_bio(mem_bio.bio, self._ffi.NULL) + if x509_req == self._ffi.NULL: + self._consume_errors() + raise ValueError("Unable to load request") + + x509_req = self._ffi.gc(x509_req, self._lib.X509_REQ_free) + return _CertificateSigningRequest(self, x509_req) + + def _load_key(self, openssl_read_func, convert_func, data, password): + mem_bio = self._bytes_to_bio(data) + + userdata = self._ffi.new("CRYPTOGRAPHY_PASSWORD_DATA *") + if password is not None: + utils._check_byteslike("password", password) + password_ptr = self._ffi.from_buffer(password) + userdata.password = password_ptr + userdata.length = len(password) + + evp_pkey = openssl_read_func( + mem_bio.bio, + self._ffi.NULL, + self._ffi.addressof( + self._lib._original_lib, "Cryptography_pem_password_cb" + ), + userdata, + ) + + if evp_pkey == self._ffi.NULL: + if userdata.error != 0: + self._consume_errors() + if userdata.error == -1: + raise TypeError( + "Password was not given but private key is encrypted" + ) + else: + assert userdata.error == -2 + raise ValueError( + "Passwords longer than {} bytes are not supported " + "by this backend.".format(userdata.maxsize - 1) + ) + else: + self._handle_key_loading_error() + + evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free) + + if password is not None and userdata.called == 0: + raise TypeError( + "Password was given but private key is not encrypted." + ) + + assert ( + password is not None and userdata.called == 1 + ) or password is None + + return convert_func(evp_pkey) + + def _handle_key_loading_error(self): + errors = self._consume_errors() + + if not errors: + raise ValueError( + "Could not deserialize key data. The data may be in an " + "incorrect format or it may be encrypted with an unsupported " + "algorithm." + ) + elif errors[0]._lib_reason_match( + self._lib.ERR_LIB_EVP, self._lib.EVP_R_BAD_DECRYPT + ) or errors[0]._lib_reason_match( + self._lib.ERR_LIB_PKCS12, + self._lib.PKCS12_R_PKCS12_CIPHERFINAL_ERROR, + ): + raise ValueError("Bad decrypt. Incorrect password?") + + elif any( + error._lib_reason_match( + self._lib.ERR_LIB_EVP, + self._lib.EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM, + ) + for error in errors + ): + raise ValueError("Unsupported public key algorithm.") + + else: + raise ValueError( + "Could not deserialize key data. The data may be in an " + "incorrect format or it may be encrypted with an unsupported " + "algorithm." + ) + + def elliptic_curve_supported(self, curve): + try: + curve_nid = self._elliptic_curve_to_nid(curve) + except UnsupportedAlgorithm: + curve_nid = self._lib.NID_undef + + group = self._lib.EC_GROUP_new_by_curve_name(curve_nid) + + if group == self._ffi.NULL: + self._consume_errors() + return False + else: + self.openssl_assert(curve_nid != self._lib.NID_undef) + self._lib.EC_GROUP_free(group) + return True + + def elliptic_curve_signature_algorithm_supported( + self, signature_algorithm, curve + ): + # We only support ECDSA right now. + if not isinstance(signature_algorithm, ec.ECDSA): + return False + + return self.elliptic_curve_supported(curve) + + def generate_elliptic_curve_private_key(self, curve): + """ + Generate a new private key on the named curve. + """ + + if self.elliptic_curve_supported(curve): + ec_cdata = self._ec_key_new_by_curve(curve) + + res = self._lib.EC_KEY_generate_key(ec_cdata) + self.openssl_assert(res == 1) + + evp_pkey = self._ec_cdata_to_evp_pkey(ec_cdata) + + return _EllipticCurvePrivateKey(self, ec_cdata, evp_pkey) + else: + raise UnsupportedAlgorithm( + "Backend object does not support {}.".format(curve.name), + _Reasons.UNSUPPORTED_ELLIPTIC_CURVE, + ) + + def load_elliptic_curve_private_numbers(self, numbers): + public = numbers.public_numbers + + ec_cdata = self._ec_key_new_by_curve(public.curve) + + private_value = self._ffi.gc( + self._int_to_bn(numbers.private_value), self._lib.BN_clear_free + ) + res = self._lib.EC_KEY_set_private_key(ec_cdata, private_value) + self.openssl_assert(res == 1) + + ec_cdata = self._ec_key_set_public_key_affine_coordinates( + ec_cdata, public.x, public.y + ) + + evp_pkey = self._ec_cdata_to_evp_pkey(ec_cdata) + + return _EllipticCurvePrivateKey(self, ec_cdata, evp_pkey) + + def load_elliptic_curve_public_numbers(self, numbers): + ec_cdata = self._ec_key_new_by_curve(numbers.curve) + ec_cdata = self._ec_key_set_public_key_affine_coordinates( + ec_cdata, numbers.x, numbers.y + ) + evp_pkey = self._ec_cdata_to_evp_pkey(ec_cdata) + + return _EllipticCurvePublicKey(self, ec_cdata, evp_pkey) + + def load_elliptic_curve_public_bytes(self, curve, point_bytes): + ec_cdata = self._ec_key_new_by_curve(curve) + group = self._lib.EC_KEY_get0_group(ec_cdata) + self.openssl_assert(group != self._ffi.NULL) + point = self._lib.EC_POINT_new(group) + self.openssl_assert(point != self._ffi.NULL) + point = self._ffi.gc(point, self._lib.EC_POINT_free) + with self._tmp_bn_ctx() as bn_ctx: + res = self._lib.EC_POINT_oct2point( + group, point, point_bytes, len(point_bytes), bn_ctx + ) + if res != 1: + self._consume_errors() + raise ValueError("Invalid public bytes for the given curve") + + res = self._lib.EC_KEY_set_public_key(ec_cdata, point) + self.openssl_assert(res == 1) + evp_pkey = self._ec_cdata_to_evp_pkey(ec_cdata) + return _EllipticCurvePublicKey(self, ec_cdata, evp_pkey) + + def derive_elliptic_curve_private_key(self, private_value, curve): + ec_cdata = self._ec_key_new_by_curve(curve) + + get_func, group = self._ec_key_determine_group_get_func(ec_cdata) + + point = self._lib.EC_POINT_new(group) + self.openssl_assert(point != self._ffi.NULL) + point = self._ffi.gc(point, self._lib.EC_POINT_free) + + value = self._int_to_bn(private_value) + value = self._ffi.gc(value, self._lib.BN_clear_free) + + with self._tmp_bn_ctx() as bn_ctx: + res = self._lib.EC_POINT_mul( + group, point, value, self._ffi.NULL, self._ffi.NULL, bn_ctx + ) + self.openssl_assert(res == 1) + + bn_x = self._lib.BN_CTX_get(bn_ctx) + bn_y = self._lib.BN_CTX_get(bn_ctx) + + res = get_func(group, point, bn_x, bn_y, bn_ctx) + self.openssl_assert(res == 1) + + res = self._lib.EC_KEY_set_public_key(ec_cdata, point) + self.openssl_assert(res == 1) + private = self._int_to_bn(private_value) + private = self._ffi.gc(private, self._lib.BN_clear_free) + res = self._lib.EC_KEY_set_private_key(ec_cdata, private) + self.openssl_assert(res == 1) + + evp_pkey = self._ec_cdata_to_evp_pkey(ec_cdata) + + return _EllipticCurvePrivateKey(self, ec_cdata, evp_pkey) + + def _ec_key_new_by_curve(self, curve): + curve_nid = self._elliptic_curve_to_nid(curve) + return self._ec_key_new_by_curve_nid(curve_nid) + + def _ec_key_new_by_curve_nid(self, curve_nid): + ec_cdata = self._lib.EC_KEY_new_by_curve_name(curve_nid) + self.openssl_assert(ec_cdata != self._ffi.NULL) + return self._ffi.gc(ec_cdata, self._lib.EC_KEY_free) + + def load_der_ocsp_request(self, data): + mem_bio = self._bytes_to_bio(data) + request = self._lib.d2i_OCSP_REQUEST_bio(mem_bio.bio, self._ffi.NULL) + if request == self._ffi.NULL: + self._consume_errors() + raise ValueError("Unable to load OCSP request") + + request = self._ffi.gc(request, self._lib.OCSP_REQUEST_free) + return _OCSPRequest(self, request) + + def load_der_ocsp_response(self, data): + mem_bio = self._bytes_to_bio(data) + response = self._lib.d2i_OCSP_RESPONSE_bio(mem_bio.bio, self._ffi.NULL) + if response == self._ffi.NULL: + self._consume_errors() + raise ValueError("Unable to load OCSP response") + + response = self._ffi.gc(response, self._lib.OCSP_RESPONSE_free) + return _OCSPResponse(self, response) + + def create_ocsp_request(self, builder): + ocsp_req = self._lib.OCSP_REQUEST_new() + self.openssl_assert(ocsp_req != self._ffi.NULL) + ocsp_req = self._ffi.gc(ocsp_req, self._lib.OCSP_REQUEST_free) + cert, issuer, algorithm = builder._request + evp_md = self._evp_md_non_null_from_algorithm(algorithm) + certid = self._lib.OCSP_cert_to_id(evp_md, cert._x509, issuer._x509) + self.openssl_assert(certid != self._ffi.NULL) + onereq = self._lib.OCSP_request_add0_id(ocsp_req, certid) + self.openssl_assert(onereq != self._ffi.NULL) + self._create_x509_extensions( + extensions=builder._extensions, + handlers=self._ocsp_request_extension_encode_handlers, + x509_obj=ocsp_req, + add_func=self._lib.OCSP_REQUEST_add_ext, + gc=True, + ) + return _OCSPRequest(self, ocsp_req) + + def _create_ocsp_basic_response(self, builder, private_key, algorithm): + self._x509_check_signature_params(private_key, algorithm) + + basic = self._lib.OCSP_BASICRESP_new() + self.openssl_assert(basic != self._ffi.NULL) + basic = self._ffi.gc(basic, self._lib.OCSP_BASICRESP_free) + evp_md = self._evp_md_non_null_from_algorithm( + builder._response._algorithm + ) + certid = self._lib.OCSP_cert_to_id( + evp_md, + builder._response._cert._x509, + builder._response._issuer._x509, + ) + self.openssl_assert(certid != self._ffi.NULL) + certid = self._ffi.gc(certid, self._lib.OCSP_CERTID_free) + if builder._response._revocation_reason is None: + reason = -1 + else: + reason = _CRL_ENTRY_REASON_ENUM_TO_CODE[ + builder._response._revocation_reason + ] + if builder._response._revocation_time is None: + rev_time = self._ffi.NULL + else: + rev_time = self._create_asn1_time( + builder._response._revocation_time + ) + + next_update = self._ffi.NULL + if builder._response._next_update is not None: + next_update = self._create_asn1_time( + builder._response._next_update + ) + + this_update = self._create_asn1_time(builder._response._this_update) + + res = self._lib.OCSP_basic_add1_status( + basic, + certid, + builder._response._cert_status.value, + reason, + rev_time, + this_update, + next_update, + ) + self.openssl_assert(res != self._ffi.NULL) + # okay, now sign the basic structure + evp_md = self._evp_md_x509_null_if_eddsa(private_key, algorithm) + responder_cert, responder_encoding = builder._responder_id + flags = self._lib.OCSP_NOCERTS + if responder_encoding is ocsp.OCSPResponderEncoding.HASH: + flags |= self._lib.OCSP_RESPID_KEY + + if builder._certs is not None: + for cert in builder._certs: + res = self._lib.OCSP_basic_add1_cert(basic, cert._x509) + self.openssl_assert(res == 1) + + self._create_x509_extensions( + extensions=builder._extensions, + handlers=self._ocsp_basicresp_extension_encode_handlers, + x509_obj=basic, + add_func=self._lib.OCSP_BASICRESP_add_ext, + gc=True, + ) + + res = self._lib.OCSP_basic_sign( + basic, + responder_cert._x509, + private_key._evp_pkey, + evp_md, + self._ffi.NULL, + flags, + ) + if res != 1: + errors = self._consume_errors_with_text() + raise ValueError( + "Error while signing. responder_cert must be signed " + "by private_key", + errors, + ) + + return basic + + def create_ocsp_response( + self, response_status, builder, private_key, algorithm + ): + if response_status is ocsp.OCSPResponseStatus.SUCCESSFUL: + basic = self._create_ocsp_basic_response( + builder, private_key, algorithm + ) + else: + basic = self._ffi.NULL + + ocsp_resp = self._lib.OCSP_response_create( + response_status.value, basic + ) + self.openssl_assert(ocsp_resp != self._ffi.NULL) + ocsp_resp = self._ffi.gc(ocsp_resp, self._lib.OCSP_RESPONSE_free) + return _OCSPResponse(self, ocsp_resp) + + def elliptic_curve_exchange_algorithm_supported(self, algorithm, curve): + return self.elliptic_curve_supported(curve) and isinstance( + algorithm, ec.ECDH + ) + + def _ec_cdata_to_evp_pkey(self, ec_cdata): + evp_pkey = self._create_evp_pkey_gc() + res = self._lib.EVP_PKEY_set1_EC_KEY(evp_pkey, ec_cdata) + self.openssl_assert(res == 1) + return evp_pkey + + def _elliptic_curve_to_nid(self, curve): + """ + Get the NID for a curve name. + """ + + curve_aliases = {"secp192r1": "prime192v1", "secp256r1": "prime256v1"} + + curve_name = curve_aliases.get(curve.name, curve.name) + + curve_nid = self._lib.OBJ_sn2nid(curve_name.encode()) + if curve_nid == self._lib.NID_undef: + raise UnsupportedAlgorithm( + "{} is not a supported elliptic curve".format(curve.name), + _Reasons.UNSUPPORTED_ELLIPTIC_CURVE, + ) + return curve_nid + + @contextmanager + def _tmp_bn_ctx(self): + bn_ctx = self._lib.BN_CTX_new() + self.openssl_assert(bn_ctx != self._ffi.NULL) + bn_ctx = self._ffi.gc(bn_ctx, self._lib.BN_CTX_free) + self._lib.BN_CTX_start(bn_ctx) + try: + yield bn_ctx + finally: + self._lib.BN_CTX_end(bn_ctx) + + def _ec_key_determine_group_get_func(self, ctx): + """ + Given an EC_KEY determine the group and what function is required to + get point coordinates. + """ + self.openssl_assert(ctx != self._ffi.NULL) + + nid_two_field = self._lib.OBJ_sn2nid(b"characteristic-two-field") + self.openssl_assert(nid_two_field != self._lib.NID_undef) + + group = self._lib.EC_KEY_get0_group(ctx) + self.openssl_assert(group != self._ffi.NULL) + + method = self._lib.EC_GROUP_method_of(group) + self.openssl_assert(method != self._ffi.NULL) + + nid = self._lib.EC_METHOD_get_field_type(method) + self.openssl_assert(nid != self._lib.NID_undef) + + if nid == nid_two_field and self._lib.Cryptography_HAS_EC2M: + get_func = self._lib.EC_POINT_get_affine_coordinates_GF2m + else: + get_func = self._lib.EC_POINT_get_affine_coordinates_GFp + + assert get_func + + return get_func, group + + def _ec_key_set_public_key_affine_coordinates(self, ctx, x, y): + """ + Sets the public key point in the EC_KEY context to the affine x and y + values. + """ + + if x < 0 or y < 0: + raise ValueError( + "Invalid EC key. Both x and y must be non-negative." + ) + + x = self._ffi.gc(self._int_to_bn(x), self._lib.BN_free) + y = self._ffi.gc(self._int_to_bn(y), self._lib.BN_free) + res = self._lib.EC_KEY_set_public_key_affine_coordinates(ctx, x, y) + if res != 1: + self._consume_errors() + raise ValueError("Invalid EC key.") + + return ctx + + def _private_key_bytes( + self, encoding, format, encryption_algorithm, key, evp_pkey, cdata + ): + # validate argument types + if not isinstance(encoding, serialization.Encoding): + raise TypeError("encoding must be an item from the Encoding enum") + if not isinstance(format, serialization.PrivateFormat): + raise TypeError( + "format must be an item from the PrivateFormat enum" + ) + if not isinstance( + encryption_algorithm, serialization.KeySerializationEncryption + ): + raise TypeError( + "Encryption algorithm must be a KeySerializationEncryption " + "instance" + ) + + # validate password + if isinstance(encryption_algorithm, serialization.NoEncryption): + password = b"" + elif isinstance( + encryption_algorithm, serialization.BestAvailableEncryption + ): + password = encryption_algorithm.password + if len(password) > 1023: + raise ValueError( + "Passwords longer than 1023 bytes are not supported by " + "this backend" + ) + else: + raise ValueError("Unsupported encryption type") + + # PKCS8 + PEM/DER + if format is serialization.PrivateFormat.PKCS8: + if encoding is serialization.Encoding.PEM: + write_bio = self._lib.PEM_write_bio_PKCS8PrivateKey + elif encoding is serialization.Encoding.DER: + write_bio = self._lib.i2d_PKCS8PrivateKey_bio + else: + raise ValueError("Unsupported encoding for PKCS8") + return self._private_key_bytes_via_bio( + write_bio, evp_pkey, password + ) + + # TraditionalOpenSSL + PEM/DER + if format is serialization.PrivateFormat.TraditionalOpenSSL: + if self._fips_enabled and not isinstance( + encryption_algorithm, serialization.NoEncryption + ): + raise ValueError( + "Encrypted traditional OpenSSL format is not " + "supported in FIPS mode." + ) + key_type = self._lib.EVP_PKEY_id(evp_pkey) + + if encoding is serialization.Encoding.PEM: + if key_type == self._lib.EVP_PKEY_RSA: + write_bio = self._lib.PEM_write_bio_RSAPrivateKey + elif key_type == self._lib.EVP_PKEY_DSA: + write_bio = self._lib.PEM_write_bio_DSAPrivateKey + elif key_type == self._lib.EVP_PKEY_EC: + write_bio = self._lib.PEM_write_bio_ECPrivateKey + else: + raise ValueError( + "Unsupported key type for TraditionalOpenSSL" + ) + return self._private_key_bytes_via_bio( + write_bio, cdata, password + ) + + if encoding is serialization.Encoding.DER: + if password: + raise ValueError( + "Encryption is not supported for DER encoded " + "traditional OpenSSL keys" + ) + if key_type == self._lib.EVP_PKEY_RSA: + write_bio = self._lib.i2d_RSAPrivateKey_bio + elif key_type == self._lib.EVP_PKEY_EC: + write_bio = self._lib.i2d_ECPrivateKey_bio + elif key_type == self._lib.EVP_PKEY_DSA: + write_bio = self._lib.i2d_DSAPrivateKey_bio + else: + raise ValueError( + "Unsupported key type for TraditionalOpenSSL" + ) + return self._bio_func_output(write_bio, cdata) + + raise ValueError("Unsupported encoding for TraditionalOpenSSL") + + # OpenSSH + PEM + if format is serialization.PrivateFormat.OpenSSH: + if encoding is serialization.Encoding.PEM: + return ssh.serialize_ssh_private_key(key, password) + + raise ValueError( + "OpenSSH private key format can only be used" + " with PEM encoding" + ) + + # Anything that key-specific code was supposed to handle earlier, + # like Raw. + raise ValueError("format is invalid with this key") + + def _private_key_bytes_via_bio(self, write_bio, evp_pkey, password): + if not password: + evp_cipher = self._ffi.NULL + else: + # This is a curated value that we will update over time. + evp_cipher = self._lib.EVP_get_cipherbyname(b"aes-256-cbc") + + return self._bio_func_output( + write_bio, + evp_pkey, + evp_cipher, + password, + len(password), + self._ffi.NULL, + self._ffi.NULL, + ) + + def _bio_func_output(self, write_bio, *args): + bio = self._create_mem_bio_gc() + res = write_bio(bio, *args) + self.openssl_assert(res == 1) + return self._read_mem_bio(bio) + + def _public_key_bytes(self, encoding, format, key, evp_pkey, cdata): + if not isinstance(encoding, serialization.Encoding): + raise TypeError("encoding must be an item from the Encoding enum") + if not isinstance(format, serialization.PublicFormat): + raise TypeError( + "format must be an item from the PublicFormat enum" + ) + + # SubjectPublicKeyInfo + PEM/DER + if format is serialization.PublicFormat.SubjectPublicKeyInfo: + if encoding is serialization.Encoding.PEM: + write_bio = self._lib.PEM_write_bio_PUBKEY + elif encoding is serialization.Encoding.DER: + write_bio = self._lib.i2d_PUBKEY_bio + else: + raise ValueError( + "SubjectPublicKeyInfo works only with PEM or DER encoding" + ) + return self._bio_func_output(write_bio, evp_pkey) + + # PKCS1 + PEM/DER + if format is serialization.PublicFormat.PKCS1: + # Only RSA is supported here. + key_type = self._lib.EVP_PKEY_id(evp_pkey) + if key_type != self._lib.EVP_PKEY_RSA: + raise ValueError("PKCS1 format is supported only for RSA keys") + + if encoding is serialization.Encoding.PEM: + write_bio = self._lib.PEM_write_bio_RSAPublicKey + elif encoding is serialization.Encoding.DER: + write_bio = self._lib.i2d_RSAPublicKey_bio + else: + raise ValueError("PKCS1 works only with PEM or DER encoding") + return self._bio_func_output(write_bio, cdata) + + # OpenSSH + OpenSSH + if format is serialization.PublicFormat.OpenSSH: + if encoding is serialization.Encoding.OpenSSH: + return ssh.serialize_ssh_public_key(key) + + raise ValueError( + "OpenSSH format must be used with OpenSSH encoding" + ) + + # Anything that key-specific code was supposed to handle earlier, + # like Raw, CompressedPoint, UncompressedPoint + raise ValueError("format is invalid with this key") + + def _parameter_bytes(self, encoding, format, cdata): + if encoding is serialization.Encoding.OpenSSH: + raise TypeError("OpenSSH encoding is not supported") + + # Only DH is supported here currently. + q = self._ffi.new("BIGNUM **") + self._lib.DH_get0_pqg(cdata, self._ffi.NULL, q, self._ffi.NULL) + if encoding is serialization.Encoding.PEM: + if q[0] != self._ffi.NULL: + write_bio = self._lib.PEM_write_bio_DHxparams + else: + write_bio = self._lib.PEM_write_bio_DHparams + elif encoding is serialization.Encoding.DER: + if q[0] != self._ffi.NULL: + write_bio = self._lib.Cryptography_i2d_DHxparams_bio + else: + write_bio = self._lib.i2d_DHparams_bio + else: + raise TypeError("encoding must be an item from the Encoding enum") + + bio = self._create_mem_bio_gc() + res = write_bio(bio, cdata) + self.openssl_assert(res == 1) + return self._read_mem_bio(bio) + + def generate_dh_parameters(self, generator, key_size): + if key_size < dh._MIN_MODULUS_SIZE: + raise ValueError( + "DH key_size must be at least {} bits".format( + dh._MIN_MODULUS_SIZE + ) + ) + + if generator not in (2, 5): + raise ValueError("DH generator must be 2 or 5") + + dh_param_cdata = self._lib.DH_new() + self.openssl_assert(dh_param_cdata != self._ffi.NULL) + dh_param_cdata = self._ffi.gc(dh_param_cdata, self._lib.DH_free) + + res = self._lib.DH_generate_parameters_ex( + dh_param_cdata, key_size, generator, self._ffi.NULL + ) + self.openssl_assert(res == 1) + + return _DHParameters(self, dh_param_cdata) + + def _dh_cdata_to_evp_pkey(self, dh_cdata): + evp_pkey = self._create_evp_pkey_gc() + res = self._lib.EVP_PKEY_set1_DH(evp_pkey, dh_cdata) + self.openssl_assert(res == 1) + return evp_pkey + + def generate_dh_private_key(self, parameters): + dh_key_cdata = _dh_params_dup(parameters._dh_cdata, self) + + res = self._lib.DH_generate_key(dh_key_cdata) + self.openssl_assert(res == 1) + + evp_pkey = self._dh_cdata_to_evp_pkey(dh_key_cdata) + + return _DHPrivateKey(self, dh_key_cdata, evp_pkey) + + def generate_dh_private_key_and_parameters(self, generator, key_size): + return self.generate_dh_private_key( + self.generate_dh_parameters(generator, key_size) + ) + + def load_dh_private_numbers(self, numbers): + parameter_numbers = numbers.public_numbers.parameter_numbers + + dh_cdata = self._lib.DH_new() + self.openssl_assert(dh_cdata != self._ffi.NULL) + dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free) + + p = self._int_to_bn(parameter_numbers.p) + g = self._int_to_bn(parameter_numbers.g) + + if parameter_numbers.q is not None: + q = self._int_to_bn(parameter_numbers.q) + else: + q = self._ffi.NULL + + pub_key = self._int_to_bn(numbers.public_numbers.y) + priv_key = self._int_to_bn(numbers.x) + + res = self._lib.DH_set0_pqg(dh_cdata, p, q, g) + self.openssl_assert(res == 1) + + res = self._lib.DH_set0_key(dh_cdata, pub_key, priv_key) + self.openssl_assert(res == 1) + + codes = self._ffi.new("int[]", 1) + res = self._lib.Cryptography_DH_check(dh_cdata, codes) + self.openssl_assert(res == 1) + + # DH_check will return DH_NOT_SUITABLE_GENERATOR if p % 24 does not + # equal 11 when the generator is 2 (a quadratic nonresidue). + # We want to ignore that error because p % 24 == 23 is also fine. + # Specifically, g is then a quadratic residue. Within the context of + # Diffie-Hellman this means it can only generate half the possible + # values. That sounds bad, but quadratic nonresidues leak a bit of + # the key to the attacker in exchange for having the full key space + # available. See: https://crypto.stackexchange.com/questions/12961 + if codes[0] != 0 and not ( + parameter_numbers.g == 2 + and codes[0] ^ self._lib.DH_NOT_SUITABLE_GENERATOR == 0 + ): + raise ValueError("DH private numbers did not pass safety checks.") + + evp_pkey = self._dh_cdata_to_evp_pkey(dh_cdata) + + return _DHPrivateKey(self, dh_cdata, evp_pkey) + + def load_dh_public_numbers(self, numbers): + dh_cdata = self._lib.DH_new() + self.openssl_assert(dh_cdata != self._ffi.NULL) + dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free) + + parameter_numbers = numbers.parameter_numbers + + p = self._int_to_bn(parameter_numbers.p) + g = self._int_to_bn(parameter_numbers.g) + + if parameter_numbers.q is not None: + q = self._int_to_bn(parameter_numbers.q) + else: + q = self._ffi.NULL + + pub_key = self._int_to_bn(numbers.y) + + res = self._lib.DH_set0_pqg(dh_cdata, p, q, g) + self.openssl_assert(res == 1) + + res = self._lib.DH_set0_key(dh_cdata, pub_key, self._ffi.NULL) + self.openssl_assert(res == 1) + + evp_pkey = self._dh_cdata_to_evp_pkey(dh_cdata) + + return _DHPublicKey(self, dh_cdata, evp_pkey) + + def load_dh_parameter_numbers(self, numbers): + dh_cdata = self._lib.DH_new() + self.openssl_assert(dh_cdata != self._ffi.NULL) + dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free) + + p = self._int_to_bn(numbers.p) + g = self._int_to_bn(numbers.g) + + if numbers.q is not None: + q = self._int_to_bn(numbers.q) + else: + q = self._ffi.NULL + + res = self._lib.DH_set0_pqg(dh_cdata, p, q, g) + self.openssl_assert(res == 1) + + return _DHParameters(self, dh_cdata) + + def dh_parameters_supported(self, p, g, q=None): + dh_cdata = self._lib.DH_new() + self.openssl_assert(dh_cdata != self._ffi.NULL) + dh_cdata = self._ffi.gc(dh_cdata, self._lib.DH_free) + + p = self._int_to_bn(p) + g = self._int_to_bn(g) + + if q is not None: + q = self._int_to_bn(q) + else: + q = self._ffi.NULL + + res = self._lib.DH_set0_pqg(dh_cdata, p, q, g) + self.openssl_assert(res == 1) + + codes = self._ffi.new("int[]", 1) + res = self._lib.Cryptography_DH_check(dh_cdata, codes) + self.openssl_assert(res == 1) + + return codes[0] == 0 + + def dh_x942_serialization_supported(self): + return self._lib.Cryptography_HAS_EVP_PKEY_DHX == 1 + + def x509_name_bytes(self, name): + x509_name = _encode_name_gc(self, name) + pp = self._ffi.new("unsigned char **") + res = self._lib.i2d_X509_NAME(x509_name, pp) + self.openssl_assert(pp[0] != self._ffi.NULL) + pp = self._ffi.gc( + pp, lambda pointer: self._lib.OPENSSL_free(pointer[0]) + ) + self.openssl_assert(res > 0) + return self._ffi.buffer(pp[0], res)[:] + + def x25519_load_public_bytes(self, data): + # When we drop support for CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 we can + # switch this to EVP_PKEY_new_raw_public_key + if len(data) != 32: + raise ValueError("An X25519 public key is 32 bytes long") + + evp_pkey = self._create_evp_pkey_gc() + res = self._lib.EVP_PKEY_set_type(evp_pkey, self._lib.NID_X25519) + self.openssl_assert(res == 1) + res = self._lib.EVP_PKEY_set1_tls_encodedpoint( + evp_pkey, data, len(data) + ) + self.openssl_assert(res == 1) + return _X25519PublicKey(self, evp_pkey) + + def x25519_load_private_bytes(self, data): + # When we drop support for CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 we can + # switch this to EVP_PKEY_new_raw_private_key and drop the + # zeroed_bytearray garbage. + # OpenSSL only has facilities for loading PKCS8 formatted private + # keys using the algorithm identifiers specified in + # https://tools.ietf.org/html/draft-ietf-curdle-pkix-09. + # This is the standard PKCS8 prefix for a 32 byte X25519 key. + # The form is: + # 0:d=0 hl=2 l= 46 cons: SEQUENCE + # 2:d=1 hl=2 l= 1 prim: INTEGER :00 + # 5:d=1 hl=2 l= 5 cons: SEQUENCE + # 7:d=2 hl=2 l= 3 prim: OBJECT :1.3.101.110 + # 12:d=1 hl=2 l= 34 prim: OCTET STRING (the key) + # Of course there's a bit more complexity. In reality OCTET STRING + # contains an OCTET STRING of length 32! So the last two bytes here + # are \x04\x20, which is an OCTET STRING of length 32. + if len(data) != 32: + raise ValueError("An X25519 private key is 32 bytes long") + + pkcs8_prefix = b'0.\x02\x01\x000\x05\x06\x03+en\x04"\x04 ' + with self._zeroed_bytearray(48) as ba: + ba[0:16] = pkcs8_prefix + ba[16:] = data + bio = self._bytes_to_bio(ba) + evp_pkey = self._lib.d2i_PrivateKey_bio(bio.bio, self._ffi.NULL) + + self.openssl_assert(evp_pkey != self._ffi.NULL) + evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free) + self.openssl_assert( + self._lib.EVP_PKEY_id(evp_pkey) == self._lib.EVP_PKEY_X25519 + ) + return _X25519PrivateKey(self, evp_pkey) + + def _evp_pkey_keygen_gc(self, nid): + evp_pkey_ctx = self._lib.EVP_PKEY_CTX_new_id(nid, self._ffi.NULL) + self.openssl_assert(evp_pkey_ctx != self._ffi.NULL) + evp_pkey_ctx = self._ffi.gc(evp_pkey_ctx, self._lib.EVP_PKEY_CTX_free) + res = self._lib.EVP_PKEY_keygen_init(evp_pkey_ctx) + self.openssl_assert(res == 1) + evp_ppkey = self._ffi.new("EVP_PKEY **") + res = self._lib.EVP_PKEY_keygen(evp_pkey_ctx, evp_ppkey) + self.openssl_assert(res == 1) + self.openssl_assert(evp_ppkey[0] != self._ffi.NULL) + evp_pkey = self._ffi.gc(evp_ppkey[0], self._lib.EVP_PKEY_free) + return evp_pkey + + def x25519_generate_key(self): + evp_pkey = self._evp_pkey_keygen_gc(self._lib.NID_X25519) + return _X25519PrivateKey(self, evp_pkey) + + def x25519_supported(self): + if self._fips_enabled: + return False + return not self._lib.CRYPTOGRAPHY_IS_LIBRESSL + + def x448_load_public_bytes(self, data): + if len(data) != 56: + raise ValueError("An X448 public key is 56 bytes long") + + evp_pkey = self._lib.EVP_PKEY_new_raw_public_key( + self._lib.NID_X448, self._ffi.NULL, data, len(data) + ) + self.openssl_assert(evp_pkey != self._ffi.NULL) + evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free) + return _X448PublicKey(self, evp_pkey) + + def x448_load_private_bytes(self, data): + if len(data) != 56: + raise ValueError("An X448 private key is 56 bytes long") + + data_ptr = self._ffi.from_buffer(data) + evp_pkey = self._lib.EVP_PKEY_new_raw_private_key( + self._lib.NID_X448, self._ffi.NULL, data_ptr, len(data) + ) + self.openssl_assert(evp_pkey != self._ffi.NULL) + evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free) + return _X448PrivateKey(self, evp_pkey) + + def x448_generate_key(self): + evp_pkey = self._evp_pkey_keygen_gc(self._lib.NID_X448) + return _X448PrivateKey(self, evp_pkey) + + def x448_supported(self): + if self._fips_enabled: + return False + return not self._lib.CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 + + def ed25519_supported(self): + if self._fips_enabled: + return False + return not self._lib.CRYPTOGRAPHY_OPENSSL_LESS_THAN_111B + + def ed25519_load_public_bytes(self, data): + utils._check_bytes("data", data) + + if len(data) != ed25519._ED25519_KEY_SIZE: + raise ValueError("An Ed25519 public key is 32 bytes long") + + evp_pkey = self._lib.EVP_PKEY_new_raw_public_key( + self._lib.NID_ED25519, self._ffi.NULL, data, len(data) + ) + self.openssl_assert(evp_pkey != self._ffi.NULL) + evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free) + + return _Ed25519PublicKey(self, evp_pkey) + + def ed25519_load_private_bytes(self, data): + if len(data) != ed25519._ED25519_KEY_SIZE: + raise ValueError("An Ed25519 private key is 32 bytes long") + + utils._check_byteslike("data", data) + data_ptr = self._ffi.from_buffer(data) + evp_pkey = self._lib.EVP_PKEY_new_raw_private_key( + self._lib.NID_ED25519, self._ffi.NULL, data_ptr, len(data) + ) + self.openssl_assert(evp_pkey != self._ffi.NULL) + evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free) + + return _Ed25519PrivateKey(self, evp_pkey) + + def ed25519_generate_key(self): + evp_pkey = self._evp_pkey_keygen_gc(self._lib.NID_ED25519) + return _Ed25519PrivateKey(self, evp_pkey) + + def ed448_supported(self): + if self._fips_enabled: + return False + return not self._lib.CRYPTOGRAPHY_OPENSSL_LESS_THAN_111B + + def ed448_load_public_bytes(self, data): + utils._check_bytes("data", data) + if len(data) != _ED448_KEY_SIZE: + raise ValueError("An Ed448 public key is 57 bytes long") + + evp_pkey = self._lib.EVP_PKEY_new_raw_public_key( + self._lib.NID_ED448, self._ffi.NULL, data, len(data) + ) + self.openssl_assert(evp_pkey != self._ffi.NULL) + evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free) + + return _Ed448PublicKey(self, evp_pkey) + + def ed448_load_private_bytes(self, data): + utils._check_byteslike("data", data) + if len(data) != _ED448_KEY_SIZE: + raise ValueError("An Ed448 private key is 57 bytes long") + + data_ptr = self._ffi.from_buffer(data) + evp_pkey = self._lib.EVP_PKEY_new_raw_private_key( + self._lib.NID_ED448, self._ffi.NULL, data_ptr, len(data) + ) + self.openssl_assert(evp_pkey != self._ffi.NULL) + evp_pkey = self._ffi.gc(evp_pkey, self._lib.EVP_PKEY_free) + + return _Ed448PrivateKey(self, evp_pkey) + + def ed448_generate_key(self): + evp_pkey = self._evp_pkey_keygen_gc(self._lib.NID_ED448) + return _Ed448PrivateKey(self, evp_pkey) + + def derive_scrypt(self, key_material, salt, length, n, r, p): + buf = self._ffi.new("unsigned char[]", length) + key_material_ptr = self._ffi.from_buffer(key_material) + res = self._lib.EVP_PBE_scrypt( + key_material_ptr, + len(key_material), + salt, + len(salt), + n, + r, + p, + scrypt._MEM_LIMIT, + buf, + length, + ) + if res != 1: + errors = self._consume_errors_with_text() + # memory required formula explained here: + # https://blog.filippo.io/the-scrypt-parameters/ + min_memory = 128 * n * r // (1024 ** 2) + raise MemoryError( + "Not enough memory to derive key. These parameters require" + " {} MB of memory.".format(min_memory), + errors, + ) + return self._ffi.buffer(buf)[:] + + def aead_cipher_supported(self, cipher): + cipher_name = aead._aead_cipher_name(cipher) + if self._fips_enabled and cipher_name not in self._fips_aead: + return False + return self._lib.EVP_get_cipherbyname(cipher_name) != self._ffi.NULL + + @contextlib.contextmanager + def _zeroed_bytearray(self, length): + """ + This method creates a bytearray, which we copy data into (hopefully + also from a mutable buffer that can be dynamically erased!), and then + zero when we're done. + """ + ba = bytearray(length) + try: + yield ba + finally: + self._zero_data(ba, length) + + def _zero_data(self, data, length): + # We clear things this way because at the moment we're not + # sure of a better way that can guarantee it overwrites the + # memory of a bytearray and doesn't just replace the underlying char *. + for i in range(length): + data[i] = 0 + + @contextlib.contextmanager + def _zeroed_null_terminated_buf(self, data): + """ + This method takes bytes, which can be a bytestring or a mutable + buffer like a bytearray, and yields a null-terminated version of that + data. This is required because PKCS12_parse doesn't take a length with + its password char * and ffi.from_buffer doesn't provide null + termination. So, to support zeroing the data via bytearray we + need to build this ridiculous construct that copies the memory, but + zeroes it after use. + """ + if data is None: + yield self._ffi.NULL + else: + data_len = len(data) + buf = self._ffi.new("char[]", data_len + 1) + self._ffi.memmove(buf, data, data_len) + try: + yield buf + finally: + # Cast to a uint8_t * so we can assign by integer + self._zero_data(self._ffi.cast("uint8_t *", buf), data_len) + + def load_key_and_certificates_from_pkcs12(self, data, password): + if password is not None: + utils._check_byteslike("password", password) + + bio = self._bytes_to_bio(data) + p12 = self._lib.d2i_PKCS12_bio(bio.bio, self._ffi.NULL) + if p12 == self._ffi.NULL: + self._consume_errors() + raise ValueError("Could not deserialize PKCS12 data") + + p12 = self._ffi.gc(p12, self._lib.PKCS12_free) + evp_pkey_ptr = self._ffi.new("EVP_PKEY **") + x509_ptr = self._ffi.new("X509 **") + sk_x509_ptr = self._ffi.new("Cryptography_STACK_OF_X509 **") + with self._zeroed_null_terminated_buf(password) as password_buf: + res = self._lib.PKCS12_parse( + p12, password_buf, evp_pkey_ptr, x509_ptr, sk_x509_ptr + ) + + if res == 0: + self._consume_errors() + raise ValueError("Invalid password or PKCS12 data") + + cert = None + key = None + additional_certificates = [] + + if evp_pkey_ptr[0] != self._ffi.NULL: + evp_pkey = self._ffi.gc(evp_pkey_ptr[0], self._lib.EVP_PKEY_free) + key = self._evp_pkey_to_private_key(evp_pkey) + + if x509_ptr[0] != self._ffi.NULL: + x509 = self._ffi.gc(x509_ptr[0], self._lib.X509_free) + cert = _Certificate(self, x509) + + if sk_x509_ptr[0] != self._ffi.NULL: + sk_x509 = self._ffi.gc(sk_x509_ptr[0], self._lib.sk_X509_free) + num = self._lib.sk_X509_num(sk_x509_ptr[0]) + for i in range(num): + x509 = self._lib.sk_X509_value(sk_x509, i) + self.openssl_assert(x509 != self._ffi.NULL) + x509 = self._ffi.gc(x509, self._lib.X509_free) + additional_certificates.append(_Certificate(self, x509)) + + return (key, cert, additional_certificates) + + def serialize_key_and_certificates_to_pkcs12( + self, name, key, cert, cas, encryption_algorithm + ): + password = None + if name is not None: + utils._check_bytes("name", name) + + if isinstance(encryption_algorithm, serialization.NoEncryption): + nid_cert = -1 + nid_key = -1 + pkcs12_iter = 0 + mac_iter = 0 + elif isinstance( + encryption_algorithm, serialization.BestAvailableEncryption + ): + # PKCS12 encryption is hopeless trash and can never be fixed. + # This is the least terrible option. + nid_cert = self._lib.NID_pbe_WithSHA1And3_Key_TripleDES_CBC + nid_key = self._lib.NID_pbe_WithSHA1And3_Key_TripleDES_CBC + # At least we can set this higher than OpenSSL's default + pkcs12_iter = 20000 + # mac_iter chosen for compatibility reasons, see: + # https://www.openssl.org/docs/man1.1.1/man3/PKCS12_create.html + # Did we mention how lousy PKCS12 encryption is? + mac_iter = 1 + password = encryption_algorithm.password + else: + raise ValueError("Unsupported key encryption type") + + if cas is None or len(cas) == 0: + sk_x509 = self._ffi.NULL + else: + sk_x509 = self._lib.sk_X509_new_null() + sk_x509 = self._ffi.gc(sk_x509, self._lib.sk_X509_free) + + # reverse the list when building the stack so that they're encoded + # in the order they were originally provided. it is a mystery + for ca in reversed(cas): + res = self._lib.sk_X509_push(sk_x509, ca._x509) + backend.openssl_assert(res >= 1) + + with self._zeroed_null_terminated_buf(password) as password_buf: + with self._zeroed_null_terminated_buf(name) as name_buf: + p12 = self._lib.PKCS12_create( + password_buf, + name_buf, + key._evp_pkey if key else self._ffi.NULL, + cert._x509 if cert else self._ffi.NULL, + sk_x509, + nid_key, + nid_cert, + pkcs12_iter, + mac_iter, + 0, + ) + + self.openssl_assert(p12 != self._ffi.NULL) + p12 = self._ffi.gc(p12, self._lib.PKCS12_free) + + bio = self._create_mem_bio_gc() + res = self._lib.i2d_PKCS12_bio(bio, p12) + self.openssl_assert(res > 0) + return self._read_mem_bio(bio) + + def poly1305_supported(self): + if self._fips_enabled: + return False + return self._lib.Cryptography_HAS_POLY1305 == 1 + + def create_poly1305_ctx(self, key): + utils._check_byteslike("key", key) + if len(key) != _POLY1305_KEY_SIZE: + raise ValueError("A poly1305 key is 32 bytes long") + + return _Poly1305Context(self, key) + + def load_pem_pkcs7_certificates(self, data): + utils._check_bytes("data", data) + bio = self._bytes_to_bio(data) + p7 = self._lib.PEM_read_bio_PKCS7( + bio.bio, self._ffi.NULL, self._ffi.NULL, self._ffi.NULL + ) + if p7 == self._ffi.NULL: + self._consume_errors() + raise ValueError("Unable to parse PKCS7 data") + + p7 = self._ffi.gc(p7, self._lib.PKCS7_free) + return self._load_pkcs7_certificates(p7) + + def load_der_pkcs7_certificates(self, data): + utils._check_bytes("data", data) + bio = self._bytes_to_bio(data) + p7 = self._lib.d2i_PKCS7_bio(bio.bio, self._ffi.NULL) + if p7 == self._ffi.NULL: + self._consume_errors() + raise ValueError("Unable to parse PKCS7 data") + + p7 = self._ffi.gc(p7, self._lib.PKCS7_free) + return self._load_pkcs7_certificates(p7) + + def _load_pkcs7_certificates(self, p7): + nid = self._lib.OBJ_obj2nid(p7.type) + self.openssl_assert(nid != self._lib.NID_undef) + if nid != self._lib.NID_pkcs7_signed: + raise UnsupportedAlgorithm( + "Only basic signed structures are currently supported. NID" + " for this data was {}".format(nid), + _Reasons.UNSUPPORTED_SERIALIZATION, + ) + + sk_x509 = p7.d.sign.cert + num = self._lib.sk_X509_num(sk_x509) + certs = [] + for i in range(num): + x509 = self._lib.sk_X509_value(sk_x509, i) + self.openssl_assert(x509 != self._ffi.NULL) + res = self._lib.X509_up_ref(x509) + # When OpenSSL is less than 1.1.0 up_ref returns the current + # refcount. On 1.1.0+ it returns 1 for success. + self.openssl_assert(res >= 1) + x509 = self._ffi.gc(x509, self._lib.X509_free) + certs.append(_Certificate(self, x509)) + + return certs + + def pkcs7_sign(self, builder, encoding, options): + bio = self._bytes_to_bio(builder._data) + init_flags = self._lib.PKCS7_PARTIAL + final_flags = 0 + + if len(builder._additional_certs) == 0: + certs = self._ffi.NULL + else: + certs = self._lib.sk_X509_new_null() + certs = self._ffi.gc(certs, self._lib.sk_X509_free) + for cert in builder._additional_certs: + res = self._lib.sk_X509_push(certs, cert._x509) + self.openssl_assert(res >= 1) + + if pkcs7.PKCS7Options.DetachedSignature in options: + # Don't embed the data in the PKCS7 structure + init_flags |= self._lib.PKCS7_DETACHED + final_flags |= self._lib.PKCS7_DETACHED + + # This just inits a structure for us. However, there + # are flags we need to set, joy. + p7 = self._lib.PKCS7_sign( + self._ffi.NULL, + self._ffi.NULL, + certs, + self._ffi.NULL, + init_flags, + ) + self.openssl_assert(p7 != self._ffi.NULL) + p7 = self._ffi.gc(p7, self._lib.PKCS7_free) + signer_flags = 0 + # These flags are configurable on a per-signature basis + # but we've deliberately chosen to make the API only allow + # setting it across all signatures for now. + if pkcs7.PKCS7Options.NoCapabilities in options: + signer_flags |= self._lib.PKCS7_NOSMIMECAP + elif pkcs7.PKCS7Options.NoAttributes in options: + signer_flags |= self._lib.PKCS7_NOATTR + + if pkcs7.PKCS7Options.NoCerts in options: + signer_flags |= self._lib.PKCS7_NOCERTS + + for certificate, private_key, hash_algorithm in builder._signers: + md = self._evp_md_non_null_from_algorithm(hash_algorithm) + p7signerinfo = self._lib.PKCS7_sign_add_signer( + p7, certificate._x509, private_key._evp_pkey, md, signer_flags + ) + self.openssl_assert(p7signerinfo != self._ffi.NULL) + + for option in options: + # DetachedSignature, NoCapabilities, and NoAttributes are already + # handled so we just need to check these last two options. + if option is pkcs7.PKCS7Options.Text: + final_flags |= self._lib.PKCS7_TEXT + elif option is pkcs7.PKCS7Options.Binary: + final_flags |= self._lib.PKCS7_BINARY + + bio_out = self._create_mem_bio_gc() + if encoding is serialization.Encoding.SMIME: + # This finalizes the structure + res = self._lib.SMIME_write_PKCS7( + bio_out, p7, bio.bio, final_flags + ) + elif encoding is serialization.Encoding.PEM: + res = self._lib.PKCS7_final(p7, bio.bio, final_flags) + self.openssl_assert(res == 1) + res = self._lib.PEM_write_bio_PKCS7_stream( + bio_out, p7, bio.bio, final_flags + ) + else: + assert encoding is serialization.Encoding.DER + # We need to call finalize here becauase i2d_PKCS7_bio does not + # finalize. + res = self._lib.PKCS7_final(p7, bio.bio, final_flags) + self.openssl_assert(res == 1) + res = self._lib.i2d_PKCS7_bio(bio_out, p7) + self.openssl_assert(res == 1) + return self._read_mem_bio(bio_out) + + +class GetCipherByName(object): + def __init__(self, fmt): + self._fmt = fmt + + def __call__(self, backend, cipher, mode): + cipher_name = self._fmt.format(cipher=cipher, mode=mode).lower() + return backend._lib.EVP_get_cipherbyname(cipher_name.encode("ascii")) + + +def _get_xts_cipher(backend, cipher, mode): + cipher_name = "aes-{}-xts".format(cipher.key_size // 2) + return backend._lib.EVP_get_cipherbyname(cipher_name.encode("ascii")) + + +backend = Backend() diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ciphers.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ciphers.py new file mode 100644 index 0000000000..ad5dad3f7e --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ciphers.py @@ -0,0 +1,231 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.exceptions import InvalidTag, UnsupportedAlgorithm, _Reasons +from cryptography.hazmat.primitives import ciphers +from cryptography.hazmat.primitives.ciphers import modes + + +@utils.register_interface(ciphers.CipherContext) +@utils.register_interface(ciphers.AEADCipherContext) +@utils.register_interface(ciphers.AEADEncryptionContext) +@utils.register_interface(ciphers.AEADDecryptionContext) +class _CipherContext(object): + _ENCRYPT = 1 + _DECRYPT = 0 + _MAX_CHUNK_SIZE = 2 ** 30 - 1 + + def __init__(self, backend, cipher, mode, operation): + self._backend = backend + self._cipher = cipher + self._mode = mode + self._operation = operation + self._tag = None + + if isinstance(self._cipher, ciphers.BlockCipherAlgorithm): + self._block_size_bytes = self._cipher.block_size // 8 + else: + self._block_size_bytes = 1 + + ctx = self._backend._lib.EVP_CIPHER_CTX_new() + ctx = self._backend._ffi.gc( + ctx, self._backend._lib.EVP_CIPHER_CTX_free + ) + + registry = self._backend._cipher_registry + try: + adapter = registry[type(cipher), type(mode)] + except KeyError: + raise UnsupportedAlgorithm( + "cipher {} in {} mode is not supported " + "by this backend.".format( + cipher.name, mode.name if mode else mode + ), + _Reasons.UNSUPPORTED_CIPHER, + ) + + evp_cipher = adapter(self._backend, cipher, mode) + if evp_cipher == self._backend._ffi.NULL: + msg = "cipher {0.name} ".format(cipher) + if mode is not None: + msg += "in {0.name} mode ".format(mode) + msg += ( + "is not supported by this backend (Your version of OpenSSL " + "may be too old. Current version: {}.)" + ).format(self._backend.openssl_version_text()) + raise UnsupportedAlgorithm(msg, _Reasons.UNSUPPORTED_CIPHER) + + if isinstance(mode, modes.ModeWithInitializationVector): + iv_nonce = self._backend._ffi.from_buffer( + mode.initialization_vector + ) + elif isinstance(mode, modes.ModeWithTweak): + iv_nonce = self._backend._ffi.from_buffer(mode.tweak) + elif isinstance(mode, modes.ModeWithNonce): + iv_nonce = self._backend._ffi.from_buffer(mode.nonce) + elif isinstance(cipher, modes.ModeWithNonce): + iv_nonce = self._backend._ffi.from_buffer(cipher.nonce) + else: + iv_nonce = self._backend._ffi.NULL + # begin init with cipher and operation type + res = self._backend._lib.EVP_CipherInit_ex( + ctx, + evp_cipher, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + operation, + ) + self._backend.openssl_assert(res != 0) + # set the key length to handle variable key ciphers + res = self._backend._lib.EVP_CIPHER_CTX_set_key_length( + ctx, len(cipher.key) + ) + self._backend.openssl_assert(res != 0) + if isinstance(mode, modes.GCM): + res = self._backend._lib.EVP_CIPHER_CTX_ctrl( + ctx, + self._backend._lib.EVP_CTRL_AEAD_SET_IVLEN, + len(iv_nonce), + self._backend._ffi.NULL, + ) + self._backend.openssl_assert(res != 0) + if mode.tag is not None: + res = self._backend._lib.EVP_CIPHER_CTX_ctrl( + ctx, + self._backend._lib.EVP_CTRL_AEAD_SET_TAG, + len(mode.tag), + mode.tag, + ) + self._backend.openssl_assert(res != 0) + self._tag = mode.tag + + # pass key/iv + res = self._backend._lib.EVP_CipherInit_ex( + ctx, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._backend._ffi.from_buffer(cipher.key), + iv_nonce, + operation, + ) + self._backend.openssl_assert(res != 0) + # We purposely disable padding here as it's handled higher up in the + # API. + self._backend._lib.EVP_CIPHER_CTX_set_padding(ctx, 0) + self._ctx = ctx + + def update(self, data): + buf = bytearray(len(data) + self._block_size_bytes - 1) + n = self.update_into(data, buf) + return bytes(buf[:n]) + + def update_into(self, data, buf): + total_data_len = len(data) + if len(buf) < (total_data_len + self._block_size_bytes - 1): + raise ValueError( + "buffer must be at least {} bytes for this " + "payload".format(len(data) + self._block_size_bytes - 1) + ) + + data_processed = 0 + total_out = 0 + outlen = self._backend._ffi.new("int *") + baseoutbuf = self._backend._ffi.from_buffer(buf) + baseinbuf = self._backend._ffi.from_buffer(data) + + while data_processed != total_data_len: + outbuf = baseoutbuf + total_out + inbuf = baseinbuf + data_processed + inlen = min(self._MAX_CHUNK_SIZE, total_data_len - data_processed) + + res = self._backend._lib.EVP_CipherUpdate( + self._ctx, outbuf, outlen, inbuf, inlen + ) + self._backend.openssl_assert(res != 0) + data_processed += inlen + total_out += outlen[0] + + return total_out + + def finalize(self): + if ( + self._operation == self._DECRYPT + and isinstance(self._mode, modes.ModeWithAuthenticationTag) + and self.tag is None + ): + raise ValueError( + "Authentication tag must be provided when decrypting." + ) + + buf = self._backend._ffi.new("unsigned char[]", self._block_size_bytes) + outlen = self._backend._ffi.new("int *") + res = self._backend._lib.EVP_CipherFinal_ex(self._ctx, buf, outlen) + if res == 0: + errors = self._backend._consume_errors() + + if not errors and isinstance(self._mode, modes.GCM): + raise InvalidTag + + self._backend.openssl_assert( + errors[0]._lib_reason_match( + self._backend._lib.ERR_LIB_EVP, + self._backend._lib.EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH, + ), + errors=errors, + ) + raise ValueError( + "The length of the provided data is not a multiple of " + "the block length." + ) + + if ( + isinstance(self._mode, modes.GCM) + and self._operation == self._ENCRYPT + ): + tag_buf = self._backend._ffi.new( + "unsigned char[]", self._block_size_bytes + ) + res = self._backend._lib.EVP_CIPHER_CTX_ctrl( + self._ctx, + self._backend._lib.EVP_CTRL_AEAD_GET_TAG, + self._block_size_bytes, + tag_buf, + ) + self._backend.openssl_assert(res != 0) + self._tag = self._backend._ffi.buffer(tag_buf)[:] + + res = self._backend._lib.EVP_CIPHER_CTX_cleanup(self._ctx) + self._backend.openssl_assert(res == 1) + return self._backend._ffi.buffer(buf)[: outlen[0]] + + def finalize_with_tag(self, tag): + if len(tag) < self._mode._min_tag_length: + raise ValueError( + "Authentication tag must be {} bytes or longer.".format( + self._mode._min_tag_length + ) + ) + res = self._backend._lib.EVP_CIPHER_CTX_ctrl( + self._ctx, self._backend._lib.EVP_CTRL_AEAD_SET_TAG, len(tag), tag + ) + self._backend.openssl_assert(res != 0) + self._tag = tag + return self.finalize() + + def authenticate_additional_data(self, data): + outlen = self._backend._ffi.new("int *") + res = self._backend._lib.EVP_CipherUpdate( + self._ctx, + self._backend._ffi.NULL, + outlen, + self._backend._ffi.from_buffer(data), + len(data), + ) + self._backend.openssl_assert(res != 0) + + tag = utils.read_only_property("_tag") diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/cmac.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/cmac.py new file mode 100644 index 0000000000..195fc230f2 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/cmac.py @@ -0,0 +1,82 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + + +from cryptography import utils +from cryptography.exceptions import ( + InvalidSignature, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.primitives import constant_time +from cryptography.hazmat.primitives.ciphers.modes import CBC + + +class _CMACContext(object): + def __init__(self, backend, algorithm, ctx=None): + if not backend.cmac_algorithm_supported(algorithm): + raise UnsupportedAlgorithm( + "This backend does not support CMAC.", + _Reasons.UNSUPPORTED_CIPHER, + ) + + self._backend = backend + self._key = algorithm.key + self._algorithm = algorithm + self._output_length = algorithm.block_size // 8 + + if ctx is None: + registry = self._backend._cipher_registry + adapter = registry[type(algorithm), CBC] + + evp_cipher = adapter(self._backend, algorithm, CBC) + + ctx = self._backend._lib.CMAC_CTX_new() + + self._backend.openssl_assert(ctx != self._backend._ffi.NULL) + ctx = self._backend._ffi.gc(ctx, self._backend._lib.CMAC_CTX_free) + + key_ptr = self._backend._ffi.from_buffer(self._key) + res = self._backend._lib.CMAC_Init( + ctx, + key_ptr, + len(self._key), + evp_cipher, + self._backend._ffi.NULL, + ) + self._backend.openssl_assert(res == 1) + + self._ctx = ctx + + algorithm = utils.read_only_property("_algorithm") + + def update(self, data): + res = self._backend._lib.CMAC_Update(self._ctx, data, len(data)) + self._backend.openssl_assert(res == 1) + + def finalize(self): + buf = self._backend._ffi.new("unsigned char[]", self._output_length) + length = self._backend._ffi.new("size_t *", self._output_length) + res = self._backend._lib.CMAC_Final(self._ctx, buf, length) + self._backend.openssl_assert(res == 1) + + self._ctx = None + + return self._backend._ffi.buffer(buf)[:] + + def copy(self): + copied_ctx = self._backend._lib.CMAC_CTX_new() + copied_ctx = self._backend._ffi.gc( + copied_ctx, self._backend._lib.CMAC_CTX_free + ) + res = self._backend._lib.CMAC_CTX_copy(copied_ctx, self._ctx) + self._backend.openssl_assert(res == 1) + return _CMACContext(self._backend, self._algorithm, ctx=copied_ctx) + + def verify(self, signature): + digest = self.finalize() + if not constant_time.bytes_eq(digest, signature): + raise InvalidSignature("Signature did not match digest.") diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/decode_asn1.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/decode_asn1.py new file mode 100644 index 0000000000..cc9b8c0e34 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/decode_asn1.py @@ -0,0 +1,878 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import datetime +import ipaddress + +import six + +from cryptography import x509 +from cryptography.hazmat._der import DERReader, INTEGER, NULL, SEQUENCE +from cryptography.x509.extensions import _TLS_FEATURE_TYPE_TO_ENUM +from cryptography.x509.name import _ASN1_TYPE_TO_ENUM +from cryptography.x509.oid import ( + CRLEntryExtensionOID, + CertificatePoliciesOID, + ExtensionOID, + OCSPExtensionOID, +) + + +def _obj2txt(backend, obj): + # Set to 80 on the recommendation of + # https://www.openssl.org/docs/crypto/OBJ_nid2ln.html#return_values + # + # But OIDs longer than this occur in real life (e.g. Active + # Directory makes some very long OIDs). So we need to detect + # and properly handle the case where the default buffer is not + # big enough. + # + buf_len = 80 + buf = backend._ffi.new("char[]", buf_len) + + # 'res' is the number of bytes that *would* be written if the + # buffer is large enough. If 'res' > buf_len - 1, we need to + # alloc a big-enough buffer and go again. + res = backend._lib.OBJ_obj2txt(buf, buf_len, obj, 1) + if res > buf_len - 1: # account for terminating null byte + buf_len = res + 1 + buf = backend._ffi.new("char[]", buf_len) + res = backend._lib.OBJ_obj2txt(buf, buf_len, obj, 1) + backend.openssl_assert(res > 0) + return backend._ffi.buffer(buf, res)[:].decode() + + +def _decode_x509_name_entry(backend, x509_name_entry): + obj = backend._lib.X509_NAME_ENTRY_get_object(x509_name_entry) + backend.openssl_assert(obj != backend._ffi.NULL) + data = backend._lib.X509_NAME_ENTRY_get_data(x509_name_entry) + backend.openssl_assert(data != backend._ffi.NULL) + value = _asn1_string_to_utf8(backend, data) + oid = _obj2txt(backend, obj) + type = _ASN1_TYPE_TO_ENUM[data.type] + + return x509.NameAttribute(x509.ObjectIdentifier(oid), value, type) + + +def _decode_x509_name(backend, x509_name): + count = backend._lib.X509_NAME_entry_count(x509_name) + attributes = [] + prev_set_id = -1 + for x in range(count): + entry = backend._lib.X509_NAME_get_entry(x509_name, x) + attribute = _decode_x509_name_entry(backend, entry) + set_id = backend._lib.X509_NAME_ENTRY_set(entry) + if set_id != prev_set_id: + attributes.append({attribute}) + else: + # is in the same RDN a previous entry + attributes[-1].add(attribute) + prev_set_id = set_id + + return x509.Name(x509.RelativeDistinguishedName(rdn) for rdn in attributes) + + +def _decode_general_names(backend, gns): + num = backend._lib.sk_GENERAL_NAME_num(gns) + names = [] + for i in range(num): + gn = backend._lib.sk_GENERAL_NAME_value(gns, i) + backend.openssl_assert(gn != backend._ffi.NULL) + names.append(_decode_general_name(backend, gn)) + + return names + + +def _decode_general_name(backend, gn): + if gn.type == backend._lib.GEN_DNS: + # Convert to bytes and then decode to utf8. We don't use + # asn1_string_to_utf8 here because it doesn't properly convert + # utf8 from ia5strings. + data = _asn1_string_to_bytes(backend, gn.d.dNSName).decode("utf8") + # We don't use the constructor for DNSName so we can bypass validation + # This allows us to create DNSName objects that have unicode chars + # when a certificate (against the RFC) contains them. + return x509.DNSName._init_without_validation(data) + elif gn.type == backend._lib.GEN_URI: + # Convert to bytes and then decode to utf8. We don't use + # asn1_string_to_utf8 here because it doesn't properly convert + # utf8 from ia5strings. + data = _asn1_string_to_bytes( + backend, gn.d.uniformResourceIdentifier + ).decode("utf8") + # We don't use the constructor for URI so we can bypass validation + # This allows us to create URI objects that have unicode chars + # when a certificate (against the RFC) contains them. + return x509.UniformResourceIdentifier._init_without_validation(data) + elif gn.type == backend._lib.GEN_RID: + oid = _obj2txt(backend, gn.d.registeredID) + return x509.RegisteredID(x509.ObjectIdentifier(oid)) + elif gn.type == backend._lib.GEN_IPADD: + data = _asn1_string_to_bytes(backend, gn.d.iPAddress) + data_len = len(data) + if data_len == 8 or data_len == 32: + # This is an IPv4 or IPv6 Network and not a single IP. This + # type of data appears in Name Constraints. Unfortunately, + # ipaddress doesn't support packed bytes + netmask. Additionally, + # IPv6Network can only handle CIDR rather than the full 16 byte + # netmask. To handle this we convert the netmask to integer, then + # find the first 0 bit, which will be the prefix. If another 1 + # bit is present after that the netmask is invalid. + base = ipaddress.ip_address(data[: data_len // 2]) + netmask = ipaddress.ip_address(data[data_len // 2 :]) + bits = bin(int(netmask))[2:] + prefix = bits.find("0") + # If no 0 bits are found it is a /32 or /128 + if prefix == -1: + prefix = len(bits) + + if "1" in bits[prefix:]: + raise ValueError("Invalid netmask") + + ip = ipaddress.ip_network(base.exploded + u"/{}".format(prefix)) + else: + ip = ipaddress.ip_address(data) + + return x509.IPAddress(ip) + elif gn.type == backend._lib.GEN_DIRNAME: + return x509.DirectoryName( + _decode_x509_name(backend, gn.d.directoryName) + ) + elif gn.type == backend._lib.GEN_EMAIL: + # Convert to bytes and then decode to utf8. We don't use + # asn1_string_to_utf8 here because it doesn't properly convert + # utf8 from ia5strings. + data = _asn1_string_to_bytes(backend, gn.d.rfc822Name).decode("utf8") + # We don't use the constructor for RFC822Name so we can bypass + # validation. This allows us to create RFC822Name objects that have + # unicode chars when a certificate (against the RFC) contains them. + return x509.RFC822Name._init_without_validation(data) + elif gn.type == backend._lib.GEN_OTHERNAME: + type_id = _obj2txt(backend, gn.d.otherName.type_id) + value = _asn1_to_der(backend, gn.d.otherName.value) + return x509.OtherName(x509.ObjectIdentifier(type_id), value) + else: + # x400Address or ediPartyName + raise x509.UnsupportedGeneralNameType( + "{} is not a supported type".format( + x509._GENERAL_NAMES.get(gn.type, gn.type) + ), + gn.type, + ) + + +def _decode_ocsp_no_check(backend, ext): + return x509.OCSPNoCheck() + + +def _decode_crl_number(backend, ext): + asn1_int = backend._ffi.cast("ASN1_INTEGER *", ext) + asn1_int = backend._ffi.gc(asn1_int, backend._lib.ASN1_INTEGER_free) + return x509.CRLNumber(_asn1_integer_to_int(backend, asn1_int)) + + +def _decode_delta_crl_indicator(backend, ext): + asn1_int = backend._ffi.cast("ASN1_INTEGER *", ext) + asn1_int = backend._ffi.gc(asn1_int, backend._lib.ASN1_INTEGER_free) + return x509.DeltaCRLIndicator(_asn1_integer_to_int(backend, asn1_int)) + + +class _X509ExtensionParser(object): + def __init__(self, backend, ext_count, get_ext, handlers): + self.ext_count = ext_count + self.get_ext = get_ext + self.handlers = handlers + self._backend = backend + + def parse(self, x509_obj): + extensions = [] + seen_oids = set() + for i in range(self.ext_count(x509_obj)): + ext = self.get_ext(x509_obj, i) + self._backend.openssl_assert(ext != self._backend._ffi.NULL) + crit = self._backend._lib.X509_EXTENSION_get_critical(ext) + critical = crit == 1 + oid = x509.ObjectIdentifier( + _obj2txt( + self._backend, + self._backend._lib.X509_EXTENSION_get_object(ext), + ) + ) + if oid in seen_oids: + raise x509.DuplicateExtension( + "Duplicate {} extension found".format(oid), oid + ) + + # These OIDs are only supported in OpenSSL 1.1.0+ but we want + # to support them in all versions of OpenSSL so we decode them + # ourselves. + if oid == ExtensionOID.TLS_FEATURE: + # The extension contents are a SEQUENCE OF INTEGERs. + data = self._backend._lib.X509_EXTENSION_get_data(ext) + data_bytes = _asn1_string_to_bytes(self._backend, data) + features = DERReader(data_bytes).read_single_element(SEQUENCE) + parsed = [] + while not features.is_empty(): + parsed.append(features.read_element(INTEGER).as_integer()) + # Map the features to their enum value. + value = x509.TLSFeature( + [_TLS_FEATURE_TYPE_TO_ENUM[x] for x in parsed] + ) + extensions.append(x509.Extension(oid, critical, value)) + seen_oids.add(oid) + continue + elif oid == ExtensionOID.PRECERT_POISON: + data = self._backend._lib.X509_EXTENSION_get_data(ext) + # The contents of the extension must be an ASN.1 NULL. + reader = DERReader(_asn1_string_to_bytes(self._backend, data)) + reader.read_single_element(NULL).check_empty() + extensions.append( + x509.Extension(oid, critical, x509.PrecertPoison()) + ) + seen_oids.add(oid) + continue + + try: + handler = self.handlers[oid] + except KeyError: + # Dump the DER payload into an UnrecognizedExtension object + data = self._backend._lib.X509_EXTENSION_get_data(ext) + self._backend.openssl_assert(data != self._backend._ffi.NULL) + der = self._backend._ffi.buffer(data.data, data.length)[:] + unrecognized = x509.UnrecognizedExtension(oid, der) + extensions.append(x509.Extension(oid, critical, unrecognized)) + else: + ext_data = self._backend._lib.X509V3_EXT_d2i(ext) + if ext_data == self._backend._ffi.NULL: + self._backend._consume_errors() + raise ValueError( + "The {} extension is invalid and can't be " + "parsed".format(oid) + ) + + value = handler(self._backend, ext_data) + extensions.append(x509.Extension(oid, critical, value)) + + seen_oids.add(oid) + + return x509.Extensions(extensions) + + +def _decode_certificate_policies(backend, cp): + cp = backend._ffi.cast("Cryptography_STACK_OF_POLICYINFO *", cp) + cp = backend._ffi.gc(cp, backend._lib.CERTIFICATEPOLICIES_free) + + num = backend._lib.sk_POLICYINFO_num(cp) + certificate_policies = [] + for i in range(num): + qualifiers = None + pi = backend._lib.sk_POLICYINFO_value(cp, i) + oid = x509.ObjectIdentifier(_obj2txt(backend, pi.policyid)) + if pi.qualifiers != backend._ffi.NULL: + qnum = backend._lib.sk_POLICYQUALINFO_num(pi.qualifiers) + qualifiers = [] + for j in range(qnum): + pqi = backend._lib.sk_POLICYQUALINFO_value(pi.qualifiers, j) + pqualid = x509.ObjectIdentifier(_obj2txt(backend, pqi.pqualid)) + if pqualid == CertificatePoliciesOID.CPS_QUALIFIER: + cpsuri = backend._ffi.buffer( + pqi.d.cpsuri.data, pqi.d.cpsuri.length + )[:].decode("ascii") + qualifiers.append(cpsuri) + else: + assert pqualid == CertificatePoliciesOID.CPS_USER_NOTICE + user_notice = _decode_user_notice( + backend, pqi.d.usernotice + ) + qualifiers.append(user_notice) + + certificate_policies.append(x509.PolicyInformation(oid, qualifiers)) + + return x509.CertificatePolicies(certificate_policies) + + +def _decode_user_notice(backend, un): + explicit_text = None + notice_reference = None + + if un.exptext != backend._ffi.NULL: + explicit_text = _asn1_string_to_utf8(backend, un.exptext) + + if un.noticeref != backend._ffi.NULL: + organization = _asn1_string_to_utf8(backend, un.noticeref.organization) + + num = backend._lib.sk_ASN1_INTEGER_num(un.noticeref.noticenos) + notice_numbers = [] + for i in range(num): + asn1_int = backend._lib.sk_ASN1_INTEGER_value( + un.noticeref.noticenos, i + ) + notice_num = _asn1_integer_to_int(backend, asn1_int) + notice_numbers.append(notice_num) + + notice_reference = x509.NoticeReference(organization, notice_numbers) + + return x509.UserNotice(notice_reference, explicit_text) + + +def _decode_basic_constraints(backend, bc_st): + basic_constraints = backend._ffi.cast("BASIC_CONSTRAINTS *", bc_st) + basic_constraints = backend._ffi.gc( + basic_constraints, backend._lib.BASIC_CONSTRAINTS_free + ) + # The byte representation of an ASN.1 boolean true is \xff. OpenSSL + # chooses to just map this to its ordinal value, so true is 255 and + # false is 0. + ca = basic_constraints.ca == 255 + path_length = _asn1_integer_to_int_or_none( + backend, basic_constraints.pathlen + ) + + return x509.BasicConstraints(ca, path_length) + + +def _decode_subject_key_identifier(backend, asn1_string): + asn1_string = backend._ffi.cast("ASN1_OCTET_STRING *", asn1_string) + asn1_string = backend._ffi.gc( + asn1_string, backend._lib.ASN1_OCTET_STRING_free + ) + return x509.SubjectKeyIdentifier( + backend._ffi.buffer(asn1_string.data, asn1_string.length)[:] + ) + + +def _decode_authority_key_identifier(backend, akid): + akid = backend._ffi.cast("AUTHORITY_KEYID *", akid) + akid = backend._ffi.gc(akid, backend._lib.AUTHORITY_KEYID_free) + key_identifier = None + authority_cert_issuer = None + + if akid.keyid != backend._ffi.NULL: + key_identifier = backend._ffi.buffer( + akid.keyid.data, akid.keyid.length + )[:] + + if akid.issuer != backend._ffi.NULL: + authority_cert_issuer = _decode_general_names(backend, akid.issuer) + + authority_cert_serial_number = _asn1_integer_to_int_or_none( + backend, akid.serial + ) + + return x509.AuthorityKeyIdentifier( + key_identifier, authority_cert_issuer, authority_cert_serial_number + ) + + +def _decode_information_access(backend, ia): + ia = backend._ffi.cast("Cryptography_STACK_OF_ACCESS_DESCRIPTION *", ia) + ia = backend._ffi.gc( + ia, + lambda x: backend._lib.sk_ACCESS_DESCRIPTION_pop_free( + x, + backend._ffi.addressof( + backend._lib._original_lib, "ACCESS_DESCRIPTION_free" + ), + ), + ) + num = backend._lib.sk_ACCESS_DESCRIPTION_num(ia) + access_descriptions = [] + for i in range(num): + ad = backend._lib.sk_ACCESS_DESCRIPTION_value(ia, i) + backend.openssl_assert(ad.method != backend._ffi.NULL) + oid = x509.ObjectIdentifier(_obj2txt(backend, ad.method)) + backend.openssl_assert(ad.location != backend._ffi.NULL) + gn = _decode_general_name(backend, ad.location) + access_descriptions.append(x509.AccessDescription(oid, gn)) + + return access_descriptions + + +def _decode_authority_information_access(backend, aia): + access_descriptions = _decode_information_access(backend, aia) + return x509.AuthorityInformationAccess(access_descriptions) + + +def _decode_subject_information_access(backend, aia): + access_descriptions = _decode_information_access(backend, aia) + return x509.SubjectInformationAccess(access_descriptions) + + +def _decode_key_usage(backend, bit_string): + bit_string = backend._ffi.cast("ASN1_BIT_STRING *", bit_string) + bit_string = backend._ffi.gc(bit_string, backend._lib.ASN1_BIT_STRING_free) + get_bit = backend._lib.ASN1_BIT_STRING_get_bit + digital_signature = get_bit(bit_string, 0) == 1 + content_commitment = get_bit(bit_string, 1) == 1 + key_encipherment = get_bit(bit_string, 2) == 1 + data_encipherment = get_bit(bit_string, 3) == 1 + key_agreement = get_bit(bit_string, 4) == 1 + key_cert_sign = get_bit(bit_string, 5) == 1 + crl_sign = get_bit(bit_string, 6) == 1 + encipher_only = get_bit(bit_string, 7) == 1 + decipher_only = get_bit(bit_string, 8) == 1 + return x509.KeyUsage( + digital_signature, + content_commitment, + key_encipherment, + data_encipherment, + key_agreement, + key_cert_sign, + crl_sign, + encipher_only, + decipher_only, + ) + + +def _decode_general_names_extension(backend, gns): + gns = backend._ffi.cast("GENERAL_NAMES *", gns) + gns = backend._ffi.gc(gns, backend._lib.GENERAL_NAMES_free) + general_names = _decode_general_names(backend, gns) + return general_names + + +def _decode_subject_alt_name(backend, ext): + return x509.SubjectAlternativeName( + _decode_general_names_extension(backend, ext) + ) + + +def _decode_issuer_alt_name(backend, ext): + return x509.IssuerAlternativeName( + _decode_general_names_extension(backend, ext) + ) + + +def _decode_name_constraints(backend, nc): + nc = backend._ffi.cast("NAME_CONSTRAINTS *", nc) + nc = backend._ffi.gc(nc, backend._lib.NAME_CONSTRAINTS_free) + permitted = _decode_general_subtrees(backend, nc.permittedSubtrees) + excluded = _decode_general_subtrees(backend, nc.excludedSubtrees) + return x509.NameConstraints( + permitted_subtrees=permitted, excluded_subtrees=excluded + ) + + +def _decode_general_subtrees(backend, stack_subtrees): + if stack_subtrees == backend._ffi.NULL: + return None + + num = backend._lib.sk_GENERAL_SUBTREE_num(stack_subtrees) + subtrees = [] + + for i in range(num): + obj = backend._lib.sk_GENERAL_SUBTREE_value(stack_subtrees, i) + backend.openssl_assert(obj != backend._ffi.NULL) + name = _decode_general_name(backend, obj.base) + subtrees.append(name) + + return subtrees + + +def _decode_issuing_dist_point(backend, idp): + idp = backend._ffi.cast("ISSUING_DIST_POINT *", idp) + idp = backend._ffi.gc(idp, backend._lib.ISSUING_DIST_POINT_free) + if idp.distpoint != backend._ffi.NULL: + full_name, relative_name = _decode_distpoint(backend, idp.distpoint) + else: + full_name = None + relative_name = None + + only_user = idp.onlyuser == 255 + only_ca = idp.onlyCA == 255 + indirect_crl = idp.indirectCRL == 255 + only_attr = idp.onlyattr == 255 + if idp.onlysomereasons != backend._ffi.NULL: + only_some_reasons = _decode_reasons(backend, idp.onlysomereasons) + else: + only_some_reasons = None + + return x509.IssuingDistributionPoint( + full_name, + relative_name, + only_user, + only_ca, + only_some_reasons, + indirect_crl, + only_attr, + ) + + +def _decode_policy_constraints(backend, pc): + pc = backend._ffi.cast("POLICY_CONSTRAINTS *", pc) + pc = backend._ffi.gc(pc, backend._lib.POLICY_CONSTRAINTS_free) + + require_explicit_policy = _asn1_integer_to_int_or_none( + backend, pc.requireExplicitPolicy + ) + inhibit_policy_mapping = _asn1_integer_to_int_or_none( + backend, pc.inhibitPolicyMapping + ) + + return x509.PolicyConstraints( + require_explicit_policy, inhibit_policy_mapping + ) + + +def _decode_extended_key_usage(backend, sk): + sk = backend._ffi.cast("Cryptography_STACK_OF_ASN1_OBJECT *", sk) + sk = backend._ffi.gc(sk, backend._lib.sk_ASN1_OBJECT_free) + num = backend._lib.sk_ASN1_OBJECT_num(sk) + ekus = [] + + for i in range(num): + obj = backend._lib.sk_ASN1_OBJECT_value(sk, i) + backend.openssl_assert(obj != backend._ffi.NULL) + oid = x509.ObjectIdentifier(_obj2txt(backend, obj)) + ekus.append(oid) + + return x509.ExtendedKeyUsage(ekus) + + +_DISTPOINT_TYPE_FULLNAME = 0 +_DISTPOINT_TYPE_RELATIVENAME = 1 + + +def _decode_dist_points(backend, cdps): + cdps = backend._ffi.cast("Cryptography_STACK_OF_DIST_POINT *", cdps) + cdps = backend._ffi.gc(cdps, backend._lib.CRL_DIST_POINTS_free) + + num = backend._lib.sk_DIST_POINT_num(cdps) + dist_points = [] + for i in range(num): + full_name = None + relative_name = None + crl_issuer = None + reasons = None + cdp = backend._lib.sk_DIST_POINT_value(cdps, i) + if cdp.reasons != backend._ffi.NULL: + reasons = _decode_reasons(backend, cdp.reasons) + + if cdp.CRLissuer != backend._ffi.NULL: + crl_issuer = _decode_general_names(backend, cdp.CRLissuer) + + # Certificates may have a crl_issuer/reasons and no distribution + # point so make sure it's not null. + if cdp.distpoint != backend._ffi.NULL: + full_name, relative_name = _decode_distpoint( + backend, cdp.distpoint + ) + + dist_points.append( + x509.DistributionPoint( + full_name, relative_name, reasons, crl_issuer + ) + ) + + return dist_points + + +# ReasonFlags ::= BIT STRING { +# unused (0), +# keyCompromise (1), +# cACompromise (2), +# affiliationChanged (3), +# superseded (4), +# cessationOfOperation (5), +# certificateHold (6), +# privilegeWithdrawn (7), +# aACompromise (8) } +_REASON_BIT_MAPPING = { + 1: x509.ReasonFlags.key_compromise, + 2: x509.ReasonFlags.ca_compromise, + 3: x509.ReasonFlags.affiliation_changed, + 4: x509.ReasonFlags.superseded, + 5: x509.ReasonFlags.cessation_of_operation, + 6: x509.ReasonFlags.certificate_hold, + 7: x509.ReasonFlags.privilege_withdrawn, + 8: x509.ReasonFlags.aa_compromise, +} + + +def _decode_reasons(backend, reasons): + # We will check each bit from RFC 5280 + enum_reasons = [] + for bit_position, reason in six.iteritems(_REASON_BIT_MAPPING): + if backend._lib.ASN1_BIT_STRING_get_bit(reasons, bit_position): + enum_reasons.append(reason) + + return frozenset(enum_reasons) + + +def _decode_distpoint(backend, distpoint): + if distpoint.type == _DISTPOINT_TYPE_FULLNAME: + full_name = _decode_general_names(backend, distpoint.name.fullname) + return full_name, None + + # OpenSSL code doesn't test for a specific type for + # relativename, everything that isn't fullname is considered + # relativename. Per RFC 5280: + # + # DistributionPointName ::= CHOICE { + # fullName [0] GeneralNames, + # nameRelativeToCRLIssuer [1] RelativeDistinguishedName } + rns = distpoint.name.relativename + rnum = backend._lib.sk_X509_NAME_ENTRY_num(rns) + attributes = set() + for i in range(rnum): + rn = backend._lib.sk_X509_NAME_ENTRY_value(rns, i) + backend.openssl_assert(rn != backend._ffi.NULL) + attributes.add(_decode_x509_name_entry(backend, rn)) + + relative_name = x509.RelativeDistinguishedName(attributes) + + return None, relative_name + + +def _decode_crl_distribution_points(backend, cdps): + dist_points = _decode_dist_points(backend, cdps) + return x509.CRLDistributionPoints(dist_points) + + +def _decode_freshest_crl(backend, cdps): + dist_points = _decode_dist_points(backend, cdps) + return x509.FreshestCRL(dist_points) + + +def _decode_inhibit_any_policy(backend, asn1_int): + asn1_int = backend._ffi.cast("ASN1_INTEGER *", asn1_int) + asn1_int = backend._ffi.gc(asn1_int, backend._lib.ASN1_INTEGER_free) + skip_certs = _asn1_integer_to_int(backend, asn1_int) + return x509.InhibitAnyPolicy(skip_certs) + + +def _decode_scts(backend, asn1_scts): + from cryptography.hazmat.backends.openssl.x509 import ( + _SignedCertificateTimestamp, + ) + + asn1_scts = backend._ffi.cast("Cryptography_STACK_OF_SCT *", asn1_scts) + asn1_scts = backend._ffi.gc(asn1_scts, backend._lib.SCT_LIST_free) + + scts = [] + for i in range(backend._lib.sk_SCT_num(asn1_scts)): + sct = backend._lib.sk_SCT_value(asn1_scts, i) + + scts.append(_SignedCertificateTimestamp(backend, asn1_scts, sct)) + return scts + + +def _decode_precert_signed_certificate_timestamps(backend, asn1_scts): + return x509.PrecertificateSignedCertificateTimestamps( + _decode_scts(backend, asn1_scts) + ) + + +def _decode_signed_certificate_timestamps(backend, asn1_scts): + return x509.SignedCertificateTimestamps(_decode_scts(backend, asn1_scts)) + + +# CRLReason ::= ENUMERATED { +# unspecified (0), +# keyCompromise (1), +# cACompromise (2), +# affiliationChanged (3), +# superseded (4), +# cessationOfOperation (5), +# certificateHold (6), +# -- value 7 is not used +# removeFromCRL (8), +# privilegeWithdrawn (9), +# aACompromise (10) } +_CRL_ENTRY_REASON_CODE_TO_ENUM = { + 0: x509.ReasonFlags.unspecified, + 1: x509.ReasonFlags.key_compromise, + 2: x509.ReasonFlags.ca_compromise, + 3: x509.ReasonFlags.affiliation_changed, + 4: x509.ReasonFlags.superseded, + 5: x509.ReasonFlags.cessation_of_operation, + 6: x509.ReasonFlags.certificate_hold, + 8: x509.ReasonFlags.remove_from_crl, + 9: x509.ReasonFlags.privilege_withdrawn, + 10: x509.ReasonFlags.aa_compromise, +} + + +_CRL_ENTRY_REASON_ENUM_TO_CODE = { + x509.ReasonFlags.unspecified: 0, + x509.ReasonFlags.key_compromise: 1, + x509.ReasonFlags.ca_compromise: 2, + x509.ReasonFlags.affiliation_changed: 3, + x509.ReasonFlags.superseded: 4, + x509.ReasonFlags.cessation_of_operation: 5, + x509.ReasonFlags.certificate_hold: 6, + x509.ReasonFlags.remove_from_crl: 8, + x509.ReasonFlags.privilege_withdrawn: 9, + x509.ReasonFlags.aa_compromise: 10, +} + + +def _decode_crl_reason(backend, enum): + enum = backend._ffi.cast("ASN1_ENUMERATED *", enum) + enum = backend._ffi.gc(enum, backend._lib.ASN1_ENUMERATED_free) + code = backend._lib.ASN1_ENUMERATED_get(enum) + + try: + return x509.CRLReason(_CRL_ENTRY_REASON_CODE_TO_ENUM[code]) + except KeyError: + raise ValueError("Unsupported reason code: {}".format(code)) + + +def _decode_invalidity_date(backend, inv_date): + generalized_time = backend._ffi.cast("ASN1_GENERALIZEDTIME *", inv_date) + generalized_time = backend._ffi.gc( + generalized_time, backend._lib.ASN1_GENERALIZEDTIME_free + ) + return x509.InvalidityDate( + _parse_asn1_generalized_time(backend, generalized_time) + ) + + +def _decode_cert_issuer(backend, gns): + gns = backend._ffi.cast("GENERAL_NAMES *", gns) + gns = backend._ffi.gc(gns, backend._lib.GENERAL_NAMES_free) + general_names = _decode_general_names(backend, gns) + return x509.CertificateIssuer(general_names) + + +def _asn1_to_der(backend, asn1_type): + buf = backend._ffi.new("unsigned char **") + res = backend._lib.i2d_ASN1_TYPE(asn1_type, buf) + backend.openssl_assert(res >= 0) + backend.openssl_assert(buf[0] != backend._ffi.NULL) + buf = backend._ffi.gc( + buf, lambda buffer: backend._lib.OPENSSL_free(buffer[0]) + ) + return backend._ffi.buffer(buf[0], res)[:] + + +def _asn1_integer_to_int(backend, asn1_int): + bn = backend._lib.ASN1_INTEGER_to_BN(asn1_int, backend._ffi.NULL) + backend.openssl_assert(bn != backend._ffi.NULL) + bn = backend._ffi.gc(bn, backend._lib.BN_free) + return backend._bn_to_int(bn) + + +def _asn1_integer_to_int_or_none(backend, asn1_int): + if asn1_int == backend._ffi.NULL: + return None + else: + return _asn1_integer_to_int(backend, asn1_int) + + +def _asn1_string_to_bytes(backend, asn1_string): + return backend._ffi.buffer(asn1_string.data, asn1_string.length)[:] + + +def _asn1_string_to_ascii(backend, asn1_string): + return _asn1_string_to_bytes(backend, asn1_string).decode("ascii") + + +def _asn1_string_to_utf8(backend, asn1_string): + buf = backend._ffi.new("unsigned char **") + res = backend._lib.ASN1_STRING_to_UTF8(buf, asn1_string) + if res == -1: + raise ValueError( + "Unsupported ASN1 string type. Type: {}".format(asn1_string.type) + ) + + backend.openssl_assert(buf[0] != backend._ffi.NULL) + buf = backend._ffi.gc( + buf, lambda buffer: backend._lib.OPENSSL_free(buffer[0]) + ) + return backend._ffi.buffer(buf[0], res)[:].decode("utf8") + + +def _parse_asn1_time(backend, asn1_time): + backend.openssl_assert(asn1_time != backend._ffi.NULL) + generalized_time = backend._lib.ASN1_TIME_to_generalizedtime( + asn1_time, backend._ffi.NULL + ) + if generalized_time == backend._ffi.NULL: + raise ValueError( + "Couldn't parse ASN.1 time as generalizedtime {!r}".format( + _asn1_string_to_bytes(backend, asn1_time) + ) + ) + + generalized_time = backend._ffi.gc( + generalized_time, backend._lib.ASN1_GENERALIZEDTIME_free + ) + return _parse_asn1_generalized_time(backend, generalized_time) + + +def _parse_asn1_generalized_time(backend, generalized_time): + time = _asn1_string_to_ascii( + backend, backend._ffi.cast("ASN1_STRING *", generalized_time) + ) + return datetime.datetime.strptime(time, "%Y%m%d%H%M%SZ") + + +def _decode_nonce(backend, nonce): + nonce = backend._ffi.cast("ASN1_OCTET_STRING *", nonce) + nonce = backend._ffi.gc(nonce, backend._lib.ASN1_OCTET_STRING_free) + return x509.OCSPNonce(_asn1_string_to_bytes(backend, nonce)) + + +_EXTENSION_HANDLERS_BASE = { + ExtensionOID.BASIC_CONSTRAINTS: _decode_basic_constraints, + ExtensionOID.SUBJECT_KEY_IDENTIFIER: _decode_subject_key_identifier, + ExtensionOID.KEY_USAGE: _decode_key_usage, + ExtensionOID.SUBJECT_ALTERNATIVE_NAME: _decode_subject_alt_name, + ExtensionOID.EXTENDED_KEY_USAGE: _decode_extended_key_usage, + ExtensionOID.AUTHORITY_KEY_IDENTIFIER: _decode_authority_key_identifier, + ExtensionOID.AUTHORITY_INFORMATION_ACCESS: ( + _decode_authority_information_access + ), + ExtensionOID.SUBJECT_INFORMATION_ACCESS: ( + _decode_subject_information_access + ), + ExtensionOID.CERTIFICATE_POLICIES: _decode_certificate_policies, + ExtensionOID.CRL_DISTRIBUTION_POINTS: _decode_crl_distribution_points, + ExtensionOID.FRESHEST_CRL: _decode_freshest_crl, + ExtensionOID.OCSP_NO_CHECK: _decode_ocsp_no_check, + ExtensionOID.INHIBIT_ANY_POLICY: _decode_inhibit_any_policy, + ExtensionOID.ISSUER_ALTERNATIVE_NAME: _decode_issuer_alt_name, + ExtensionOID.NAME_CONSTRAINTS: _decode_name_constraints, + ExtensionOID.POLICY_CONSTRAINTS: _decode_policy_constraints, +} +_EXTENSION_HANDLERS_SCT = { + ExtensionOID.PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS: ( + _decode_precert_signed_certificate_timestamps + ) +} + +_REVOKED_EXTENSION_HANDLERS = { + CRLEntryExtensionOID.CRL_REASON: _decode_crl_reason, + CRLEntryExtensionOID.INVALIDITY_DATE: _decode_invalidity_date, + CRLEntryExtensionOID.CERTIFICATE_ISSUER: _decode_cert_issuer, +} + +_CRL_EXTENSION_HANDLERS = { + ExtensionOID.CRL_NUMBER: _decode_crl_number, + ExtensionOID.DELTA_CRL_INDICATOR: _decode_delta_crl_indicator, + ExtensionOID.AUTHORITY_KEY_IDENTIFIER: _decode_authority_key_identifier, + ExtensionOID.ISSUER_ALTERNATIVE_NAME: _decode_issuer_alt_name, + ExtensionOID.AUTHORITY_INFORMATION_ACCESS: ( + _decode_authority_information_access + ), + ExtensionOID.ISSUING_DISTRIBUTION_POINT: _decode_issuing_dist_point, + ExtensionOID.FRESHEST_CRL: _decode_freshest_crl, +} + +_OCSP_REQ_EXTENSION_HANDLERS = { + OCSPExtensionOID.NONCE: _decode_nonce, +} + +_OCSP_BASICRESP_EXTENSION_HANDLERS = { + OCSPExtensionOID.NONCE: _decode_nonce, +} + +_OCSP_SINGLERESP_EXTENSION_HANDLERS_SCT = { + ExtensionOID.SIGNED_CERTIFICATE_TIMESTAMPS: ( + _decode_signed_certificate_timestamps + ) +} diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/dh.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/dh.py new file mode 100644 index 0000000000..2862676c65 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/dh.py @@ -0,0 +1,271 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.exceptions import UnsupportedAlgorithm, _Reasons +from cryptography.hazmat.primitives import serialization +from cryptography.hazmat.primitives.asymmetric import dh + + +def _dh_params_dup(dh_cdata, backend): + lib = backend._lib + ffi = backend._ffi + + param_cdata = lib.DHparams_dup(dh_cdata) + backend.openssl_assert(param_cdata != ffi.NULL) + param_cdata = ffi.gc(param_cdata, lib.DH_free) + if lib.CRYPTOGRAPHY_IS_LIBRESSL: + # In libressl DHparams_dup don't copy q + q = ffi.new("BIGNUM **") + lib.DH_get0_pqg(dh_cdata, ffi.NULL, q, ffi.NULL) + q_dup = lib.BN_dup(q[0]) + res = lib.DH_set0_pqg(param_cdata, ffi.NULL, q_dup, ffi.NULL) + backend.openssl_assert(res == 1) + + return param_cdata + + +def _dh_cdata_to_parameters(dh_cdata, backend): + param_cdata = _dh_params_dup(dh_cdata, backend) + return _DHParameters(backend, param_cdata) + + +@utils.register_interface(dh.DHParametersWithSerialization) +class _DHParameters(object): + def __init__(self, backend, dh_cdata): + self._backend = backend + self._dh_cdata = dh_cdata + + def parameter_numbers(self): + p = self._backend._ffi.new("BIGNUM **") + g = self._backend._ffi.new("BIGNUM **") + q = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DH_get0_pqg(self._dh_cdata, p, q, g) + self._backend.openssl_assert(p[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(g[0] != self._backend._ffi.NULL) + if q[0] == self._backend._ffi.NULL: + q_val = None + else: + q_val = self._backend._bn_to_int(q[0]) + return dh.DHParameterNumbers( + p=self._backend._bn_to_int(p[0]), + g=self._backend._bn_to_int(g[0]), + q=q_val, + ) + + def generate_private_key(self): + return self._backend.generate_dh_private_key(self) + + def parameter_bytes(self, encoding, format): + if format is not serialization.ParameterFormat.PKCS3: + raise ValueError("Only PKCS3 serialization is supported") + if not self._backend._lib.Cryptography_HAS_EVP_PKEY_DHX: + q = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DH_get0_pqg( + self._dh_cdata, + self._backend._ffi.NULL, + q, + self._backend._ffi.NULL, + ) + if q[0] != self._backend._ffi.NULL: + raise UnsupportedAlgorithm( + "DH X9.42 serialization is not supported", + _Reasons.UNSUPPORTED_SERIALIZATION, + ) + + return self._backend._parameter_bytes(encoding, format, self._dh_cdata) + + +def _get_dh_num_bits(backend, dh_cdata): + p = backend._ffi.new("BIGNUM **") + backend._lib.DH_get0_pqg(dh_cdata, p, backend._ffi.NULL, backend._ffi.NULL) + backend.openssl_assert(p[0] != backend._ffi.NULL) + return backend._lib.BN_num_bits(p[0]) + + +@utils.register_interface(dh.DHPrivateKeyWithSerialization) +class _DHPrivateKey(object): + def __init__(self, backend, dh_cdata, evp_pkey): + self._backend = backend + self._dh_cdata = dh_cdata + self._evp_pkey = evp_pkey + self._key_size_bytes = self._backend._lib.DH_size(dh_cdata) + + @property + def key_size(self): + return _get_dh_num_bits(self._backend, self._dh_cdata) + + def private_numbers(self): + p = self._backend._ffi.new("BIGNUM **") + g = self._backend._ffi.new("BIGNUM **") + q = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DH_get0_pqg(self._dh_cdata, p, q, g) + self._backend.openssl_assert(p[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(g[0] != self._backend._ffi.NULL) + if q[0] == self._backend._ffi.NULL: + q_val = None + else: + q_val = self._backend._bn_to_int(q[0]) + pub_key = self._backend._ffi.new("BIGNUM **") + priv_key = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DH_get0_key(self._dh_cdata, pub_key, priv_key) + self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(priv_key[0] != self._backend._ffi.NULL) + return dh.DHPrivateNumbers( + public_numbers=dh.DHPublicNumbers( + parameter_numbers=dh.DHParameterNumbers( + p=self._backend._bn_to_int(p[0]), + g=self._backend._bn_to_int(g[0]), + q=q_val, + ), + y=self._backend._bn_to_int(pub_key[0]), + ), + x=self._backend._bn_to_int(priv_key[0]), + ) + + def exchange(self, peer_public_key): + + buf = self._backend._ffi.new("unsigned char[]", self._key_size_bytes) + pub_key = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DH_get0_key( + peer_public_key._dh_cdata, pub_key, self._backend._ffi.NULL + ) + self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL) + res = self._backend._lib.DH_compute_key( + buf, pub_key[0], self._dh_cdata + ) + + if res == -1: + errors_with_text = self._backend._consume_errors_with_text() + raise ValueError( + "Error computing shared key. Public key is likely invalid " + "for this exchange.", + errors_with_text, + ) + else: + self._backend.openssl_assert(res >= 1) + + key = self._backend._ffi.buffer(buf)[:res] + pad = self._key_size_bytes - len(key) + + if pad > 0: + key = (b"\x00" * pad) + key + + return key + + def public_key(self): + dh_cdata = _dh_params_dup(self._dh_cdata, self._backend) + pub_key = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DH_get0_key( + self._dh_cdata, pub_key, self._backend._ffi.NULL + ) + self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL) + pub_key_dup = self._backend._lib.BN_dup(pub_key[0]) + self._backend.openssl_assert(pub_key_dup != self._backend._ffi.NULL) + + res = self._backend._lib.DH_set0_key( + dh_cdata, pub_key_dup, self._backend._ffi.NULL + ) + self._backend.openssl_assert(res == 1) + evp_pkey = self._backend._dh_cdata_to_evp_pkey(dh_cdata) + return _DHPublicKey(self._backend, dh_cdata, evp_pkey) + + def parameters(self): + return _dh_cdata_to_parameters(self._dh_cdata, self._backend) + + def private_bytes(self, encoding, format, encryption_algorithm): + if format is not serialization.PrivateFormat.PKCS8: + raise ValueError( + "DH private keys support only PKCS8 serialization" + ) + if not self._backend._lib.Cryptography_HAS_EVP_PKEY_DHX: + q = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DH_get0_pqg( + self._dh_cdata, + self._backend._ffi.NULL, + q, + self._backend._ffi.NULL, + ) + if q[0] != self._backend._ffi.NULL: + raise UnsupportedAlgorithm( + "DH X9.42 serialization is not supported", + _Reasons.UNSUPPORTED_SERIALIZATION, + ) + + return self._backend._private_key_bytes( + encoding, + format, + encryption_algorithm, + self, + self._evp_pkey, + self._dh_cdata, + ) + + +@utils.register_interface(dh.DHPublicKeyWithSerialization) +class _DHPublicKey(object): + def __init__(self, backend, dh_cdata, evp_pkey): + self._backend = backend + self._dh_cdata = dh_cdata + self._evp_pkey = evp_pkey + self._key_size_bits = _get_dh_num_bits(self._backend, self._dh_cdata) + + @property + def key_size(self): + return self._key_size_bits + + def public_numbers(self): + p = self._backend._ffi.new("BIGNUM **") + g = self._backend._ffi.new("BIGNUM **") + q = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DH_get0_pqg(self._dh_cdata, p, q, g) + self._backend.openssl_assert(p[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(g[0] != self._backend._ffi.NULL) + if q[0] == self._backend._ffi.NULL: + q_val = None + else: + q_val = self._backend._bn_to_int(q[0]) + pub_key = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DH_get0_key( + self._dh_cdata, pub_key, self._backend._ffi.NULL + ) + self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL) + return dh.DHPublicNumbers( + parameter_numbers=dh.DHParameterNumbers( + p=self._backend._bn_to_int(p[0]), + g=self._backend._bn_to_int(g[0]), + q=q_val, + ), + y=self._backend._bn_to_int(pub_key[0]), + ) + + def parameters(self): + return _dh_cdata_to_parameters(self._dh_cdata, self._backend) + + def public_bytes(self, encoding, format): + if format is not serialization.PublicFormat.SubjectPublicKeyInfo: + raise ValueError( + "DH public keys support only " + "SubjectPublicKeyInfo serialization" + ) + + if not self._backend._lib.Cryptography_HAS_EVP_PKEY_DHX: + q = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DH_get0_pqg( + self._dh_cdata, + self._backend._ffi.NULL, + q, + self._backend._ffi.NULL, + ) + if q[0] != self._backend._ffi.NULL: + raise UnsupportedAlgorithm( + "DH X9.42 serialization is not supported", + _Reasons.UNSUPPORTED_SERIALIZATION, + ) + + return self._backend._public_key_bytes( + encoding, format, self, self._evp_pkey, None + ) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/dsa.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/dsa.py new file mode 100644 index 0000000000..0c5faba18a --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/dsa.py @@ -0,0 +1,263 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.exceptions import InvalidSignature +from cryptography.hazmat.backends.openssl.utils import ( + _calculate_digest_and_algorithm, + _check_not_prehashed, + _warn_sign_verify_deprecated, +) +from cryptography.hazmat.primitives import hashes +from cryptography.hazmat.primitives.asymmetric import ( + AsymmetricSignatureContext, + AsymmetricVerificationContext, + dsa, +) + + +def _dsa_sig_sign(backend, private_key, data): + sig_buf_len = backend._lib.DSA_size(private_key._dsa_cdata) + sig_buf = backend._ffi.new("unsigned char[]", sig_buf_len) + buflen = backend._ffi.new("unsigned int *") + + # The first parameter passed to DSA_sign is unused by OpenSSL but + # must be an integer. + res = backend._lib.DSA_sign( + 0, data, len(data), sig_buf, buflen, private_key._dsa_cdata + ) + backend.openssl_assert(res == 1) + backend.openssl_assert(buflen[0]) + + return backend._ffi.buffer(sig_buf)[: buflen[0]] + + +def _dsa_sig_verify(backend, public_key, signature, data): + # The first parameter passed to DSA_verify is unused by OpenSSL but + # must be an integer. + res = backend._lib.DSA_verify( + 0, data, len(data), signature, len(signature), public_key._dsa_cdata + ) + + if res != 1: + backend._consume_errors() + raise InvalidSignature + + +@utils.register_interface(AsymmetricVerificationContext) +class _DSAVerificationContext(object): + def __init__(self, backend, public_key, signature, algorithm): + self._backend = backend + self._public_key = public_key + self._signature = signature + self._algorithm = algorithm + + self._hash_ctx = hashes.Hash(self._algorithm, self._backend) + + def update(self, data): + self._hash_ctx.update(data) + + def verify(self): + data_to_verify = self._hash_ctx.finalize() + + _dsa_sig_verify( + self._backend, self._public_key, self._signature, data_to_verify + ) + + +@utils.register_interface(AsymmetricSignatureContext) +class _DSASignatureContext(object): + def __init__(self, backend, private_key, algorithm): + self._backend = backend + self._private_key = private_key + self._algorithm = algorithm + self._hash_ctx = hashes.Hash(self._algorithm, self._backend) + + def update(self, data): + self._hash_ctx.update(data) + + def finalize(self): + data_to_sign = self._hash_ctx.finalize() + return _dsa_sig_sign(self._backend, self._private_key, data_to_sign) + + +@utils.register_interface(dsa.DSAParametersWithNumbers) +class _DSAParameters(object): + def __init__(self, backend, dsa_cdata): + self._backend = backend + self._dsa_cdata = dsa_cdata + + def parameter_numbers(self): + p = self._backend._ffi.new("BIGNUM **") + q = self._backend._ffi.new("BIGNUM **") + g = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DSA_get0_pqg(self._dsa_cdata, p, q, g) + self._backend.openssl_assert(p[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(q[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(g[0] != self._backend._ffi.NULL) + return dsa.DSAParameterNumbers( + p=self._backend._bn_to_int(p[0]), + q=self._backend._bn_to_int(q[0]), + g=self._backend._bn_to_int(g[0]), + ) + + def generate_private_key(self): + return self._backend.generate_dsa_private_key(self) + + +@utils.register_interface(dsa.DSAPrivateKeyWithSerialization) +class _DSAPrivateKey(object): + def __init__(self, backend, dsa_cdata, evp_pkey): + self._backend = backend + self._dsa_cdata = dsa_cdata + self._evp_pkey = evp_pkey + + p = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DSA_get0_pqg( + dsa_cdata, p, self._backend._ffi.NULL, self._backend._ffi.NULL + ) + self._backend.openssl_assert(p[0] != backend._ffi.NULL) + self._key_size = self._backend._lib.BN_num_bits(p[0]) + + key_size = utils.read_only_property("_key_size") + + def signer(self, signature_algorithm): + _warn_sign_verify_deprecated() + _check_not_prehashed(signature_algorithm) + return _DSASignatureContext(self._backend, self, signature_algorithm) + + def private_numbers(self): + p = self._backend._ffi.new("BIGNUM **") + q = self._backend._ffi.new("BIGNUM **") + g = self._backend._ffi.new("BIGNUM **") + pub_key = self._backend._ffi.new("BIGNUM **") + priv_key = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DSA_get0_pqg(self._dsa_cdata, p, q, g) + self._backend.openssl_assert(p[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(q[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(g[0] != self._backend._ffi.NULL) + self._backend._lib.DSA_get0_key(self._dsa_cdata, pub_key, priv_key) + self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(priv_key[0] != self._backend._ffi.NULL) + return dsa.DSAPrivateNumbers( + public_numbers=dsa.DSAPublicNumbers( + parameter_numbers=dsa.DSAParameterNumbers( + p=self._backend._bn_to_int(p[0]), + q=self._backend._bn_to_int(q[0]), + g=self._backend._bn_to_int(g[0]), + ), + y=self._backend._bn_to_int(pub_key[0]), + ), + x=self._backend._bn_to_int(priv_key[0]), + ) + + def public_key(self): + dsa_cdata = self._backend._lib.DSAparams_dup(self._dsa_cdata) + self._backend.openssl_assert(dsa_cdata != self._backend._ffi.NULL) + dsa_cdata = self._backend._ffi.gc( + dsa_cdata, self._backend._lib.DSA_free + ) + pub_key = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DSA_get0_key( + self._dsa_cdata, pub_key, self._backend._ffi.NULL + ) + self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL) + pub_key_dup = self._backend._lib.BN_dup(pub_key[0]) + res = self._backend._lib.DSA_set0_key( + dsa_cdata, pub_key_dup, self._backend._ffi.NULL + ) + self._backend.openssl_assert(res == 1) + evp_pkey = self._backend._dsa_cdata_to_evp_pkey(dsa_cdata) + return _DSAPublicKey(self._backend, dsa_cdata, evp_pkey) + + def parameters(self): + dsa_cdata = self._backend._lib.DSAparams_dup(self._dsa_cdata) + self._backend.openssl_assert(dsa_cdata != self._backend._ffi.NULL) + dsa_cdata = self._backend._ffi.gc( + dsa_cdata, self._backend._lib.DSA_free + ) + return _DSAParameters(self._backend, dsa_cdata) + + def private_bytes(self, encoding, format, encryption_algorithm): + return self._backend._private_key_bytes( + encoding, + format, + encryption_algorithm, + self, + self._evp_pkey, + self._dsa_cdata, + ) + + def sign(self, data, algorithm): + data, algorithm = _calculate_digest_and_algorithm( + self._backend, data, algorithm + ) + return _dsa_sig_sign(self._backend, self, data) + + +@utils.register_interface(dsa.DSAPublicKeyWithSerialization) +class _DSAPublicKey(object): + def __init__(self, backend, dsa_cdata, evp_pkey): + self._backend = backend + self._dsa_cdata = dsa_cdata + self._evp_pkey = evp_pkey + p = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DSA_get0_pqg( + dsa_cdata, p, self._backend._ffi.NULL, self._backend._ffi.NULL + ) + self._backend.openssl_assert(p[0] != backend._ffi.NULL) + self._key_size = self._backend._lib.BN_num_bits(p[0]) + + key_size = utils.read_only_property("_key_size") + + def verifier(self, signature, signature_algorithm): + _warn_sign_verify_deprecated() + utils._check_bytes("signature", signature) + + _check_not_prehashed(signature_algorithm) + return _DSAVerificationContext( + self._backend, self, signature, signature_algorithm + ) + + def public_numbers(self): + p = self._backend._ffi.new("BIGNUM **") + q = self._backend._ffi.new("BIGNUM **") + g = self._backend._ffi.new("BIGNUM **") + pub_key = self._backend._ffi.new("BIGNUM **") + self._backend._lib.DSA_get0_pqg(self._dsa_cdata, p, q, g) + self._backend.openssl_assert(p[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(q[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(g[0] != self._backend._ffi.NULL) + self._backend._lib.DSA_get0_key( + self._dsa_cdata, pub_key, self._backend._ffi.NULL + ) + self._backend.openssl_assert(pub_key[0] != self._backend._ffi.NULL) + return dsa.DSAPublicNumbers( + parameter_numbers=dsa.DSAParameterNumbers( + p=self._backend._bn_to_int(p[0]), + q=self._backend._bn_to_int(q[0]), + g=self._backend._bn_to_int(g[0]), + ), + y=self._backend._bn_to_int(pub_key[0]), + ) + + def parameters(self): + dsa_cdata = self._backend._lib.DSAparams_dup(self._dsa_cdata) + dsa_cdata = self._backend._ffi.gc( + dsa_cdata, self._backend._lib.DSA_free + ) + return _DSAParameters(self._backend, dsa_cdata) + + def public_bytes(self, encoding, format): + return self._backend._public_key_bytes( + encoding, format, self, self._evp_pkey, None + ) + + def verify(self, signature, data, algorithm): + data, algorithm = _calculate_digest_and_algorithm( + self._backend, data, algorithm + ) + return _dsa_sig_verify(self._backend, self, signature, data) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ec.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ec.py new file mode 100644 index 0000000000..05d32baba6 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ec.py @@ -0,0 +1,337 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.exceptions import ( + InvalidSignature, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends.openssl.utils import ( + _calculate_digest_and_algorithm, + _check_not_prehashed, + _warn_sign_verify_deprecated, +) +from cryptography.hazmat.primitives import hashes, serialization +from cryptography.hazmat.primitives.asymmetric import ( + AsymmetricSignatureContext, + AsymmetricVerificationContext, + ec, +) + + +def _check_signature_algorithm(signature_algorithm): + if not isinstance(signature_algorithm, ec.ECDSA): + raise UnsupportedAlgorithm( + "Unsupported elliptic curve signature algorithm.", + _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, + ) + + +def _ec_key_curve_sn(backend, ec_key): + group = backend._lib.EC_KEY_get0_group(ec_key) + backend.openssl_assert(group != backend._ffi.NULL) + + nid = backend._lib.EC_GROUP_get_curve_name(group) + # The following check is to find EC keys with unnamed curves and raise + # an error for now. + if nid == backend._lib.NID_undef: + raise NotImplementedError( + "ECDSA keys with unnamed curves are unsupported at this time" + ) + + # This is like the above check, but it also catches the case where you + # explicitly encoded a curve with the same parameters as a named curve. + # Don't do that. + if ( + not backend._lib.CRYPTOGRAPHY_IS_LIBRESSL + and backend._lib.EC_GROUP_get_asn1_flag(group) == 0 + ): + raise NotImplementedError( + "ECDSA keys with unnamed curves are unsupported at this time" + ) + + curve_name = backend._lib.OBJ_nid2sn(nid) + backend.openssl_assert(curve_name != backend._ffi.NULL) + + sn = backend._ffi.string(curve_name).decode("ascii") + return sn + + +def _mark_asn1_named_ec_curve(backend, ec_cdata): + """ + Set the named curve flag on the EC_KEY. This causes OpenSSL to + serialize EC keys along with their curve OID which makes + deserialization easier. + """ + + backend._lib.EC_KEY_set_asn1_flag( + ec_cdata, backend._lib.OPENSSL_EC_NAMED_CURVE + ) + + +def _sn_to_elliptic_curve(backend, sn): + try: + return ec._CURVE_TYPES[sn]() + except KeyError: + raise UnsupportedAlgorithm( + "{} is not a supported elliptic curve".format(sn), + _Reasons.UNSUPPORTED_ELLIPTIC_CURVE, + ) + + +def _ecdsa_sig_sign(backend, private_key, data): + max_size = backend._lib.ECDSA_size(private_key._ec_key) + backend.openssl_assert(max_size > 0) + + sigbuf = backend._ffi.new("unsigned char[]", max_size) + siglen_ptr = backend._ffi.new("unsigned int[]", 1) + res = backend._lib.ECDSA_sign( + 0, data, len(data), sigbuf, siglen_ptr, private_key._ec_key + ) + backend.openssl_assert(res == 1) + return backend._ffi.buffer(sigbuf)[: siglen_ptr[0]] + + +def _ecdsa_sig_verify(backend, public_key, signature, data): + res = backend._lib.ECDSA_verify( + 0, data, len(data), signature, len(signature), public_key._ec_key + ) + if res != 1: + backend._consume_errors() + raise InvalidSignature + + +@utils.register_interface(AsymmetricSignatureContext) +class _ECDSASignatureContext(object): + def __init__(self, backend, private_key, algorithm): + self._backend = backend + self._private_key = private_key + self._digest = hashes.Hash(algorithm, backend) + + def update(self, data): + self._digest.update(data) + + def finalize(self): + digest = self._digest.finalize() + + return _ecdsa_sig_sign(self._backend, self._private_key, digest) + + +@utils.register_interface(AsymmetricVerificationContext) +class _ECDSAVerificationContext(object): + def __init__(self, backend, public_key, signature, algorithm): + self._backend = backend + self._public_key = public_key + self._signature = signature + self._digest = hashes.Hash(algorithm, backend) + + def update(self, data): + self._digest.update(data) + + def verify(self): + digest = self._digest.finalize() + _ecdsa_sig_verify( + self._backend, self._public_key, self._signature, digest + ) + + +@utils.register_interface(ec.EllipticCurvePrivateKeyWithSerialization) +class _EllipticCurvePrivateKey(object): + def __init__(self, backend, ec_key_cdata, evp_pkey): + self._backend = backend + self._ec_key = ec_key_cdata + self._evp_pkey = evp_pkey + + sn = _ec_key_curve_sn(backend, ec_key_cdata) + self._curve = _sn_to_elliptic_curve(backend, sn) + _mark_asn1_named_ec_curve(backend, ec_key_cdata) + + curve = utils.read_only_property("_curve") + + @property + def key_size(self): + return self.curve.key_size + + def signer(self, signature_algorithm): + _warn_sign_verify_deprecated() + _check_signature_algorithm(signature_algorithm) + _check_not_prehashed(signature_algorithm.algorithm) + return _ECDSASignatureContext( + self._backend, self, signature_algorithm.algorithm + ) + + def exchange(self, algorithm, peer_public_key): + if not ( + self._backend.elliptic_curve_exchange_algorithm_supported( + algorithm, self.curve + ) + ): + raise UnsupportedAlgorithm( + "This backend does not support the ECDH algorithm.", + _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, + ) + + if peer_public_key.curve.name != self.curve.name: + raise ValueError( + "peer_public_key and self are not on the same curve" + ) + + group = self._backend._lib.EC_KEY_get0_group(self._ec_key) + z_len = (self._backend._lib.EC_GROUP_get_degree(group) + 7) // 8 + self._backend.openssl_assert(z_len > 0) + z_buf = self._backend._ffi.new("uint8_t[]", z_len) + peer_key = self._backend._lib.EC_KEY_get0_public_key( + peer_public_key._ec_key + ) + + r = self._backend._lib.ECDH_compute_key( + z_buf, z_len, peer_key, self._ec_key, self._backend._ffi.NULL + ) + self._backend.openssl_assert(r > 0) + return self._backend._ffi.buffer(z_buf)[:z_len] + + def public_key(self): + group = self._backend._lib.EC_KEY_get0_group(self._ec_key) + self._backend.openssl_assert(group != self._backend._ffi.NULL) + + curve_nid = self._backend._lib.EC_GROUP_get_curve_name(group) + public_ec_key = self._backend._ec_key_new_by_curve_nid(curve_nid) + + point = self._backend._lib.EC_KEY_get0_public_key(self._ec_key) + self._backend.openssl_assert(point != self._backend._ffi.NULL) + + res = self._backend._lib.EC_KEY_set_public_key(public_ec_key, point) + self._backend.openssl_assert(res == 1) + + evp_pkey = self._backend._ec_cdata_to_evp_pkey(public_ec_key) + + return _EllipticCurvePublicKey(self._backend, public_ec_key, evp_pkey) + + def private_numbers(self): + bn = self._backend._lib.EC_KEY_get0_private_key(self._ec_key) + private_value = self._backend._bn_to_int(bn) + return ec.EllipticCurvePrivateNumbers( + private_value=private_value, + public_numbers=self.public_key().public_numbers(), + ) + + def private_bytes(self, encoding, format, encryption_algorithm): + return self._backend._private_key_bytes( + encoding, + format, + encryption_algorithm, + self, + self._evp_pkey, + self._ec_key, + ) + + def sign(self, data, signature_algorithm): + _check_signature_algorithm(signature_algorithm) + data, algorithm = _calculate_digest_and_algorithm( + self._backend, data, signature_algorithm._algorithm + ) + return _ecdsa_sig_sign(self._backend, self, data) + + +@utils.register_interface(ec.EllipticCurvePublicKeyWithSerialization) +class _EllipticCurvePublicKey(object): + def __init__(self, backend, ec_key_cdata, evp_pkey): + self._backend = backend + self._ec_key = ec_key_cdata + self._evp_pkey = evp_pkey + + sn = _ec_key_curve_sn(backend, ec_key_cdata) + self._curve = _sn_to_elliptic_curve(backend, sn) + _mark_asn1_named_ec_curve(backend, ec_key_cdata) + + curve = utils.read_only_property("_curve") + + @property + def key_size(self): + return self.curve.key_size + + def verifier(self, signature, signature_algorithm): + _warn_sign_verify_deprecated() + utils._check_bytes("signature", signature) + + _check_signature_algorithm(signature_algorithm) + _check_not_prehashed(signature_algorithm.algorithm) + return _ECDSAVerificationContext( + self._backend, self, signature, signature_algorithm.algorithm + ) + + def public_numbers(self): + get_func, group = self._backend._ec_key_determine_group_get_func( + self._ec_key + ) + point = self._backend._lib.EC_KEY_get0_public_key(self._ec_key) + self._backend.openssl_assert(point != self._backend._ffi.NULL) + + with self._backend._tmp_bn_ctx() as bn_ctx: + bn_x = self._backend._lib.BN_CTX_get(bn_ctx) + bn_y = self._backend._lib.BN_CTX_get(bn_ctx) + + res = get_func(group, point, bn_x, bn_y, bn_ctx) + self._backend.openssl_assert(res == 1) + + x = self._backend._bn_to_int(bn_x) + y = self._backend._bn_to_int(bn_y) + + return ec.EllipticCurvePublicNumbers(x=x, y=y, curve=self._curve) + + def _encode_point(self, format): + if format is serialization.PublicFormat.CompressedPoint: + conversion = self._backend._lib.POINT_CONVERSION_COMPRESSED + else: + assert format is serialization.PublicFormat.UncompressedPoint + conversion = self._backend._lib.POINT_CONVERSION_UNCOMPRESSED + + group = self._backend._lib.EC_KEY_get0_group(self._ec_key) + self._backend.openssl_assert(group != self._backend._ffi.NULL) + point = self._backend._lib.EC_KEY_get0_public_key(self._ec_key) + self._backend.openssl_assert(point != self._backend._ffi.NULL) + with self._backend._tmp_bn_ctx() as bn_ctx: + buflen = self._backend._lib.EC_POINT_point2oct( + group, point, conversion, self._backend._ffi.NULL, 0, bn_ctx + ) + self._backend.openssl_assert(buflen > 0) + buf = self._backend._ffi.new("char[]", buflen) + res = self._backend._lib.EC_POINT_point2oct( + group, point, conversion, buf, buflen, bn_ctx + ) + self._backend.openssl_assert(buflen == res) + + return self._backend._ffi.buffer(buf)[:] + + def public_bytes(self, encoding, format): + + if ( + encoding is serialization.Encoding.X962 + or format is serialization.PublicFormat.CompressedPoint + or format is serialization.PublicFormat.UncompressedPoint + ): + if encoding is not serialization.Encoding.X962 or format not in ( + serialization.PublicFormat.CompressedPoint, + serialization.PublicFormat.UncompressedPoint, + ): + raise ValueError( + "X962 encoding must be used with CompressedPoint or " + "UncompressedPoint format" + ) + + return self._encode_point(format) + else: + return self._backend._public_key_bytes( + encoding, format, self, self._evp_pkey, None + ) + + def verify(self, signature, data, signature_algorithm): + _check_signature_algorithm(signature_algorithm) + data, algorithm = _calculate_digest_and_algorithm( + self._backend, data, signature_algorithm._algorithm + ) + _ecdsa_sig_verify(self._backend, self, signature, data) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ed25519.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ed25519.py new file mode 100644 index 0000000000..13bec3af10 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ed25519.py @@ -0,0 +1,145 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import exceptions, utils +from cryptography.hazmat.primitives import serialization +from cryptography.hazmat.primitives.asymmetric.ed25519 import ( + Ed25519PrivateKey, + Ed25519PublicKey, + _ED25519_KEY_SIZE, + _ED25519_SIG_SIZE, +) + + +@utils.register_interface(Ed25519PublicKey) +class _Ed25519PublicKey(object): + def __init__(self, backend, evp_pkey): + self._backend = backend + self._evp_pkey = evp_pkey + + def public_bytes(self, encoding, format): + if ( + encoding is serialization.Encoding.Raw + or format is serialization.PublicFormat.Raw + ): + if ( + encoding is not serialization.Encoding.Raw + or format is not serialization.PublicFormat.Raw + ): + raise ValueError( + "When using Raw both encoding and format must be Raw" + ) + + return self._raw_public_bytes() + + return self._backend._public_key_bytes( + encoding, format, self, self._evp_pkey, None + ) + + def _raw_public_bytes(self): + buf = self._backend._ffi.new("unsigned char []", _ED25519_KEY_SIZE) + buflen = self._backend._ffi.new("size_t *", _ED25519_KEY_SIZE) + res = self._backend._lib.EVP_PKEY_get_raw_public_key( + self._evp_pkey, buf, buflen + ) + self._backend.openssl_assert(res == 1) + self._backend.openssl_assert(buflen[0] == _ED25519_KEY_SIZE) + return self._backend._ffi.buffer(buf, _ED25519_KEY_SIZE)[:] + + def verify(self, signature, data): + evp_md_ctx = self._backend._lib.EVP_MD_CTX_new() + self._backend.openssl_assert(evp_md_ctx != self._backend._ffi.NULL) + evp_md_ctx = self._backend._ffi.gc( + evp_md_ctx, self._backend._lib.EVP_MD_CTX_free + ) + res = self._backend._lib.EVP_DigestVerifyInit( + evp_md_ctx, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._evp_pkey, + ) + self._backend.openssl_assert(res == 1) + res = self._backend._lib.EVP_DigestVerify( + evp_md_ctx, signature, len(signature), data, len(data) + ) + if res != 1: + self._backend._consume_errors() + raise exceptions.InvalidSignature + + +@utils.register_interface(Ed25519PrivateKey) +class _Ed25519PrivateKey(object): + def __init__(self, backend, evp_pkey): + self._backend = backend + self._evp_pkey = evp_pkey + + def public_key(self): + buf = self._backend._ffi.new("unsigned char []", _ED25519_KEY_SIZE) + buflen = self._backend._ffi.new("size_t *", _ED25519_KEY_SIZE) + res = self._backend._lib.EVP_PKEY_get_raw_public_key( + self._evp_pkey, buf, buflen + ) + self._backend.openssl_assert(res == 1) + self._backend.openssl_assert(buflen[0] == _ED25519_KEY_SIZE) + public_bytes = self._backend._ffi.buffer(buf)[:] + return self._backend.ed25519_load_public_bytes(public_bytes) + + def sign(self, data): + evp_md_ctx = self._backend._lib.EVP_MD_CTX_new() + self._backend.openssl_assert(evp_md_ctx != self._backend._ffi.NULL) + evp_md_ctx = self._backend._ffi.gc( + evp_md_ctx, self._backend._lib.EVP_MD_CTX_free + ) + res = self._backend._lib.EVP_DigestSignInit( + evp_md_ctx, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._evp_pkey, + ) + self._backend.openssl_assert(res == 1) + buf = self._backend._ffi.new("unsigned char[]", _ED25519_SIG_SIZE) + buflen = self._backend._ffi.new("size_t *", len(buf)) + res = self._backend._lib.EVP_DigestSign( + evp_md_ctx, buf, buflen, data, len(data) + ) + self._backend.openssl_assert(res == 1) + self._backend.openssl_assert(buflen[0] == _ED25519_SIG_SIZE) + return self._backend._ffi.buffer(buf, buflen[0])[:] + + def private_bytes(self, encoding, format, encryption_algorithm): + if ( + encoding is serialization.Encoding.Raw + or format is serialization.PublicFormat.Raw + ): + if ( + format is not serialization.PrivateFormat.Raw + or encoding is not serialization.Encoding.Raw + or not isinstance( + encryption_algorithm, serialization.NoEncryption + ) + ): + raise ValueError( + "When using Raw both encoding and format must be Raw " + "and encryption_algorithm must be NoEncryption()" + ) + + return self._raw_private_bytes() + + return self._backend._private_key_bytes( + encoding, format, encryption_algorithm, self, self._evp_pkey, None + ) + + def _raw_private_bytes(self): + buf = self._backend._ffi.new("unsigned char []", _ED25519_KEY_SIZE) + buflen = self._backend._ffi.new("size_t *", _ED25519_KEY_SIZE) + res = self._backend._lib.EVP_PKEY_get_raw_private_key( + self._evp_pkey, buf, buflen + ) + self._backend.openssl_assert(res == 1) + self._backend.openssl_assert(buflen[0] == _ED25519_KEY_SIZE) + return self._backend._ffi.buffer(buf, _ED25519_KEY_SIZE)[:] diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ed448.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ed448.py new file mode 100644 index 0000000000..6512770e5b --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ed448.py @@ -0,0 +1,146 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import exceptions, utils +from cryptography.hazmat.primitives import serialization +from cryptography.hazmat.primitives.asymmetric.ed448 import ( + Ed448PrivateKey, + Ed448PublicKey, +) + +_ED448_KEY_SIZE = 57 +_ED448_SIG_SIZE = 114 + + +@utils.register_interface(Ed448PublicKey) +class _Ed448PublicKey(object): + def __init__(self, backend, evp_pkey): + self._backend = backend + self._evp_pkey = evp_pkey + + def public_bytes(self, encoding, format): + if ( + encoding is serialization.Encoding.Raw + or format is serialization.PublicFormat.Raw + ): + if ( + encoding is not serialization.Encoding.Raw + or format is not serialization.PublicFormat.Raw + ): + raise ValueError( + "When using Raw both encoding and format must be Raw" + ) + + return self._raw_public_bytes() + + return self._backend._public_key_bytes( + encoding, format, self, self._evp_pkey, None + ) + + def _raw_public_bytes(self): + buf = self._backend._ffi.new("unsigned char []", _ED448_KEY_SIZE) + buflen = self._backend._ffi.new("size_t *", _ED448_KEY_SIZE) + res = self._backend._lib.EVP_PKEY_get_raw_public_key( + self._evp_pkey, buf, buflen + ) + self._backend.openssl_assert(res == 1) + self._backend.openssl_assert(buflen[0] == _ED448_KEY_SIZE) + return self._backend._ffi.buffer(buf, _ED448_KEY_SIZE)[:] + + def verify(self, signature, data): + evp_md_ctx = self._backend._lib.EVP_MD_CTX_new() + self._backend.openssl_assert(evp_md_ctx != self._backend._ffi.NULL) + evp_md_ctx = self._backend._ffi.gc( + evp_md_ctx, self._backend._lib.EVP_MD_CTX_free + ) + res = self._backend._lib.EVP_DigestVerifyInit( + evp_md_ctx, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._evp_pkey, + ) + self._backend.openssl_assert(res == 1) + res = self._backend._lib.EVP_DigestVerify( + evp_md_ctx, signature, len(signature), data, len(data) + ) + if res != 1: + self._backend._consume_errors() + raise exceptions.InvalidSignature + + +@utils.register_interface(Ed448PrivateKey) +class _Ed448PrivateKey(object): + def __init__(self, backend, evp_pkey): + self._backend = backend + self._evp_pkey = evp_pkey + + def public_key(self): + buf = self._backend._ffi.new("unsigned char []", _ED448_KEY_SIZE) + buflen = self._backend._ffi.new("size_t *", _ED448_KEY_SIZE) + res = self._backend._lib.EVP_PKEY_get_raw_public_key( + self._evp_pkey, buf, buflen + ) + self._backend.openssl_assert(res == 1) + self._backend.openssl_assert(buflen[0] == _ED448_KEY_SIZE) + public_bytes = self._backend._ffi.buffer(buf)[:] + return self._backend.ed448_load_public_bytes(public_bytes) + + def sign(self, data): + evp_md_ctx = self._backend._lib.EVP_MD_CTX_new() + self._backend.openssl_assert(evp_md_ctx != self._backend._ffi.NULL) + evp_md_ctx = self._backend._ffi.gc( + evp_md_ctx, self._backend._lib.EVP_MD_CTX_free + ) + res = self._backend._lib.EVP_DigestSignInit( + evp_md_ctx, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._evp_pkey, + ) + self._backend.openssl_assert(res == 1) + buf = self._backend._ffi.new("unsigned char[]", _ED448_SIG_SIZE) + buflen = self._backend._ffi.new("size_t *", len(buf)) + res = self._backend._lib.EVP_DigestSign( + evp_md_ctx, buf, buflen, data, len(data) + ) + self._backend.openssl_assert(res == 1) + self._backend.openssl_assert(buflen[0] == _ED448_SIG_SIZE) + return self._backend._ffi.buffer(buf, buflen[0])[:] + + def private_bytes(self, encoding, format, encryption_algorithm): + if ( + encoding is serialization.Encoding.Raw + or format is serialization.PublicFormat.Raw + ): + if ( + format is not serialization.PrivateFormat.Raw + or encoding is not serialization.Encoding.Raw + or not isinstance( + encryption_algorithm, serialization.NoEncryption + ) + ): + raise ValueError( + "When using Raw both encoding and format must be Raw " + "and encryption_algorithm must be NoEncryption()" + ) + + return self._raw_private_bytes() + + return self._backend._private_key_bytes( + encoding, format, encryption_algorithm, self, self._evp_pkey, None + ) + + def _raw_private_bytes(self): + buf = self._backend._ffi.new("unsigned char []", _ED448_KEY_SIZE) + buflen = self._backend._ffi.new("size_t *", _ED448_KEY_SIZE) + res = self._backend._lib.EVP_PKEY_get_raw_private_key( + self._evp_pkey, buf, buflen + ) + self._backend.openssl_assert(res == 1) + self._backend.openssl_assert(buflen[0] == _ED448_KEY_SIZE) + return self._backend._ffi.buffer(buf, _ED448_KEY_SIZE)[:] diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/encode_asn1.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/encode_asn1.py new file mode 100644 index 0000000000..0a33200bbc --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/encode_asn1.py @@ -0,0 +1,670 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import calendar +import ipaddress + +import six + +from cryptography import utils, x509 +from cryptography.hazmat.backends.openssl.decode_asn1 import ( + _CRL_ENTRY_REASON_ENUM_TO_CODE, + _DISTPOINT_TYPE_FULLNAME, + _DISTPOINT_TYPE_RELATIVENAME, +) +from cryptography.x509.name import _ASN1Type +from cryptography.x509.oid import ( + CRLEntryExtensionOID, + ExtensionOID, + OCSPExtensionOID, +) + + +def _encode_asn1_int(backend, x): + """ + Converts a python integer to an ASN1_INTEGER. The returned ASN1_INTEGER + will not be garbage collected (to support adding them to structs that take + ownership of the object). Be sure to register it for GC if it will be + discarded after use. + + """ + # Convert Python integer to OpenSSL "bignum" in case value exceeds + # machine's native integer limits (note: `int_to_bn` doesn't automatically + # GC). + i = backend._int_to_bn(x) + i = backend._ffi.gc(i, backend._lib.BN_free) + + # Wrap in an ASN.1 integer. Don't GC -- as documented. + i = backend._lib.BN_to_ASN1_INTEGER(i, backend._ffi.NULL) + backend.openssl_assert(i != backend._ffi.NULL) + return i + + +def _encode_asn1_int_gc(backend, x): + i = _encode_asn1_int(backend, x) + i = backend._ffi.gc(i, backend._lib.ASN1_INTEGER_free) + return i + + +def _encode_asn1_str(backend, data): + """ + Create an ASN1_OCTET_STRING from a Python byte string. + """ + s = backend._lib.ASN1_OCTET_STRING_new() + res = backend._lib.ASN1_OCTET_STRING_set(s, data, len(data)) + backend.openssl_assert(res == 1) + return s + + +def _encode_asn1_utf8_str(backend, string): + """ + Create an ASN1_UTF8STRING from a Python unicode string. + This object will be an ASN1_STRING with UTF8 type in OpenSSL and + can be decoded with ASN1_STRING_to_UTF8. + """ + s = backend._lib.ASN1_UTF8STRING_new() + res = backend._lib.ASN1_STRING_set( + s, string.encode("utf8"), len(string.encode("utf8")) + ) + backend.openssl_assert(res == 1) + return s + + +def _encode_asn1_str_gc(backend, data): + s = _encode_asn1_str(backend, data) + s = backend._ffi.gc(s, backend._lib.ASN1_OCTET_STRING_free) + return s + + +def _encode_inhibit_any_policy(backend, inhibit_any_policy): + return _encode_asn1_int_gc(backend, inhibit_any_policy.skip_certs) + + +def _encode_name(backend, name): + """ + The X509_NAME created will not be gc'd. Use _encode_name_gc if needed. + """ + subject = backend._lib.X509_NAME_new() + for rdn in name.rdns: + set_flag = 0 # indicate whether to add to last RDN or create new RDN + for attribute in rdn: + name_entry = _encode_name_entry(backend, attribute) + # X509_NAME_add_entry dups the object so we need to gc this copy + name_entry = backend._ffi.gc( + name_entry, backend._lib.X509_NAME_ENTRY_free + ) + res = backend._lib.X509_NAME_add_entry( + subject, name_entry, -1, set_flag + ) + backend.openssl_assert(res == 1) + set_flag = -1 + return subject + + +def _encode_name_gc(backend, attributes): + subject = _encode_name(backend, attributes) + subject = backend._ffi.gc(subject, backend._lib.X509_NAME_free) + return subject + + +def _encode_sk_name_entry(backend, attributes): + """ + The sk_X509_NAME_ENTRY created will not be gc'd. + """ + stack = backend._lib.sk_X509_NAME_ENTRY_new_null() + for attribute in attributes: + name_entry = _encode_name_entry(backend, attribute) + res = backend._lib.sk_X509_NAME_ENTRY_push(stack, name_entry) + backend.openssl_assert(res >= 1) + return stack + + +def _encode_name_entry(backend, attribute): + if attribute._type is _ASN1Type.BMPString: + value = attribute.value.encode("utf_16_be") + elif attribute._type is _ASN1Type.UniversalString: + value = attribute.value.encode("utf_32_be") + else: + value = attribute.value.encode("utf8") + + obj = _txt2obj_gc(backend, attribute.oid.dotted_string) + + name_entry = backend._lib.X509_NAME_ENTRY_create_by_OBJ( + backend._ffi.NULL, obj, attribute._type.value, value, len(value) + ) + return name_entry + + +def _encode_crl_number_delta_crl_indicator(backend, ext): + return _encode_asn1_int_gc(backend, ext.crl_number) + + +def _encode_issuing_dist_point(backend, ext): + idp = backend._lib.ISSUING_DIST_POINT_new() + backend.openssl_assert(idp != backend._ffi.NULL) + idp = backend._ffi.gc(idp, backend._lib.ISSUING_DIST_POINT_free) + idp.onlyuser = 255 if ext.only_contains_user_certs else 0 + idp.onlyCA = 255 if ext.only_contains_ca_certs else 0 + idp.indirectCRL = 255 if ext.indirect_crl else 0 + idp.onlyattr = 255 if ext.only_contains_attribute_certs else 0 + if ext.only_some_reasons: + idp.onlysomereasons = _encode_reasonflags( + backend, ext.only_some_reasons + ) + + if ext.full_name: + idp.distpoint = _encode_full_name(backend, ext.full_name) + + if ext.relative_name: + idp.distpoint = _encode_relative_name(backend, ext.relative_name) + + return idp + + +def _encode_crl_reason(backend, crl_reason): + asn1enum = backend._lib.ASN1_ENUMERATED_new() + backend.openssl_assert(asn1enum != backend._ffi.NULL) + asn1enum = backend._ffi.gc(asn1enum, backend._lib.ASN1_ENUMERATED_free) + res = backend._lib.ASN1_ENUMERATED_set( + asn1enum, _CRL_ENTRY_REASON_ENUM_TO_CODE[crl_reason.reason] + ) + backend.openssl_assert(res == 1) + + return asn1enum + + +def _encode_invalidity_date(backend, invalidity_date): + time = backend._lib.ASN1_GENERALIZEDTIME_set( + backend._ffi.NULL, + calendar.timegm(invalidity_date.invalidity_date.timetuple()), + ) + backend.openssl_assert(time != backend._ffi.NULL) + time = backend._ffi.gc(time, backend._lib.ASN1_GENERALIZEDTIME_free) + + return time + + +def _encode_certificate_policies(backend, certificate_policies): + cp = backend._lib.sk_POLICYINFO_new_null() + backend.openssl_assert(cp != backend._ffi.NULL) + cp = backend._ffi.gc(cp, backend._lib.sk_POLICYINFO_free) + for policy_info in certificate_policies: + pi = backend._lib.POLICYINFO_new() + backend.openssl_assert(pi != backend._ffi.NULL) + res = backend._lib.sk_POLICYINFO_push(cp, pi) + backend.openssl_assert(res >= 1) + oid = _txt2obj(backend, policy_info.policy_identifier.dotted_string) + pi.policyid = oid + if policy_info.policy_qualifiers: + pqis = backend._lib.sk_POLICYQUALINFO_new_null() + backend.openssl_assert(pqis != backend._ffi.NULL) + for qualifier in policy_info.policy_qualifiers: + pqi = backend._lib.POLICYQUALINFO_new() + backend.openssl_assert(pqi != backend._ffi.NULL) + res = backend._lib.sk_POLICYQUALINFO_push(pqis, pqi) + backend.openssl_assert(res >= 1) + if isinstance(qualifier, six.text_type): + pqi.pqualid = _txt2obj( + backend, x509.OID_CPS_QUALIFIER.dotted_string + ) + pqi.d.cpsuri = _encode_asn1_str( + backend, + qualifier.encode("ascii"), + ) + else: + assert isinstance(qualifier, x509.UserNotice) + pqi.pqualid = _txt2obj( + backend, x509.OID_CPS_USER_NOTICE.dotted_string + ) + un = backend._lib.USERNOTICE_new() + backend.openssl_assert(un != backend._ffi.NULL) + pqi.d.usernotice = un + if qualifier.explicit_text: + un.exptext = _encode_asn1_utf8_str( + backend, qualifier.explicit_text + ) + + un.noticeref = _encode_notice_reference( + backend, qualifier.notice_reference + ) + + pi.qualifiers = pqis + + return cp + + +def _encode_notice_reference(backend, notice): + if notice is None: + return backend._ffi.NULL + else: + nr = backend._lib.NOTICEREF_new() + backend.openssl_assert(nr != backend._ffi.NULL) + # organization is a required field + nr.organization = _encode_asn1_utf8_str(backend, notice.organization) + + notice_stack = backend._lib.sk_ASN1_INTEGER_new_null() + nr.noticenos = notice_stack + for number in notice.notice_numbers: + num = _encode_asn1_int(backend, number) + res = backend._lib.sk_ASN1_INTEGER_push(notice_stack, num) + backend.openssl_assert(res >= 1) + + return nr + + +def _txt2obj(backend, name): + """ + Converts a Python string with an ASN.1 object ID in dotted form to a + ASN1_OBJECT. + """ + name = name.encode("ascii") + obj = backend._lib.OBJ_txt2obj(name, 1) + backend.openssl_assert(obj != backend._ffi.NULL) + return obj + + +def _txt2obj_gc(backend, name): + obj = _txt2obj(backend, name) + obj = backend._ffi.gc(obj, backend._lib.ASN1_OBJECT_free) + return obj + + +def _encode_ocsp_nocheck(backend, ext): + # Doesn't need to be GC'd + return backend._lib.ASN1_NULL_new() + + +def _encode_key_usage(backend, key_usage): + set_bit = backend._lib.ASN1_BIT_STRING_set_bit + ku = backend._lib.ASN1_BIT_STRING_new() + ku = backend._ffi.gc(ku, backend._lib.ASN1_BIT_STRING_free) + res = set_bit(ku, 0, key_usage.digital_signature) + backend.openssl_assert(res == 1) + res = set_bit(ku, 1, key_usage.content_commitment) + backend.openssl_assert(res == 1) + res = set_bit(ku, 2, key_usage.key_encipherment) + backend.openssl_assert(res == 1) + res = set_bit(ku, 3, key_usage.data_encipherment) + backend.openssl_assert(res == 1) + res = set_bit(ku, 4, key_usage.key_agreement) + backend.openssl_assert(res == 1) + res = set_bit(ku, 5, key_usage.key_cert_sign) + backend.openssl_assert(res == 1) + res = set_bit(ku, 6, key_usage.crl_sign) + backend.openssl_assert(res == 1) + if key_usage.key_agreement: + res = set_bit(ku, 7, key_usage.encipher_only) + backend.openssl_assert(res == 1) + res = set_bit(ku, 8, key_usage.decipher_only) + backend.openssl_assert(res == 1) + else: + res = set_bit(ku, 7, 0) + backend.openssl_assert(res == 1) + res = set_bit(ku, 8, 0) + backend.openssl_assert(res == 1) + + return ku + + +def _encode_authority_key_identifier(backend, authority_keyid): + akid = backend._lib.AUTHORITY_KEYID_new() + backend.openssl_assert(akid != backend._ffi.NULL) + akid = backend._ffi.gc(akid, backend._lib.AUTHORITY_KEYID_free) + if authority_keyid.key_identifier is not None: + akid.keyid = _encode_asn1_str( + backend, + authority_keyid.key_identifier, + ) + + if authority_keyid.authority_cert_issuer is not None: + akid.issuer = _encode_general_names( + backend, authority_keyid.authority_cert_issuer + ) + + if authority_keyid.authority_cert_serial_number is not None: + akid.serial = _encode_asn1_int( + backend, authority_keyid.authority_cert_serial_number + ) + + return akid + + +def _encode_basic_constraints(backend, basic_constraints): + constraints = backend._lib.BASIC_CONSTRAINTS_new() + constraints = backend._ffi.gc( + constraints, backend._lib.BASIC_CONSTRAINTS_free + ) + constraints.ca = 255 if basic_constraints.ca else 0 + if basic_constraints.ca and basic_constraints.path_length is not None: + constraints.pathlen = _encode_asn1_int( + backend, basic_constraints.path_length + ) + + return constraints + + +def _encode_information_access(backend, info_access): + aia = backend._lib.sk_ACCESS_DESCRIPTION_new_null() + backend.openssl_assert(aia != backend._ffi.NULL) + aia = backend._ffi.gc( + aia, + lambda x: backend._lib.sk_ACCESS_DESCRIPTION_pop_free( + x, + backend._ffi.addressof( + backend._lib._original_lib, "ACCESS_DESCRIPTION_free" + ), + ), + ) + for access_description in info_access: + ad = backend._lib.ACCESS_DESCRIPTION_new() + method = _txt2obj( + backend, access_description.access_method.dotted_string + ) + _encode_general_name_preallocated( + backend, access_description.access_location, ad.location + ) + ad.method = method + res = backend._lib.sk_ACCESS_DESCRIPTION_push(aia, ad) + backend.openssl_assert(res >= 1) + + return aia + + +def _encode_general_names(backend, names): + general_names = backend._lib.GENERAL_NAMES_new() + backend.openssl_assert(general_names != backend._ffi.NULL) + for name in names: + gn = _encode_general_name(backend, name) + res = backend._lib.sk_GENERAL_NAME_push(general_names, gn) + backend.openssl_assert(res != 0) + + return general_names + + +def _encode_alt_name(backend, san): + general_names = _encode_general_names(backend, san) + general_names = backend._ffi.gc( + general_names, backend._lib.GENERAL_NAMES_free + ) + return general_names + + +def _encode_subject_key_identifier(backend, ski): + return _encode_asn1_str_gc(backend, ski.digest) + + +def _encode_general_name(backend, name): + gn = backend._lib.GENERAL_NAME_new() + _encode_general_name_preallocated(backend, name, gn) + return gn + + +def _encode_general_name_preallocated(backend, name, gn): + if isinstance(name, x509.DNSName): + backend.openssl_assert(gn != backend._ffi.NULL) + gn.type = backend._lib.GEN_DNS + + ia5 = backend._lib.ASN1_IA5STRING_new() + backend.openssl_assert(ia5 != backend._ffi.NULL) + # ia5strings are supposed to be ITU T.50 but to allow round-tripping + # of broken certs that encode utf8 we'll encode utf8 here too. + value = name.value.encode("utf8") + + res = backend._lib.ASN1_STRING_set(ia5, value, len(value)) + backend.openssl_assert(res == 1) + gn.d.dNSName = ia5 + elif isinstance(name, x509.RegisteredID): + backend.openssl_assert(gn != backend._ffi.NULL) + gn.type = backend._lib.GEN_RID + obj = backend._lib.OBJ_txt2obj( + name.value.dotted_string.encode("ascii"), 1 + ) + backend.openssl_assert(obj != backend._ffi.NULL) + gn.d.registeredID = obj + elif isinstance(name, x509.DirectoryName): + backend.openssl_assert(gn != backend._ffi.NULL) + dir_name = _encode_name(backend, name.value) + gn.type = backend._lib.GEN_DIRNAME + gn.d.directoryName = dir_name + elif isinstance(name, x509.IPAddress): + backend.openssl_assert(gn != backend._ffi.NULL) + if isinstance(name.value, ipaddress.IPv4Network): + packed = name.value.network_address.packed + utils.int_to_bytes( + ((1 << 32) - name.value.num_addresses), 4 + ) + elif isinstance(name.value, ipaddress.IPv6Network): + packed = name.value.network_address.packed + utils.int_to_bytes( + (1 << 128) - name.value.num_addresses, 16 + ) + else: + packed = name.value.packed + ipaddr = _encode_asn1_str(backend, packed) + gn.type = backend._lib.GEN_IPADD + gn.d.iPAddress = ipaddr + elif isinstance(name, x509.OtherName): + backend.openssl_assert(gn != backend._ffi.NULL) + other_name = backend._lib.OTHERNAME_new() + backend.openssl_assert(other_name != backend._ffi.NULL) + + type_id = backend._lib.OBJ_txt2obj( + name.type_id.dotted_string.encode("ascii"), 1 + ) + backend.openssl_assert(type_id != backend._ffi.NULL) + data = backend._ffi.new("unsigned char[]", name.value) + data_ptr_ptr = backend._ffi.new("unsigned char **") + data_ptr_ptr[0] = data + value = backend._lib.d2i_ASN1_TYPE( + backend._ffi.NULL, data_ptr_ptr, len(name.value) + ) + if value == backend._ffi.NULL: + backend._consume_errors() + raise ValueError("Invalid ASN.1 data") + other_name.type_id = type_id + other_name.value = value + gn.type = backend._lib.GEN_OTHERNAME + gn.d.otherName = other_name + elif isinstance(name, x509.RFC822Name): + backend.openssl_assert(gn != backend._ffi.NULL) + # ia5strings are supposed to be ITU T.50 but to allow round-tripping + # of broken certs that encode utf8 we'll encode utf8 here too. + data = name.value.encode("utf8") + asn1_str = _encode_asn1_str(backend, data) + gn.type = backend._lib.GEN_EMAIL + gn.d.rfc822Name = asn1_str + elif isinstance(name, x509.UniformResourceIdentifier): + backend.openssl_assert(gn != backend._ffi.NULL) + # ia5strings are supposed to be ITU T.50 but to allow round-tripping + # of broken certs that encode utf8 we'll encode utf8 here too. + data = name.value.encode("utf8") + asn1_str = _encode_asn1_str(backend, data) + gn.type = backend._lib.GEN_URI + gn.d.uniformResourceIdentifier = asn1_str + else: + raise ValueError("{} is an unknown GeneralName type".format(name)) + + +def _encode_extended_key_usage(backend, extended_key_usage): + eku = backend._lib.sk_ASN1_OBJECT_new_null() + eku = backend._ffi.gc(eku, backend._lib.sk_ASN1_OBJECT_free) + for oid in extended_key_usage: + obj = _txt2obj(backend, oid.dotted_string) + res = backend._lib.sk_ASN1_OBJECT_push(eku, obj) + backend.openssl_assert(res >= 1) + + return eku + + +_CRLREASONFLAGS = { + x509.ReasonFlags.key_compromise: 1, + x509.ReasonFlags.ca_compromise: 2, + x509.ReasonFlags.affiliation_changed: 3, + x509.ReasonFlags.superseded: 4, + x509.ReasonFlags.cessation_of_operation: 5, + x509.ReasonFlags.certificate_hold: 6, + x509.ReasonFlags.privilege_withdrawn: 7, + x509.ReasonFlags.aa_compromise: 8, +} + + +def _encode_reasonflags(backend, reasons): + bitmask = backend._lib.ASN1_BIT_STRING_new() + backend.openssl_assert(bitmask != backend._ffi.NULL) + for reason in reasons: + res = backend._lib.ASN1_BIT_STRING_set_bit( + bitmask, _CRLREASONFLAGS[reason], 1 + ) + backend.openssl_assert(res == 1) + + return bitmask + + +def _encode_full_name(backend, full_name): + dpn = backend._lib.DIST_POINT_NAME_new() + backend.openssl_assert(dpn != backend._ffi.NULL) + dpn.type = _DISTPOINT_TYPE_FULLNAME + dpn.name.fullname = _encode_general_names(backend, full_name) + return dpn + + +def _encode_relative_name(backend, relative_name): + dpn = backend._lib.DIST_POINT_NAME_new() + backend.openssl_assert(dpn != backend._ffi.NULL) + dpn.type = _DISTPOINT_TYPE_RELATIVENAME + dpn.name.relativename = _encode_sk_name_entry(backend, relative_name) + return dpn + + +def _encode_cdps_freshest_crl(backend, cdps): + cdp = backend._lib.sk_DIST_POINT_new_null() + cdp = backend._ffi.gc(cdp, backend._lib.sk_DIST_POINT_free) + for point in cdps: + dp = backend._lib.DIST_POINT_new() + backend.openssl_assert(dp != backend._ffi.NULL) + + if point.reasons: + dp.reasons = _encode_reasonflags(backend, point.reasons) + + if point.full_name: + dp.distpoint = _encode_full_name(backend, point.full_name) + + if point.relative_name: + dp.distpoint = _encode_relative_name(backend, point.relative_name) + + if point.crl_issuer: + dp.CRLissuer = _encode_general_names(backend, point.crl_issuer) + + res = backend._lib.sk_DIST_POINT_push(cdp, dp) + backend.openssl_assert(res >= 1) + + return cdp + + +def _encode_name_constraints(backend, name_constraints): + nc = backend._lib.NAME_CONSTRAINTS_new() + backend.openssl_assert(nc != backend._ffi.NULL) + nc = backend._ffi.gc(nc, backend._lib.NAME_CONSTRAINTS_free) + permitted = _encode_general_subtree( + backend, name_constraints.permitted_subtrees + ) + nc.permittedSubtrees = permitted + excluded = _encode_general_subtree( + backend, name_constraints.excluded_subtrees + ) + nc.excludedSubtrees = excluded + + return nc + + +def _encode_policy_constraints(backend, policy_constraints): + pc = backend._lib.POLICY_CONSTRAINTS_new() + backend.openssl_assert(pc != backend._ffi.NULL) + pc = backend._ffi.gc(pc, backend._lib.POLICY_CONSTRAINTS_free) + if policy_constraints.require_explicit_policy is not None: + pc.requireExplicitPolicy = _encode_asn1_int( + backend, policy_constraints.require_explicit_policy + ) + + if policy_constraints.inhibit_policy_mapping is not None: + pc.inhibitPolicyMapping = _encode_asn1_int( + backend, policy_constraints.inhibit_policy_mapping + ) + + return pc + + +def _encode_general_subtree(backend, subtrees): + if subtrees is None: + return backend._ffi.NULL + else: + general_subtrees = backend._lib.sk_GENERAL_SUBTREE_new_null() + for name in subtrees: + gs = backend._lib.GENERAL_SUBTREE_new() + gs.base = _encode_general_name(backend, name) + res = backend._lib.sk_GENERAL_SUBTREE_push(general_subtrees, gs) + backend.openssl_assert(res >= 1) + + return general_subtrees + + +def _encode_precert_signed_certificate_timestamps(backend, scts): + sct_stack = backend._lib.sk_SCT_new_null() + backend.openssl_assert(sct_stack != backend._ffi.NULL) + sct_stack = backend._ffi.gc(sct_stack, backend._lib.sk_SCT_free) + for sct in scts: + res = backend._lib.sk_SCT_push(sct_stack, sct._sct) + backend.openssl_assert(res >= 1) + return sct_stack + + +def _encode_nonce(backend, nonce): + return _encode_asn1_str_gc(backend, nonce.nonce) + + +_EXTENSION_ENCODE_HANDLERS = { + ExtensionOID.BASIC_CONSTRAINTS: _encode_basic_constraints, + ExtensionOID.SUBJECT_KEY_IDENTIFIER: _encode_subject_key_identifier, + ExtensionOID.KEY_USAGE: _encode_key_usage, + ExtensionOID.SUBJECT_ALTERNATIVE_NAME: _encode_alt_name, + ExtensionOID.ISSUER_ALTERNATIVE_NAME: _encode_alt_name, + ExtensionOID.EXTENDED_KEY_USAGE: _encode_extended_key_usage, + ExtensionOID.AUTHORITY_KEY_IDENTIFIER: _encode_authority_key_identifier, + ExtensionOID.CERTIFICATE_POLICIES: _encode_certificate_policies, + ExtensionOID.AUTHORITY_INFORMATION_ACCESS: _encode_information_access, + ExtensionOID.SUBJECT_INFORMATION_ACCESS: _encode_information_access, + ExtensionOID.CRL_DISTRIBUTION_POINTS: _encode_cdps_freshest_crl, + ExtensionOID.FRESHEST_CRL: _encode_cdps_freshest_crl, + ExtensionOID.INHIBIT_ANY_POLICY: _encode_inhibit_any_policy, + ExtensionOID.OCSP_NO_CHECK: _encode_ocsp_nocheck, + ExtensionOID.NAME_CONSTRAINTS: _encode_name_constraints, + ExtensionOID.POLICY_CONSTRAINTS: _encode_policy_constraints, + ExtensionOID.PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS: ( + _encode_precert_signed_certificate_timestamps + ), +} + +_CRL_EXTENSION_ENCODE_HANDLERS = { + ExtensionOID.ISSUER_ALTERNATIVE_NAME: _encode_alt_name, + ExtensionOID.AUTHORITY_KEY_IDENTIFIER: _encode_authority_key_identifier, + ExtensionOID.AUTHORITY_INFORMATION_ACCESS: _encode_information_access, + ExtensionOID.CRL_NUMBER: _encode_crl_number_delta_crl_indicator, + ExtensionOID.DELTA_CRL_INDICATOR: _encode_crl_number_delta_crl_indicator, + ExtensionOID.ISSUING_DISTRIBUTION_POINT: _encode_issuing_dist_point, + ExtensionOID.FRESHEST_CRL: _encode_cdps_freshest_crl, +} + +_CRL_ENTRY_EXTENSION_ENCODE_HANDLERS = { + CRLEntryExtensionOID.CERTIFICATE_ISSUER: _encode_alt_name, + CRLEntryExtensionOID.CRL_REASON: _encode_crl_reason, + CRLEntryExtensionOID.INVALIDITY_DATE: _encode_invalidity_date, +} + +_OCSP_REQUEST_EXTENSION_ENCODE_HANDLERS = { + OCSPExtensionOID.NONCE: _encode_nonce, +} + +_OCSP_BASICRESP_EXTENSION_ENCODE_HANDLERS = { + OCSPExtensionOID.NONCE: _encode_nonce, +} diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/hashes.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/hashes.py new file mode 100644 index 0000000000..764dce0ede --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/hashes.py @@ -0,0 +1,82 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + + +from cryptography import utils +from cryptography.exceptions import UnsupportedAlgorithm, _Reasons +from cryptography.hazmat.primitives import hashes + + +@utils.register_interface(hashes.HashContext) +class _HashContext(object): + def __init__(self, backend, algorithm, ctx=None): + self._algorithm = algorithm + + self._backend = backend + + if ctx is None: + ctx = self._backend._lib.EVP_MD_CTX_new() + ctx = self._backend._ffi.gc( + ctx, self._backend._lib.EVP_MD_CTX_free + ) + evp_md = self._backend._evp_md_from_algorithm(algorithm) + if evp_md == self._backend._ffi.NULL: + raise UnsupportedAlgorithm( + "{} is not a supported hash on this backend.".format( + algorithm.name + ), + _Reasons.UNSUPPORTED_HASH, + ) + res = self._backend._lib.EVP_DigestInit_ex( + ctx, evp_md, self._backend._ffi.NULL + ) + self._backend.openssl_assert(res != 0) + + self._ctx = ctx + + algorithm = utils.read_only_property("_algorithm") + + def copy(self): + copied_ctx = self._backend._lib.EVP_MD_CTX_new() + copied_ctx = self._backend._ffi.gc( + copied_ctx, self._backend._lib.EVP_MD_CTX_free + ) + res = self._backend._lib.EVP_MD_CTX_copy_ex(copied_ctx, self._ctx) + self._backend.openssl_assert(res != 0) + return _HashContext(self._backend, self.algorithm, ctx=copied_ctx) + + def update(self, data): + data_ptr = self._backend._ffi.from_buffer(data) + res = self._backend._lib.EVP_DigestUpdate( + self._ctx, data_ptr, len(data) + ) + self._backend.openssl_assert(res != 0) + + def finalize(self): + if isinstance(self.algorithm, hashes.ExtendableOutputFunction): + # extendable output functions use a different finalize + return self._finalize_xof() + else: + buf = self._backend._ffi.new( + "unsigned char[]", self._backend._lib.EVP_MAX_MD_SIZE + ) + outlen = self._backend._ffi.new("unsigned int *") + res = self._backend._lib.EVP_DigestFinal_ex(self._ctx, buf, outlen) + self._backend.openssl_assert(res != 0) + self._backend.openssl_assert( + outlen[0] == self.algorithm.digest_size + ) + return self._backend._ffi.buffer(buf)[: outlen[0]] + + def _finalize_xof(self): + buf = self._backend._ffi.new( + "unsigned char[]", self.algorithm.digest_size + ) + res = self._backend._lib.EVP_DigestFinalXOF( + self._ctx, buf, self.algorithm.digest_size + ) + self._backend.openssl_assert(res != 0) + return self._backend._ffi.buffer(buf)[: self.algorithm.digest_size] diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/hmac.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/hmac.py new file mode 100644 index 0000000000..1cc9d99fec --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/hmac.py @@ -0,0 +1,76 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + + +from cryptography import utils +from cryptography.exceptions import ( + InvalidSignature, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.primitives import constant_time, hashes + + +@utils.register_interface(hashes.HashContext) +class _HMACContext(object): + def __init__(self, backend, key, algorithm, ctx=None): + self._algorithm = algorithm + self._backend = backend + + if ctx is None: + ctx = self._backend._lib.HMAC_CTX_new() + self._backend.openssl_assert(ctx != self._backend._ffi.NULL) + ctx = self._backend._ffi.gc(ctx, self._backend._lib.HMAC_CTX_free) + evp_md = self._backend._evp_md_from_algorithm(algorithm) + if evp_md == self._backend._ffi.NULL: + raise UnsupportedAlgorithm( + "{} is not a supported hash on this backend".format( + algorithm.name + ), + _Reasons.UNSUPPORTED_HASH, + ) + key_ptr = self._backend._ffi.from_buffer(key) + res = self._backend._lib.HMAC_Init_ex( + ctx, key_ptr, len(key), evp_md, self._backend._ffi.NULL + ) + self._backend.openssl_assert(res != 0) + + self._ctx = ctx + self._key = key + + algorithm = utils.read_only_property("_algorithm") + + def copy(self): + copied_ctx = self._backend._lib.HMAC_CTX_new() + self._backend.openssl_assert(copied_ctx != self._backend._ffi.NULL) + copied_ctx = self._backend._ffi.gc( + copied_ctx, self._backend._lib.HMAC_CTX_free + ) + res = self._backend._lib.HMAC_CTX_copy(copied_ctx, self._ctx) + self._backend.openssl_assert(res != 0) + return _HMACContext( + self._backend, self._key, self.algorithm, ctx=copied_ctx + ) + + def update(self, data): + data_ptr = self._backend._ffi.from_buffer(data) + res = self._backend._lib.HMAC_Update(self._ctx, data_ptr, len(data)) + self._backend.openssl_assert(res != 0) + + def finalize(self): + buf = self._backend._ffi.new( + "unsigned char[]", self._backend._lib.EVP_MAX_MD_SIZE + ) + outlen = self._backend._ffi.new("unsigned int *") + res = self._backend._lib.HMAC_Final(self._ctx, buf, outlen) + self._backend.openssl_assert(res != 0) + self._backend.openssl_assert(outlen[0] == self.algorithm.digest_size) + return self._backend._ffi.buffer(buf)[: outlen[0]] + + def verify(self, signature): + digest = self.finalize() + if not constant_time.bytes_eq(digest, signature): + raise InvalidSignature("Signature did not match digest.") diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ocsp.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ocsp.py new file mode 100644 index 0000000000..50c02e7a80 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/ocsp.py @@ -0,0 +1,401 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import functools + +from cryptography import utils, x509 +from cryptography.exceptions import UnsupportedAlgorithm +from cryptography.hazmat.backends.openssl.decode_asn1 import ( + _CRL_ENTRY_REASON_CODE_TO_ENUM, + _asn1_integer_to_int, + _asn1_string_to_bytes, + _decode_x509_name, + _obj2txt, + _parse_asn1_generalized_time, +) +from cryptography.hazmat.backends.openssl.x509 import _Certificate +from cryptography.hazmat.primitives import serialization +from cryptography.x509.ocsp import ( + OCSPCertStatus, + OCSPRequest, + OCSPResponse, + OCSPResponseStatus, + _CERT_STATUS_TO_ENUM, + _OIDS_TO_HASH, + _RESPONSE_STATUS_TO_ENUM, +) + + +def _requires_successful_response(func): + @functools.wraps(func) + def wrapper(self, *args): + if self.response_status != OCSPResponseStatus.SUCCESSFUL: + raise ValueError( + "OCSP response status is not successful so the property " + "has no value" + ) + else: + return func(self, *args) + + return wrapper + + +def _issuer_key_hash(backend, cert_id): + key_hash = backend._ffi.new("ASN1_OCTET_STRING **") + res = backend._lib.OCSP_id_get0_info( + backend._ffi.NULL, + backend._ffi.NULL, + key_hash, + backend._ffi.NULL, + cert_id, + ) + backend.openssl_assert(res == 1) + backend.openssl_assert(key_hash[0] != backend._ffi.NULL) + return _asn1_string_to_bytes(backend, key_hash[0]) + + +def _issuer_name_hash(backend, cert_id): + name_hash = backend._ffi.new("ASN1_OCTET_STRING **") + res = backend._lib.OCSP_id_get0_info( + name_hash, + backend._ffi.NULL, + backend._ffi.NULL, + backend._ffi.NULL, + cert_id, + ) + backend.openssl_assert(res == 1) + backend.openssl_assert(name_hash[0] != backend._ffi.NULL) + return _asn1_string_to_bytes(backend, name_hash[0]) + + +def _serial_number(backend, cert_id): + num = backend._ffi.new("ASN1_INTEGER **") + res = backend._lib.OCSP_id_get0_info( + backend._ffi.NULL, backend._ffi.NULL, backend._ffi.NULL, num, cert_id + ) + backend.openssl_assert(res == 1) + backend.openssl_assert(num[0] != backend._ffi.NULL) + return _asn1_integer_to_int(backend, num[0]) + + +def _hash_algorithm(backend, cert_id): + asn1obj = backend._ffi.new("ASN1_OBJECT **") + res = backend._lib.OCSP_id_get0_info( + backend._ffi.NULL, + asn1obj, + backend._ffi.NULL, + backend._ffi.NULL, + cert_id, + ) + backend.openssl_assert(res == 1) + backend.openssl_assert(asn1obj[0] != backend._ffi.NULL) + oid = _obj2txt(backend, asn1obj[0]) + try: + return _OIDS_TO_HASH[oid] + except KeyError: + raise UnsupportedAlgorithm( + "Signature algorithm OID: {} not recognized".format(oid) + ) + + +@utils.register_interface(OCSPResponse) +class _OCSPResponse(object): + def __init__(self, backend, ocsp_response): + self._backend = backend + self._ocsp_response = ocsp_response + status = self._backend._lib.OCSP_response_status(self._ocsp_response) + self._backend.openssl_assert(status in _RESPONSE_STATUS_TO_ENUM) + self._status = _RESPONSE_STATUS_TO_ENUM[status] + if self._status is OCSPResponseStatus.SUCCESSFUL: + basic = self._backend._lib.OCSP_response_get1_basic( + self._ocsp_response + ) + self._backend.openssl_assert(basic != self._backend._ffi.NULL) + self._basic = self._backend._ffi.gc( + basic, self._backend._lib.OCSP_BASICRESP_free + ) + num_resp = self._backend._lib.OCSP_resp_count(self._basic) + if num_resp != 1: + raise ValueError( + "OCSP response contains more than one SINGLERESP structure" + ", which this library does not support. " + "{} found".format(num_resp) + ) + self._single = self._backend._lib.OCSP_resp_get0(self._basic, 0) + self._backend.openssl_assert( + self._single != self._backend._ffi.NULL + ) + self._cert_id = self._backend._lib.OCSP_SINGLERESP_get0_id( + self._single + ) + self._backend.openssl_assert( + self._cert_id != self._backend._ffi.NULL + ) + + response_status = utils.read_only_property("_status") + + @property + @_requires_successful_response + def signature_algorithm_oid(self): + alg = self._backend._lib.OCSP_resp_get0_tbs_sigalg(self._basic) + self._backend.openssl_assert(alg != self._backend._ffi.NULL) + oid = _obj2txt(self._backend, alg.algorithm) + return x509.ObjectIdentifier(oid) + + @property + @_requires_successful_response + def signature_hash_algorithm(self): + oid = self.signature_algorithm_oid + try: + return x509._SIG_OIDS_TO_HASH[oid] + except KeyError: + raise UnsupportedAlgorithm( + "Signature algorithm OID:{} not recognized".format(oid) + ) + + @property + @_requires_successful_response + def signature(self): + sig = self._backend._lib.OCSP_resp_get0_signature(self._basic) + self._backend.openssl_assert(sig != self._backend._ffi.NULL) + return _asn1_string_to_bytes(self._backend, sig) + + @property + @_requires_successful_response + def tbs_response_bytes(self): + respdata = self._backend._lib.OCSP_resp_get0_respdata(self._basic) + self._backend.openssl_assert(respdata != self._backend._ffi.NULL) + pp = self._backend._ffi.new("unsigned char **") + res = self._backend._lib.i2d_OCSP_RESPDATA(respdata, pp) + self._backend.openssl_assert(pp[0] != self._backend._ffi.NULL) + pp = self._backend._ffi.gc( + pp, lambda pointer: self._backend._lib.OPENSSL_free(pointer[0]) + ) + self._backend.openssl_assert(res > 0) + return self._backend._ffi.buffer(pp[0], res)[:] + + @property + @_requires_successful_response + def certificates(self): + sk_x509 = self._backend._lib.OCSP_resp_get0_certs(self._basic) + num = self._backend._lib.sk_X509_num(sk_x509) + certs = [] + for i in range(num): + x509 = self._backend._lib.sk_X509_value(sk_x509, i) + self._backend.openssl_assert(x509 != self._backend._ffi.NULL) + cert = _Certificate(self._backend, x509) + # We need to keep the OCSP response that the certificate came from + # alive until the Certificate object itself goes out of scope, so + # we give it a private reference. + cert._ocsp_resp = self + certs.append(cert) + + return certs + + @property + @_requires_successful_response + def responder_key_hash(self): + _, asn1_string = self._responder_key_name() + if asn1_string == self._backend._ffi.NULL: + return None + else: + return _asn1_string_to_bytes(self._backend, asn1_string) + + @property + @_requires_successful_response + def responder_name(self): + x509_name, _ = self._responder_key_name() + if x509_name == self._backend._ffi.NULL: + return None + else: + return _decode_x509_name(self._backend, x509_name) + + def _responder_key_name(self): + asn1_string = self._backend._ffi.new("ASN1_OCTET_STRING **") + x509_name = self._backend._ffi.new("X509_NAME **") + res = self._backend._lib.OCSP_resp_get0_id( + self._basic, asn1_string, x509_name + ) + self._backend.openssl_assert(res == 1) + return x509_name[0], asn1_string[0] + + @property + @_requires_successful_response + def produced_at(self): + produced_at = self._backend._lib.OCSP_resp_get0_produced_at( + self._basic + ) + return _parse_asn1_generalized_time(self._backend, produced_at) + + @property + @_requires_successful_response + def certificate_status(self): + status = self._backend._lib.OCSP_single_get0_status( + self._single, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + ) + self._backend.openssl_assert(status in _CERT_STATUS_TO_ENUM) + return _CERT_STATUS_TO_ENUM[status] + + @property + @_requires_successful_response + def revocation_time(self): + if self.certificate_status is not OCSPCertStatus.REVOKED: + return None + + asn1_time = self._backend._ffi.new("ASN1_GENERALIZEDTIME **") + self._backend._lib.OCSP_single_get0_status( + self._single, + self._backend._ffi.NULL, + asn1_time, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + ) + self._backend.openssl_assert(asn1_time[0] != self._backend._ffi.NULL) + return _parse_asn1_generalized_time(self._backend, asn1_time[0]) + + @property + @_requires_successful_response + def revocation_reason(self): + if self.certificate_status is not OCSPCertStatus.REVOKED: + return None + + reason_ptr = self._backend._ffi.new("int *") + self._backend._lib.OCSP_single_get0_status( + self._single, + reason_ptr, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + ) + # If no reason is encoded OpenSSL returns -1 + if reason_ptr[0] == -1: + return None + else: + self._backend.openssl_assert( + reason_ptr[0] in _CRL_ENTRY_REASON_CODE_TO_ENUM + ) + return _CRL_ENTRY_REASON_CODE_TO_ENUM[reason_ptr[0]] + + @property + @_requires_successful_response + def this_update(self): + asn1_time = self._backend._ffi.new("ASN1_GENERALIZEDTIME **") + self._backend._lib.OCSP_single_get0_status( + self._single, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + asn1_time, + self._backend._ffi.NULL, + ) + self._backend.openssl_assert(asn1_time[0] != self._backend._ffi.NULL) + return _parse_asn1_generalized_time(self._backend, asn1_time[0]) + + @property + @_requires_successful_response + def next_update(self): + asn1_time = self._backend._ffi.new("ASN1_GENERALIZEDTIME **") + self._backend._lib.OCSP_single_get0_status( + self._single, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + asn1_time, + ) + if asn1_time[0] != self._backend._ffi.NULL: + return _parse_asn1_generalized_time(self._backend, asn1_time[0]) + else: + return None + + @property + @_requires_successful_response + def issuer_key_hash(self): + return _issuer_key_hash(self._backend, self._cert_id) + + @property + @_requires_successful_response + def issuer_name_hash(self): + return _issuer_name_hash(self._backend, self._cert_id) + + @property + @_requires_successful_response + def hash_algorithm(self): + return _hash_algorithm(self._backend, self._cert_id) + + @property + @_requires_successful_response + def serial_number(self): + return _serial_number(self._backend, self._cert_id) + + @utils.cached_property + @_requires_successful_response + def extensions(self): + return self._backend._ocsp_basicresp_ext_parser.parse(self._basic) + + @utils.cached_property + @_requires_successful_response + def single_extensions(self): + return self._backend._ocsp_singleresp_ext_parser.parse(self._single) + + def public_bytes(self, encoding): + if encoding is not serialization.Encoding.DER: + raise ValueError("The only allowed encoding value is Encoding.DER") + + bio = self._backend._create_mem_bio_gc() + res = self._backend._lib.i2d_OCSP_RESPONSE_bio( + bio, self._ocsp_response + ) + self._backend.openssl_assert(res > 0) + return self._backend._read_mem_bio(bio) + + +@utils.register_interface(OCSPRequest) +class _OCSPRequest(object): + def __init__(self, backend, ocsp_request): + if backend._lib.OCSP_request_onereq_count(ocsp_request) > 1: + raise NotImplementedError( + "OCSP request contains more than one request" + ) + self._backend = backend + self._ocsp_request = ocsp_request + self._request = self._backend._lib.OCSP_request_onereq_get0( + self._ocsp_request, 0 + ) + self._backend.openssl_assert(self._request != self._backend._ffi.NULL) + self._cert_id = self._backend._lib.OCSP_onereq_get0_id(self._request) + self._backend.openssl_assert(self._cert_id != self._backend._ffi.NULL) + + @property + def issuer_key_hash(self): + return _issuer_key_hash(self._backend, self._cert_id) + + @property + def issuer_name_hash(self): + return _issuer_name_hash(self._backend, self._cert_id) + + @property + def serial_number(self): + return _serial_number(self._backend, self._cert_id) + + @property + def hash_algorithm(self): + return _hash_algorithm(self._backend, self._cert_id) + + @utils.cached_property + def extensions(self): + return self._backend._ocsp_req_ext_parser.parse(self._ocsp_request) + + def public_bytes(self, encoding): + if encoding is not serialization.Encoding.DER: + raise ValueError("The only allowed encoding value is Encoding.DER") + + bio = self._backend._create_mem_bio_gc() + res = self._backend._lib.i2d_OCSP_REQUEST_bio(bio, self._ocsp_request) + self._backend.openssl_assert(res > 0) + return self._backend._read_mem_bio(bio) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/poly1305.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/poly1305.py new file mode 100644 index 0000000000..5699918b17 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/poly1305.py @@ -0,0 +1,65 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + + +from cryptography.exceptions import InvalidSignature +from cryptography.hazmat.primitives import constant_time + + +_POLY1305_TAG_SIZE = 16 +_POLY1305_KEY_SIZE = 32 + + +class _Poly1305Context(object): + def __init__(self, backend, key): + self._backend = backend + + key_ptr = self._backend._ffi.from_buffer(key) + # This function copies the key into OpenSSL-owned memory so we don't + # need to retain it ourselves + evp_pkey = self._backend._lib.EVP_PKEY_new_raw_private_key( + self._backend._lib.NID_poly1305, + self._backend._ffi.NULL, + key_ptr, + len(key), + ) + self._backend.openssl_assert(evp_pkey != self._backend._ffi.NULL) + self._evp_pkey = self._backend._ffi.gc( + evp_pkey, self._backend._lib.EVP_PKEY_free + ) + ctx = self._backend._lib.EVP_MD_CTX_new() + self._backend.openssl_assert(ctx != self._backend._ffi.NULL) + self._ctx = self._backend._ffi.gc( + ctx, self._backend._lib.EVP_MD_CTX_free + ) + res = self._backend._lib.EVP_DigestSignInit( + self._ctx, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + self._evp_pkey, + ) + self._backend.openssl_assert(res == 1) + + def update(self, data): + data_ptr = self._backend._ffi.from_buffer(data) + res = self._backend._lib.EVP_DigestSignUpdate( + self._ctx, data_ptr, len(data) + ) + self._backend.openssl_assert(res != 0) + + def finalize(self): + buf = self._backend._ffi.new("unsigned char[]", _POLY1305_TAG_SIZE) + outlen = self._backend._ffi.new("size_t *") + res = self._backend._lib.EVP_DigestSignFinal(self._ctx, buf, outlen) + self._backend.openssl_assert(res != 0) + self._backend.openssl_assert(outlen[0] == _POLY1305_TAG_SIZE) + return self._backend._ffi.buffer(buf)[: outlen[0]] + + def verify(self, tag): + mac = self.finalize() + if not constant_time.bytes_eq(mac, tag): + raise InvalidSignature("Value did not match computed tag.") diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/rsa.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/rsa.py new file mode 100644 index 0000000000..82cd49c960 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/rsa.py @@ -0,0 +1,516 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.exceptions import ( + InvalidSignature, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends.openssl.utils import ( + _calculate_digest_and_algorithm, + _check_not_prehashed, + _warn_sign_verify_deprecated, +) +from cryptography.hazmat.primitives import hashes +from cryptography.hazmat.primitives.asymmetric import ( + AsymmetricSignatureContext, + AsymmetricVerificationContext, + rsa, +) +from cryptography.hazmat.primitives.asymmetric.padding import ( + AsymmetricPadding, + MGF1, + OAEP, + PKCS1v15, + PSS, + calculate_max_pss_salt_length, +) +from cryptography.hazmat.primitives.asymmetric.rsa import ( + RSAPrivateKeyWithSerialization, + RSAPublicKeyWithSerialization, +) + + +def _get_rsa_pss_salt_length(pss, key, hash_algorithm): + salt = pss._salt_length + + if salt is MGF1.MAX_LENGTH or salt is PSS.MAX_LENGTH: + return calculate_max_pss_salt_length(key, hash_algorithm) + else: + return salt + + +def _enc_dec_rsa(backend, key, data, padding): + if not isinstance(padding, AsymmetricPadding): + raise TypeError("Padding must be an instance of AsymmetricPadding.") + + if isinstance(padding, PKCS1v15): + padding_enum = backend._lib.RSA_PKCS1_PADDING + elif isinstance(padding, OAEP): + padding_enum = backend._lib.RSA_PKCS1_OAEP_PADDING + + if not isinstance(padding._mgf, MGF1): + raise UnsupportedAlgorithm( + "Only MGF1 is supported by this backend.", + _Reasons.UNSUPPORTED_MGF, + ) + + if not backend.rsa_padding_supported(padding): + raise UnsupportedAlgorithm( + "This combination of padding and hash algorithm is not " + "supported by this backend.", + _Reasons.UNSUPPORTED_PADDING, + ) + + else: + raise UnsupportedAlgorithm( + "{} is not supported by this backend.".format(padding.name), + _Reasons.UNSUPPORTED_PADDING, + ) + + return _enc_dec_rsa_pkey_ctx(backend, key, data, padding_enum, padding) + + +def _enc_dec_rsa_pkey_ctx(backend, key, data, padding_enum, padding): + if isinstance(key, _RSAPublicKey): + init = backend._lib.EVP_PKEY_encrypt_init + crypt = backend._lib.EVP_PKEY_encrypt + else: + init = backend._lib.EVP_PKEY_decrypt_init + crypt = backend._lib.EVP_PKEY_decrypt + + pkey_ctx = backend._lib.EVP_PKEY_CTX_new(key._evp_pkey, backend._ffi.NULL) + backend.openssl_assert(pkey_ctx != backend._ffi.NULL) + pkey_ctx = backend._ffi.gc(pkey_ctx, backend._lib.EVP_PKEY_CTX_free) + res = init(pkey_ctx) + backend.openssl_assert(res == 1) + res = backend._lib.EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, padding_enum) + backend.openssl_assert(res > 0) + buf_size = backend._lib.EVP_PKEY_size(key._evp_pkey) + backend.openssl_assert(buf_size > 0) + if isinstance(padding, OAEP) and backend._lib.Cryptography_HAS_RSA_OAEP_MD: + mgf1_md = backend._evp_md_non_null_from_algorithm( + padding._mgf._algorithm + ) + res = backend._lib.EVP_PKEY_CTX_set_rsa_mgf1_md(pkey_ctx, mgf1_md) + backend.openssl_assert(res > 0) + oaep_md = backend._evp_md_non_null_from_algorithm(padding._algorithm) + res = backend._lib.EVP_PKEY_CTX_set_rsa_oaep_md(pkey_ctx, oaep_md) + backend.openssl_assert(res > 0) + + if ( + isinstance(padding, OAEP) + and padding._label is not None + and len(padding._label) > 0 + ): + # set0_rsa_oaep_label takes ownership of the char * so we need to + # copy it into some new memory + labelptr = backend._lib.OPENSSL_malloc(len(padding._label)) + backend.openssl_assert(labelptr != backend._ffi.NULL) + backend._ffi.memmove(labelptr, padding._label, len(padding._label)) + res = backend._lib.EVP_PKEY_CTX_set0_rsa_oaep_label( + pkey_ctx, labelptr, len(padding._label) + ) + backend.openssl_assert(res == 1) + + outlen = backend._ffi.new("size_t *", buf_size) + buf = backend._ffi.new("unsigned char[]", buf_size) + # Everything from this line onwards is written with the goal of being as + # constant-time as is practical given the constraints of Python and our + # API. See Bleichenbacher's '98 attack on RSA, and its many many variants. + # As such, you should not attempt to change this (particularly to "clean it + # up") without understanding why it was written this way (see + # Chesterton's Fence), and without measuring to verify you have not + # introduced observable time differences. + res = crypt(pkey_ctx, buf, outlen, data, len(data)) + resbuf = backend._ffi.buffer(buf)[: outlen[0]] + backend._lib.ERR_clear_error() + if res <= 0: + raise ValueError("Encryption/decryption failed.") + return resbuf + + +def _rsa_sig_determine_padding(backend, key, padding, algorithm): + if not isinstance(padding, AsymmetricPadding): + raise TypeError("Expected provider of AsymmetricPadding.") + + pkey_size = backend._lib.EVP_PKEY_size(key._evp_pkey) + backend.openssl_assert(pkey_size > 0) + + if isinstance(padding, PKCS1v15): + # Hash algorithm is ignored for PKCS1v15-padding, may be None. + padding_enum = backend._lib.RSA_PKCS1_PADDING + elif isinstance(padding, PSS): + if not isinstance(padding._mgf, MGF1): + raise UnsupportedAlgorithm( + "Only MGF1 is supported by this backend.", + _Reasons.UNSUPPORTED_MGF, + ) + + # PSS padding requires a hash algorithm + if not isinstance(algorithm, hashes.HashAlgorithm): + raise TypeError("Expected instance of hashes.HashAlgorithm.") + + # Size of key in bytes - 2 is the maximum + # PSS signature length (salt length is checked later) + if pkey_size - algorithm.digest_size - 2 < 0: + raise ValueError( + "Digest too large for key size. Use a larger " + "key or different digest." + ) + + padding_enum = backend._lib.RSA_PKCS1_PSS_PADDING + else: + raise UnsupportedAlgorithm( + "{} is not supported by this backend.".format(padding.name), + _Reasons.UNSUPPORTED_PADDING, + ) + + return padding_enum + + +# Hash algorithm can be absent (None) to initialize the context without setting +# any message digest algorithm. This is currently only valid for the PKCS1v15 +# padding type, where it means that the signature data is encoded/decoded +# as provided, without being wrapped in a DigestInfo structure. +def _rsa_sig_setup(backend, padding, algorithm, key, init_func): + padding_enum = _rsa_sig_determine_padding(backend, key, padding, algorithm) + pkey_ctx = backend._lib.EVP_PKEY_CTX_new(key._evp_pkey, backend._ffi.NULL) + backend.openssl_assert(pkey_ctx != backend._ffi.NULL) + pkey_ctx = backend._ffi.gc(pkey_ctx, backend._lib.EVP_PKEY_CTX_free) + res = init_func(pkey_ctx) + backend.openssl_assert(res == 1) + if algorithm is not None: + evp_md = backend._evp_md_non_null_from_algorithm(algorithm) + res = backend._lib.EVP_PKEY_CTX_set_signature_md(pkey_ctx, evp_md) + if res == 0: + backend._consume_errors() + raise UnsupportedAlgorithm( + "{} is not supported by this backend for RSA signing.".format( + algorithm.name + ), + _Reasons.UNSUPPORTED_HASH, + ) + res = backend._lib.EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, padding_enum) + if res <= 0: + backend._consume_errors() + raise UnsupportedAlgorithm( + "{} is not supported for the RSA signature operation.".format( + padding.name + ), + _Reasons.UNSUPPORTED_PADDING, + ) + if isinstance(padding, PSS): + res = backend._lib.EVP_PKEY_CTX_set_rsa_pss_saltlen( + pkey_ctx, _get_rsa_pss_salt_length(padding, key, algorithm) + ) + backend.openssl_assert(res > 0) + + mgf1_md = backend._evp_md_non_null_from_algorithm( + padding._mgf._algorithm + ) + res = backend._lib.EVP_PKEY_CTX_set_rsa_mgf1_md(pkey_ctx, mgf1_md) + backend.openssl_assert(res > 0) + + return pkey_ctx + + +def _rsa_sig_sign(backend, padding, algorithm, private_key, data): + pkey_ctx = _rsa_sig_setup( + backend, + padding, + algorithm, + private_key, + backend._lib.EVP_PKEY_sign_init, + ) + buflen = backend._ffi.new("size_t *") + res = backend._lib.EVP_PKEY_sign( + pkey_ctx, backend._ffi.NULL, buflen, data, len(data) + ) + backend.openssl_assert(res == 1) + buf = backend._ffi.new("unsigned char[]", buflen[0]) + res = backend._lib.EVP_PKEY_sign(pkey_ctx, buf, buflen, data, len(data)) + if res != 1: + errors = backend._consume_errors_with_text() + raise ValueError( + "Digest or salt length too long for key size. Use a larger key " + "or shorter salt length if you are specifying a PSS salt", + errors, + ) + + return backend._ffi.buffer(buf)[:] + + +def _rsa_sig_verify(backend, padding, algorithm, public_key, signature, data): + pkey_ctx = _rsa_sig_setup( + backend, + padding, + algorithm, + public_key, + backend._lib.EVP_PKEY_verify_init, + ) + res = backend._lib.EVP_PKEY_verify( + pkey_ctx, signature, len(signature), data, len(data) + ) + # The previous call can return negative numbers in the event of an + # error. This is not a signature failure but we need to fail if it + # occurs. + backend.openssl_assert(res >= 0) + if res == 0: + backend._consume_errors() + raise InvalidSignature + + +def _rsa_sig_recover(backend, padding, algorithm, public_key, signature): + pkey_ctx = _rsa_sig_setup( + backend, + padding, + algorithm, + public_key, + backend._lib.EVP_PKEY_verify_recover_init, + ) + + # Attempt to keep the rest of the code in this function as constant/time + # as possible. See the comment in _enc_dec_rsa_pkey_ctx. Note that the + # outlen parameter is used even though its value may be undefined in the + # error case. Due to the tolerant nature of Python slicing this does not + # trigger any exceptions. + maxlen = backend._lib.EVP_PKEY_size(public_key._evp_pkey) + backend.openssl_assert(maxlen > 0) + buf = backend._ffi.new("unsigned char[]", maxlen) + buflen = backend._ffi.new("size_t *", maxlen) + res = backend._lib.EVP_PKEY_verify_recover( + pkey_ctx, buf, buflen, signature, len(signature) + ) + resbuf = backend._ffi.buffer(buf)[: buflen[0]] + backend._lib.ERR_clear_error() + # Assume that all parameter errors are handled during the setup phase and + # any error here is due to invalid signature. + if res != 1: + raise InvalidSignature + return resbuf + + +@utils.register_interface(AsymmetricSignatureContext) +class _RSASignatureContext(object): + def __init__(self, backend, private_key, padding, algorithm): + self._backend = backend + self._private_key = private_key + + # We now call _rsa_sig_determine_padding in _rsa_sig_setup. However + # we need to make a pointless call to it here so we maintain the + # API of erroring on init with this context if the values are invalid. + _rsa_sig_determine_padding(backend, private_key, padding, algorithm) + self._padding = padding + self._algorithm = algorithm + self._hash_ctx = hashes.Hash(self._algorithm, self._backend) + + def update(self, data): + self._hash_ctx.update(data) + + def finalize(self): + return _rsa_sig_sign( + self._backend, + self._padding, + self._algorithm, + self._private_key, + self._hash_ctx.finalize(), + ) + + +@utils.register_interface(AsymmetricVerificationContext) +class _RSAVerificationContext(object): + def __init__(self, backend, public_key, signature, padding, algorithm): + self._backend = backend + self._public_key = public_key + self._signature = signature + self._padding = padding + # We now call _rsa_sig_determine_padding in _rsa_sig_setup. However + # we need to make a pointless call to it here so we maintain the + # API of erroring on init with this context if the values are invalid. + _rsa_sig_determine_padding(backend, public_key, padding, algorithm) + + padding = padding + self._algorithm = algorithm + self._hash_ctx = hashes.Hash(self._algorithm, self._backend) + + def update(self, data): + self._hash_ctx.update(data) + + def verify(self): + return _rsa_sig_verify( + self._backend, + self._padding, + self._algorithm, + self._public_key, + self._signature, + self._hash_ctx.finalize(), + ) + + +@utils.register_interface(RSAPrivateKeyWithSerialization) +class _RSAPrivateKey(object): + def __init__(self, backend, rsa_cdata, evp_pkey): + res = backend._lib.RSA_check_key(rsa_cdata) + if res != 1: + errors = backend._consume_errors_with_text() + raise ValueError("Invalid private key", errors) + + # Blinding is on by default in many versions of OpenSSL, but let's + # just be conservative here. + res = backend._lib.RSA_blinding_on(rsa_cdata, backend._ffi.NULL) + backend.openssl_assert(res == 1) + + self._backend = backend + self._rsa_cdata = rsa_cdata + self._evp_pkey = evp_pkey + + n = self._backend._ffi.new("BIGNUM **") + self._backend._lib.RSA_get0_key( + self._rsa_cdata, + n, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + ) + self._backend.openssl_assert(n[0] != self._backend._ffi.NULL) + self._key_size = self._backend._lib.BN_num_bits(n[0]) + + key_size = utils.read_only_property("_key_size") + + def signer(self, padding, algorithm): + _warn_sign_verify_deprecated() + _check_not_prehashed(algorithm) + return _RSASignatureContext(self._backend, self, padding, algorithm) + + def decrypt(self, ciphertext, padding): + key_size_bytes = (self.key_size + 7) // 8 + if key_size_bytes != len(ciphertext): + raise ValueError("Ciphertext length must be equal to key size.") + + return _enc_dec_rsa(self._backend, self, ciphertext, padding) + + def public_key(self): + ctx = self._backend._lib.RSAPublicKey_dup(self._rsa_cdata) + self._backend.openssl_assert(ctx != self._backend._ffi.NULL) + ctx = self._backend._ffi.gc(ctx, self._backend._lib.RSA_free) + evp_pkey = self._backend._rsa_cdata_to_evp_pkey(ctx) + return _RSAPublicKey(self._backend, ctx, evp_pkey) + + def private_numbers(self): + n = self._backend._ffi.new("BIGNUM **") + e = self._backend._ffi.new("BIGNUM **") + d = self._backend._ffi.new("BIGNUM **") + p = self._backend._ffi.new("BIGNUM **") + q = self._backend._ffi.new("BIGNUM **") + dmp1 = self._backend._ffi.new("BIGNUM **") + dmq1 = self._backend._ffi.new("BIGNUM **") + iqmp = self._backend._ffi.new("BIGNUM **") + self._backend._lib.RSA_get0_key(self._rsa_cdata, n, e, d) + self._backend.openssl_assert(n[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(e[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(d[0] != self._backend._ffi.NULL) + self._backend._lib.RSA_get0_factors(self._rsa_cdata, p, q) + self._backend.openssl_assert(p[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(q[0] != self._backend._ffi.NULL) + self._backend._lib.RSA_get0_crt_params( + self._rsa_cdata, dmp1, dmq1, iqmp + ) + self._backend.openssl_assert(dmp1[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(dmq1[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(iqmp[0] != self._backend._ffi.NULL) + return rsa.RSAPrivateNumbers( + p=self._backend._bn_to_int(p[0]), + q=self._backend._bn_to_int(q[0]), + d=self._backend._bn_to_int(d[0]), + dmp1=self._backend._bn_to_int(dmp1[0]), + dmq1=self._backend._bn_to_int(dmq1[0]), + iqmp=self._backend._bn_to_int(iqmp[0]), + public_numbers=rsa.RSAPublicNumbers( + e=self._backend._bn_to_int(e[0]), + n=self._backend._bn_to_int(n[0]), + ), + ) + + def private_bytes(self, encoding, format, encryption_algorithm): + return self._backend._private_key_bytes( + encoding, + format, + encryption_algorithm, + self, + self._evp_pkey, + self._rsa_cdata, + ) + + def sign(self, data, padding, algorithm): + data, algorithm = _calculate_digest_and_algorithm( + self._backend, data, algorithm + ) + return _rsa_sig_sign(self._backend, padding, algorithm, self, data) + + +@utils.register_interface(RSAPublicKeyWithSerialization) +class _RSAPublicKey(object): + def __init__(self, backend, rsa_cdata, evp_pkey): + self._backend = backend + self._rsa_cdata = rsa_cdata + self._evp_pkey = evp_pkey + + n = self._backend._ffi.new("BIGNUM **") + self._backend._lib.RSA_get0_key( + self._rsa_cdata, + n, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + ) + self._backend.openssl_assert(n[0] != self._backend._ffi.NULL) + self._key_size = self._backend._lib.BN_num_bits(n[0]) + + key_size = utils.read_only_property("_key_size") + + def verifier(self, signature, padding, algorithm): + _warn_sign_verify_deprecated() + utils._check_bytes("signature", signature) + + _check_not_prehashed(algorithm) + return _RSAVerificationContext( + self._backend, self, signature, padding, algorithm + ) + + def encrypt(self, plaintext, padding): + return _enc_dec_rsa(self._backend, self, plaintext, padding) + + def public_numbers(self): + n = self._backend._ffi.new("BIGNUM **") + e = self._backend._ffi.new("BIGNUM **") + self._backend._lib.RSA_get0_key( + self._rsa_cdata, n, e, self._backend._ffi.NULL + ) + self._backend.openssl_assert(n[0] != self._backend._ffi.NULL) + self._backend.openssl_assert(e[0] != self._backend._ffi.NULL) + return rsa.RSAPublicNumbers( + e=self._backend._bn_to_int(e[0]), + n=self._backend._bn_to_int(n[0]), + ) + + def public_bytes(self, encoding, format): + return self._backend._public_key_bytes( + encoding, format, self, self._evp_pkey, self._rsa_cdata + ) + + def verify(self, signature, data, padding, algorithm): + data, algorithm = _calculate_digest_and_algorithm( + self._backend, data, algorithm + ) + return _rsa_sig_verify( + self._backend, padding, algorithm, self, signature, data + ) + + def recover_data_from_signature(self, signature, padding, algorithm): + _check_not_prehashed(algorithm) + return _rsa_sig_recover( + self._backend, padding, algorithm, self, signature + ) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/utils.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/utils.py new file mode 100644 index 0000000000..3d697d1fb5 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/utils.py @@ -0,0 +1,66 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import warnings + +from cryptography import utils +from cryptography.hazmat.primitives import hashes +from cryptography.hazmat.primitives.asymmetric.utils import Prehashed + + +def _evp_pkey_derive(backend, evp_pkey, peer_public_key): + ctx = backend._lib.EVP_PKEY_CTX_new(evp_pkey, backend._ffi.NULL) + backend.openssl_assert(ctx != backend._ffi.NULL) + ctx = backend._ffi.gc(ctx, backend._lib.EVP_PKEY_CTX_free) + res = backend._lib.EVP_PKEY_derive_init(ctx) + backend.openssl_assert(res == 1) + res = backend._lib.EVP_PKEY_derive_set_peer(ctx, peer_public_key._evp_pkey) + backend.openssl_assert(res == 1) + keylen = backend._ffi.new("size_t *") + res = backend._lib.EVP_PKEY_derive(ctx, backend._ffi.NULL, keylen) + backend.openssl_assert(res == 1) + backend.openssl_assert(keylen[0] > 0) + buf = backend._ffi.new("unsigned char[]", keylen[0]) + res = backend._lib.EVP_PKEY_derive(ctx, buf, keylen) + if res != 1: + raise ValueError("Null shared key derived from public/private pair.") + + return backend._ffi.buffer(buf, keylen[0])[:] + + +def _calculate_digest_and_algorithm(backend, data, algorithm): + if not isinstance(algorithm, Prehashed): + hash_ctx = hashes.Hash(algorithm, backend) + hash_ctx.update(data) + data = hash_ctx.finalize() + else: + algorithm = algorithm._algorithm + + if len(data) != algorithm.digest_size: + raise ValueError( + "The provided data must be the same length as the hash " + "algorithm's digest size." + ) + + return (data, algorithm) + + +def _check_not_prehashed(signature_algorithm): + if isinstance(signature_algorithm, Prehashed): + raise TypeError( + "Prehashed is only supported in the sign and verify methods. " + "It cannot be used with signer, verifier or " + "recover_data_from_signature." + ) + + +def _warn_sign_verify_deprecated(): + warnings.warn( + "signer and verifier have been deprecated. Please use sign " + "and verify instead.", + utils.PersistentlyDeprecated2017, + stacklevel=3, + ) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/x25519.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/x25519.py new file mode 100644 index 0000000000..4971c54814 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/x25519.py @@ -0,0 +1,123 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.hazmat.backends.openssl.utils import _evp_pkey_derive +from cryptography.hazmat.primitives import serialization +from cryptography.hazmat.primitives.asymmetric.x25519 import ( + X25519PrivateKey, + X25519PublicKey, +) + + +_X25519_KEY_SIZE = 32 + + +@utils.register_interface(X25519PublicKey) +class _X25519PublicKey(object): + def __init__(self, backend, evp_pkey): + self._backend = backend + self._evp_pkey = evp_pkey + + def public_bytes(self, encoding, format): + if ( + encoding is serialization.Encoding.Raw + or format is serialization.PublicFormat.Raw + ): + if ( + encoding is not serialization.Encoding.Raw + or format is not serialization.PublicFormat.Raw + ): + raise ValueError( + "When using Raw both encoding and format must be Raw" + ) + + return self._raw_public_bytes() + + return self._backend._public_key_bytes( + encoding, format, self, self._evp_pkey, None + ) + + def _raw_public_bytes(self): + ucharpp = self._backend._ffi.new("unsigned char **") + res = self._backend._lib.EVP_PKEY_get1_tls_encodedpoint( + self._evp_pkey, ucharpp + ) + self._backend.openssl_assert(res == 32) + self._backend.openssl_assert(ucharpp[0] != self._backend._ffi.NULL) + data = self._backend._ffi.gc( + ucharpp[0], self._backend._lib.OPENSSL_free + ) + return self._backend._ffi.buffer(data, res)[:] + + +@utils.register_interface(X25519PrivateKey) +class _X25519PrivateKey(object): + def __init__(self, backend, evp_pkey): + self._backend = backend + self._evp_pkey = evp_pkey + + def public_key(self): + bio = self._backend._create_mem_bio_gc() + res = self._backend._lib.i2d_PUBKEY_bio(bio, self._evp_pkey) + self._backend.openssl_assert(res == 1) + evp_pkey = self._backend._lib.d2i_PUBKEY_bio( + bio, self._backend._ffi.NULL + ) + self._backend.openssl_assert(evp_pkey != self._backend._ffi.NULL) + evp_pkey = self._backend._ffi.gc( + evp_pkey, self._backend._lib.EVP_PKEY_free + ) + return _X25519PublicKey(self._backend, evp_pkey) + + def exchange(self, peer_public_key): + if not isinstance(peer_public_key, X25519PublicKey): + raise TypeError("peer_public_key must be X25519PublicKey.") + + return _evp_pkey_derive(self._backend, self._evp_pkey, peer_public_key) + + def private_bytes(self, encoding, format, encryption_algorithm): + if ( + encoding is serialization.Encoding.Raw + or format is serialization.PublicFormat.Raw + ): + if ( + format is not serialization.PrivateFormat.Raw + or encoding is not serialization.Encoding.Raw + or not isinstance( + encryption_algorithm, serialization.NoEncryption + ) + ): + raise ValueError( + "When using Raw both encoding and format must be Raw " + "and encryption_algorithm must be NoEncryption()" + ) + + return self._raw_private_bytes() + + return self._backend._private_key_bytes( + encoding, format, encryption_algorithm, self, self._evp_pkey, None + ) + + def _raw_private_bytes(self): + # When we drop support for CRYPTOGRAPHY_OPENSSL_LESS_THAN_111 we can + # switch this to EVP_PKEY_new_raw_private_key + # The trick we use here is serializing to a PKCS8 key and just + # using the last 32 bytes, which is the key itself. + bio = self._backend._create_mem_bio_gc() + res = self._backend._lib.i2d_PKCS8PrivateKey_bio( + bio, + self._evp_pkey, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + 0, + self._backend._ffi.NULL, + self._backend._ffi.NULL, + ) + self._backend.openssl_assert(res == 1) + pkcs8 = self._backend._read_mem_bio(bio) + self._backend.openssl_assert(len(pkcs8) == 48) + return pkcs8[-_X25519_KEY_SIZE:] diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/x448.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/x448.py new file mode 100644 index 0000000000..7ebcdf84bc --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/x448.py @@ -0,0 +1,107 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.hazmat.backends.openssl.utils import _evp_pkey_derive +from cryptography.hazmat.primitives import serialization +from cryptography.hazmat.primitives.asymmetric.x448 import ( + X448PrivateKey, + X448PublicKey, +) + +_X448_KEY_SIZE = 56 + + +@utils.register_interface(X448PublicKey) +class _X448PublicKey(object): + def __init__(self, backend, evp_pkey): + self._backend = backend + self._evp_pkey = evp_pkey + + def public_bytes(self, encoding, format): + if ( + encoding is serialization.Encoding.Raw + or format is serialization.PublicFormat.Raw + ): + if ( + encoding is not serialization.Encoding.Raw + or format is not serialization.PublicFormat.Raw + ): + raise ValueError( + "When using Raw both encoding and format must be Raw" + ) + + return self._raw_public_bytes() + + return self._backend._public_key_bytes( + encoding, format, self, self._evp_pkey, None + ) + + def _raw_public_bytes(self): + buf = self._backend._ffi.new("unsigned char []", _X448_KEY_SIZE) + buflen = self._backend._ffi.new("size_t *", _X448_KEY_SIZE) + res = self._backend._lib.EVP_PKEY_get_raw_public_key( + self._evp_pkey, buf, buflen + ) + self._backend.openssl_assert(res == 1) + self._backend.openssl_assert(buflen[0] == _X448_KEY_SIZE) + return self._backend._ffi.buffer(buf, _X448_KEY_SIZE)[:] + + +@utils.register_interface(X448PrivateKey) +class _X448PrivateKey(object): + def __init__(self, backend, evp_pkey): + self._backend = backend + self._evp_pkey = evp_pkey + + def public_key(self): + buf = self._backend._ffi.new("unsigned char []", _X448_KEY_SIZE) + buflen = self._backend._ffi.new("size_t *", _X448_KEY_SIZE) + res = self._backend._lib.EVP_PKEY_get_raw_public_key( + self._evp_pkey, buf, buflen + ) + self._backend.openssl_assert(res == 1) + self._backend.openssl_assert(buflen[0] == _X448_KEY_SIZE) + return self._backend.x448_load_public_bytes(buf) + + def exchange(self, peer_public_key): + if not isinstance(peer_public_key, X448PublicKey): + raise TypeError("peer_public_key must be X448PublicKey.") + + return _evp_pkey_derive(self._backend, self._evp_pkey, peer_public_key) + + def private_bytes(self, encoding, format, encryption_algorithm): + if ( + encoding is serialization.Encoding.Raw + or format is serialization.PublicFormat.Raw + ): + if ( + format is not serialization.PrivateFormat.Raw + or encoding is not serialization.Encoding.Raw + or not isinstance( + encryption_algorithm, serialization.NoEncryption + ) + ): + raise ValueError( + "When using Raw both encoding and format must be Raw " + "and encryption_algorithm must be NoEncryption()" + ) + + return self._raw_private_bytes() + + return self._backend._private_key_bytes( + encoding, format, encryption_algorithm, self, self._evp_pkey, None + ) + + def _raw_private_bytes(self): + buf = self._backend._ffi.new("unsigned char []", _X448_KEY_SIZE) + buflen = self._backend._ffi.new("size_t *", _X448_KEY_SIZE) + res = self._backend._lib.EVP_PKEY_get_raw_private_key( + self._evp_pkey, buf, buflen + ) + self._backend.openssl_assert(res == 1) + self._backend.openssl_assert(buflen[0] == _X448_KEY_SIZE) + return self._backend._ffi.buffer(buf, _X448_KEY_SIZE)[:] diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/x509.py b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/x509.py new file mode 100644 index 0000000000..4d0dac7649 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/backends/openssl/x509.py @@ -0,0 +1,587 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import datetime +import operator + +from cryptography import utils, x509 +from cryptography.exceptions import UnsupportedAlgorithm +from cryptography.hazmat.backends.openssl.decode_asn1 import ( + _asn1_integer_to_int, + _asn1_string_to_bytes, + _decode_x509_name, + _obj2txt, + _parse_asn1_time, +) +from cryptography.hazmat.backends.openssl.encode_asn1 import ( + _encode_asn1_int_gc, + _txt2obj_gc, +) +from cryptography.hazmat.primitives import hashes, serialization +from cryptography.hazmat.primitives.asymmetric import dsa, ec, rsa +from cryptography.x509.name import _ASN1Type + + +@utils.register_interface(x509.Certificate) +class _Certificate(object): + def __init__(self, backend, x509_cert): + self._backend = backend + self._x509 = x509_cert + + version = self._backend._lib.X509_get_version(self._x509) + if version == 0: + self._version = x509.Version.v1 + elif version == 2: + self._version = x509.Version.v3 + else: + raise x509.InvalidVersion( + "{} is not a valid X509 version".format(version), version + ) + + def __repr__(self): + return "<Certificate(subject={}, ...)>".format(self.subject) + + def __eq__(self, other): + if not isinstance(other, x509.Certificate): + return NotImplemented + + res = self._backend._lib.X509_cmp(self._x509, other._x509) + return res == 0 + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.public_bytes(serialization.Encoding.DER)) + + def __deepcopy__(self, memo): + return self + + def fingerprint(self, algorithm): + h = hashes.Hash(algorithm, self._backend) + h.update(self.public_bytes(serialization.Encoding.DER)) + return h.finalize() + + version = utils.read_only_property("_version") + + @property + def serial_number(self): + asn1_int = self._backend._lib.X509_get_serialNumber(self._x509) + self._backend.openssl_assert(asn1_int != self._backend._ffi.NULL) + return _asn1_integer_to_int(self._backend, asn1_int) + + def public_key(self): + pkey = self._backend._lib.X509_get_pubkey(self._x509) + if pkey == self._backend._ffi.NULL: + # Remove errors from the stack. + self._backend._consume_errors() + raise ValueError("Certificate public key is of an unknown type") + + pkey = self._backend._ffi.gc(pkey, self._backend._lib.EVP_PKEY_free) + + return self._backend._evp_pkey_to_public_key(pkey) + + @property + def not_valid_before(self): + asn1_time = self._backend._lib.X509_getm_notBefore(self._x509) + return _parse_asn1_time(self._backend, asn1_time) + + @property + def not_valid_after(self): + asn1_time = self._backend._lib.X509_getm_notAfter(self._x509) + return _parse_asn1_time(self._backend, asn1_time) + + @property + def issuer(self): + issuer = self._backend._lib.X509_get_issuer_name(self._x509) + self._backend.openssl_assert(issuer != self._backend._ffi.NULL) + return _decode_x509_name(self._backend, issuer) + + @property + def subject(self): + subject = self._backend._lib.X509_get_subject_name(self._x509) + self._backend.openssl_assert(subject != self._backend._ffi.NULL) + return _decode_x509_name(self._backend, subject) + + @property + def signature_hash_algorithm(self): + oid = self.signature_algorithm_oid + try: + return x509._SIG_OIDS_TO_HASH[oid] + except KeyError: + raise UnsupportedAlgorithm( + "Signature algorithm OID:{} not recognized".format(oid) + ) + + @property + def signature_algorithm_oid(self): + alg = self._backend._ffi.new("X509_ALGOR **") + self._backend._lib.X509_get0_signature( + self._backend._ffi.NULL, alg, self._x509 + ) + self._backend.openssl_assert(alg[0] != self._backend._ffi.NULL) + oid = _obj2txt(self._backend, alg[0].algorithm) + return x509.ObjectIdentifier(oid) + + @utils.cached_property + def extensions(self): + return self._backend._certificate_extension_parser.parse(self._x509) + + @property + def signature(self): + sig = self._backend._ffi.new("ASN1_BIT_STRING **") + self._backend._lib.X509_get0_signature( + sig, self._backend._ffi.NULL, self._x509 + ) + self._backend.openssl_assert(sig[0] != self._backend._ffi.NULL) + return _asn1_string_to_bytes(self._backend, sig[0]) + + @property + def tbs_certificate_bytes(self): + pp = self._backend._ffi.new("unsigned char **") + res = self._backend._lib.i2d_re_X509_tbs(self._x509, pp) + self._backend.openssl_assert(res > 0) + pp = self._backend._ffi.gc( + pp, lambda pointer: self._backend._lib.OPENSSL_free(pointer[0]) + ) + return self._backend._ffi.buffer(pp[0], res)[:] + + def public_bytes(self, encoding): + bio = self._backend._create_mem_bio_gc() + if encoding is serialization.Encoding.PEM: + res = self._backend._lib.PEM_write_bio_X509(bio, self._x509) + elif encoding is serialization.Encoding.DER: + res = self._backend._lib.i2d_X509_bio(bio, self._x509) + else: + raise TypeError("encoding must be an item from the Encoding enum") + + self._backend.openssl_assert(res == 1) + return self._backend._read_mem_bio(bio) + + +@utils.register_interface(x509.RevokedCertificate) +class _RevokedCertificate(object): + def __init__(self, backend, crl, x509_revoked): + self._backend = backend + # The X509_REVOKED_value is a X509_REVOKED * that has + # no reference counting. This means when X509_CRL_free is + # called then the CRL and all X509_REVOKED * are freed. Since + # you can retain a reference to a single revoked certificate + # and let the CRL fall out of scope we need to retain a + # private reference to the CRL inside the RevokedCertificate + # object to prevent the gc from being called inappropriately. + self._crl = crl + self._x509_revoked = x509_revoked + + @property + def serial_number(self): + asn1_int = self._backend._lib.X509_REVOKED_get0_serialNumber( + self._x509_revoked + ) + self._backend.openssl_assert(asn1_int != self._backend._ffi.NULL) + return _asn1_integer_to_int(self._backend, asn1_int) + + @property + def revocation_date(self): + return _parse_asn1_time( + self._backend, + self._backend._lib.X509_REVOKED_get0_revocationDate( + self._x509_revoked + ), + ) + + @utils.cached_property + def extensions(self): + return self._backend._revoked_cert_extension_parser.parse( + self._x509_revoked + ) + + +@utils.register_interface(x509.CertificateRevocationList) +class _CertificateRevocationList(object): + def __init__(self, backend, x509_crl): + self._backend = backend + self._x509_crl = x509_crl + + def __eq__(self, other): + if not isinstance(other, x509.CertificateRevocationList): + return NotImplemented + + res = self._backend._lib.X509_CRL_cmp(self._x509_crl, other._x509_crl) + return res == 0 + + def __ne__(self, other): + return not self == other + + def fingerprint(self, algorithm): + h = hashes.Hash(algorithm, self._backend) + bio = self._backend._create_mem_bio_gc() + res = self._backend._lib.i2d_X509_CRL_bio(bio, self._x509_crl) + self._backend.openssl_assert(res == 1) + der = self._backend._read_mem_bio(bio) + h.update(der) + return h.finalize() + + @utils.cached_property + def _sorted_crl(self): + # X509_CRL_get0_by_serial sorts in place, which breaks a variety of + # things we don't want to break (like iteration and the signature). + # Let's dupe it and sort that instead. + dup = self._backend._lib.X509_CRL_dup(self._x509_crl) + self._backend.openssl_assert(dup != self._backend._ffi.NULL) + dup = self._backend._ffi.gc(dup, self._backend._lib.X509_CRL_free) + return dup + + def get_revoked_certificate_by_serial_number(self, serial_number): + revoked = self._backend._ffi.new("X509_REVOKED **") + asn1_int = _encode_asn1_int_gc(self._backend, serial_number) + res = self._backend._lib.X509_CRL_get0_by_serial( + self._sorted_crl, revoked, asn1_int + ) + if res == 0: + return None + else: + self._backend.openssl_assert(revoked[0] != self._backend._ffi.NULL) + return _RevokedCertificate( + self._backend, self._sorted_crl, revoked[0] + ) + + @property + def signature_hash_algorithm(self): + oid = self.signature_algorithm_oid + try: + return x509._SIG_OIDS_TO_HASH[oid] + except KeyError: + raise UnsupportedAlgorithm( + "Signature algorithm OID:{} not recognized".format(oid) + ) + + @property + def signature_algorithm_oid(self): + alg = self._backend._ffi.new("X509_ALGOR **") + self._backend._lib.X509_CRL_get0_signature( + self._x509_crl, self._backend._ffi.NULL, alg + ) + self._backend.openssl_assert(alg[0] != self._backend._ffi.NULL) + oid = _obj2txt(self._backend, alg[0].algorithm) + return x509.ObjectIdentifier(oid) + + @property + def issuer(self): + issuer = self._backend._lib.X509_CRL_get_issuer(self._x509_crl) + self._backend.openssl_assert(issuer != self._backend._ffi.NULL) + return _decode_x509_name(self._backend, issuer) + + @property + def next_update(self): + nu = self._backend._lib.X509_CRL_get_nextUpdate(self._x509_crl) + self._backend.openssl_assert(nu != self._backend._ffi.NULL) + return _parse_asn1_time(self._backend, nu) + + @property + def last_update(self): + lu = self._backend._lib.X509_CRL_get_lastUpdate(self._x509_crl) + self._backend.openssl_assert(lu != self._backend._ffi.NULL) + return _parse_asn1_time(self._backend, lu) + + @property + def signature(self): + sig = self._backend._ffi.new("ASN1_BIT_STRING **") + self._backend._lib.X509_CRL_get0_signature( + self._x509_crl, sig, self._backend._ffi.NULL + ) + self._backend.openssl_assert(sig[0] != self._backend._ffi.NULL) + return _asn1_string_to_bytes(self._backend, sig[0]) + + @property + def tbs_certlist_bytes(self): + pp = self._backend._ffi.new("unsigned char **") + res = self._backend._lib.i2d_re_X509_CRL_tbs(self._x509_crl, pp) + self._backend.openssl_assert(res > 0) + pp = self._backend._ffi.gc( + pp, lambda pointer: self._backend._lib.OPENSSL_free(pointer[0]) + ) + return self._backend._ffi.buffer(pp[0], res)[:] + + def public_bytes(self, encoding): + bio = self._backend._create_mem_bio_gc() + if encoding is serialization.Encoding.PEM: + res = self._backend._lib.PEM_write_bio_X509_CRL( + bio, self._x509_crl + ) + elif encoding is serialization.Encoding.DER: + res = self._backend._lib.i2d_X509_CRL_bio(bio, self._x509_crl) + else: + raise TypeError("encoding must be an item from the Encoding enum") + + self._backend.openssl_assert(res == 1) + return self._backend._read_mem_bio(bio) + + def _revoked_cert(self, idx): + revoked = self._backend._lib.X509_CRL_get_REVOKED(self._x509_crl) + r = self._backend._lib.sk_X509_REVOKED_value(revoked, idx) + self._backend.openssl_assert(r != self._backend._ffi.NULL) + return _RevokedCertificate(self._backend, self, r) + + def __iter__(self): + for i in range(len(self)): + yield self._revoked_cert(i) + + def __getitem__(self, idx): + if isinstance(idx, slice): + start, stop, step = idx.indices(len(self)) + return [self._revoked_cert(i) for i in range(start, stop, step)] + else: + idx = operator.index(idx) + if idx < 0: + idx += len(self) + if not 0 <= idx < len(self): + raise IndexError + return self._revoked_cert(idx) + + def __len__(self): + revoked = self._backend._lib.X509_CRL_get_REVOKED(self._x509_crl) + if revoked == self._backend._ffi.NULL: + return 0 + else: + return self._backend._lib.sk_X509_REVOKED_num(revoked) + + @utils.cached_property + def extensions(self): + return self._backend._crl_extension_parser.parse(self._x509_crl) + + def is_signature_valid(self, public_key): + if not isinstance( + public_key, + (dsa.DSAPublicKey, rsa.RSAPublicKey, ec.EllipticCurvePublicKey), + ): + raise TypeError( + "Expecting one of DSAPublicKey, RSAPublicKey," + " or EllipticCurvePublicKey." + ) + res = self._backend._lib.X509_CRL_verify( + self._x509_crl, public_key._evp_pkey + ) + + if res != 1: + self._backend._consume_errors() + return False + + return True + + +@utils.register_interface(x509.CertificateSigningRequest) +class _CertificateSigningRequest(object): + def __init__(self, backend, x509_req): + self._backend = backend + self._x509_req = x509_req + + def __eq__(self, other): + if not isinstance(other, _CertificateSigningRequest): + return NotImplemented + + self_bytes = self.public_bytes(serialization.Encoding.DER) + other_bytes = other.public_bytes(serialization.Encoding.DER) + return self_bytes == other_bytes + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.public_bytes(serialization.Encoding.DER)) + + def public_key(self): + pkey = self._backend._lib.X509_REQ_get_pubkey(self._x509_req) + self._backend.openssl_assert(pkey != self._backend._ffi.NULL) + pkey = self._backend._ffi.gc(pkey, self._backend._lib.EVP_PKEY_free) + return self._backend._evp_pkey_to_public_key(pkey) + + @property + def subject(self): + subject = self._backend._lib.X509_REQ_get_subject_name(self._x509_req) + self._backend.openssl_assert(subject != self._backend._ffi.NULL) + return _decode_x509_name(self._backend, subject) + + @property + def signature_hash_algorithm(self): + oid = self.signature_algorithm_oid + try: + return x509._SIG_OIDS_TO_HASH[oid] + except KeyError: + raise UnsupportedAlgorithm( + "Signature algorithm OID:{} not recognized".format(oid) + ) + + @property + def signature_algorithm_oid(self): + alg = self._backend._ffi.new("X509_ALGOR **") + self._backend._lib.X509_REQ_get0_signature( + self._x509_req, self._backend._ffi.NULL, alg + ) + self._backend.openssl_assert(alg[0] != self._backend._ffi.NULL) + oid = _obj2txt(self._backend, alg[0].algorithm) + return x509.ObjectIdentifier(oid) + + @utils.cached_property + def extensions(self): + x509_exts = self._backend._lib.X509_REQ_get_extensions(self._x509_req) + x509_exts = self._backend._ffi.gc( + x509_exts, + lambda x: self._backend._lib.sk_X509_EXTENSION_pop_free( + x, + self._backend._ffi.addressof( + self._backend._lib._original_lib, "X509_EXTENSION_free" + ), + ), + ) + return self._backend._csr_extension_parser.parse(x509_exts) + + def public_bytes(self, encoding): + bio = self._backend._create_mem_bio_gc() + if encoding is serialization.Encoding.PEM: + res = self._backend._lib.PEM_write_bio_X509_REQ( + bio, self._x509_req + ) + elif encoding is serialization.Encoding.DER: + res = self._backend._lib.i2d_X509_REQ_bio(bio, self._x509_req) + else: + raise TypeError("encoding must be an item from the Encoding enum") + + self._backend.openssl_assert(res == 1) + return self._backend._read_mem_bio(bio) + + @property + def tbs_certrequest_bytes(self): + pp = self._backend._ffi.new("unsigned char **") + res = self._backend._lib.i2d_re_X509_REQ_tbs(self._x509_req, pp) + self._backend.openssl_assert(res > 0) + pp = self._backend._ffi.gc( + pp, lambda pointer: self._backend._lib.OPENSSL_free(pointer[0]) + ) + return self._backend._ffi.buffer(pp[0], res)[:] + + @property + def signature(self): + sig = self._backend._ffi.new("ASN1_BIT_STRING **") + self._backend._lib.X509_REQ_get0_signature( + self._x509_req, sig, self._backend._ffi.NULL + ) + self._backend.openssl_assert(sig[0] != self._backend._ffi.NULL) + return _asn1_string_to_bytes(self._backend, sig[0]) + + @property + def is_signature_valid(self): + pkey = self._backend._lib.X509_REQ_get_pubkey(self._x509_req) + self._backend.openssl_assert(pkey != self._backend._ffi.NULL) + pkey = self._backend._ffi.gc(pkey, self._backend._lib.EVP_PKEY_free) + res = self._backend._lib.X509_REQ_verify(self._x509_req, pkey) + + if res != 1: + self._backend._consume_errors() + return False + + return True + + def get_attribute_for_oid(self, oid): + obj = _txt2obj_gc(self._backend, oid.dotted_string) + pos = self._backend._lib.X509_REQ_get_attr_by_OBJ( + self._x509_req, obj, -1 + ) + if pos == -1: + raise x509.AttributeNotFound( + "No {} attribute was found".format(oid), oid + ) + + attr = self._backend._lib.X509_REQ_get_attr(self._x509_req, pos) + self._backend.openssl_assert(attr != self._backend._ffi.NULL) + # We don't support multiple valued attributes for now. + self._backend.openssl_assert( + self._backend._lib.X509_ATTRIBUTE_count(attr) == 1 + ) + asn1_type = self._backend._lib.X509_ATTRIBUTE_get0_type(attr, 0) + self._backend.openssl_assert(asn1_type != self._backend._ffi.NULL) + # We need this to ensure that our C type cast is safe. + # Also this should always be a sane string type, but we'll see if + # that is true in the real world... + if asn1_type.type not in ( + _ASN1Type.UTF8String.value, + _ASN1Type.PrintableString.value, + _ASN1Type.IA5String.value, + ): + raise ValueError( + "OID {} has a disallowed ASN.1 type: {}".format( + oid, asn1_type.type + ) + ) + + data = self._backend._lib.X509_ATTRIBUTE_get0_data( + attr, 0, asn1_type.type, self._backend._ffi.NULL + ) + self._backend.openssl_assert(data != self._backend._ffi.NULL) + # This cast is safe iff we assert on the type above to ensure + # that it is always a type of ASN1_STRING + data = self._backend._ffi.cast("ASN1_STRING *", data) + return _asn1_string_to_bytes(self._backend, data) + + +@utils.register_interface( + x509.certificate_transparency.SignedCertificateTimestamp +) +class _SignedCertificateTimestamp(object): + def __init__(self, backend, sct_list, sct): + self._backend = backend + # Keep the SCT_LIST that this SCT came from alive. + self._sct_list = sct_list + self._sct = sct + + @property + def version(self): + version = self._backend._lib.SCT_get_version(self._sct) + assert version == self._backend._lib.SCT_VERSION_V1 + return x509.certificate_transparency.Version.v1 + + @property + def log_id(self): + out = self._backend._ffi.new("unsigned char **") + log_id_length = self._backend._lib.SCT_get0_log_id(self._sct, out) + assert log_id_length >= 0 + return self._backend._ffi.buffer(out[0], log_id_length)[:] + + @property + def timestamp(self): + timestamp = self._backend._lib.SCT_get_timestamp(self._sct) + milliseconds = timestamp % 1000 + return datetime.datetime.utcfromtimestamp(timestamp // 1000).replace( + microsecond=milliseconds * 1000 + ) + + @property + def entry_type(self): + entry_type = self._backend._lib.SCT_get_log_entry_type(self._sct) + # We currently only support loading SCTs from the X.509 extension, so + # we only have precerts. + assert entry_type == self._backend._lib.CT_LOG_ENTRY_TYPE_PRECERT + return x509.certificate_transparency.LogEntryType.PRE_CERTIFICATE + + @property + def _signature(self): + ptrptr = self._backend._ffi.new("unsigned char **") + res = self._backend._lib.SCT_get0_signature(self._sct, ptrptr) + self._backend.openssl_assert(res > 0) + self._backend.openssl_assert(ptrptr[0] != self._backend._ffi.NULL) + return self._backend._ffi.buffer(ptrptr[0], res)[:] + + def __hash__(self): + return hash(self._signature) + + def __eq__(self, other): + if not isinstance(other, _SignedCertificateTimestamp): + return NotImplemented + + return self._signature == other._signature + + def __ne__(self, other): + return not self == other diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/bindings/__init__.py b/contrib/python/cryptography/py3/cryptography/hazmat/bindings/__init__.py new file mode 100644 index 0000000000..4b540884df --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/bindings/__init__.py @@ -0,0 +1,5 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/bindings/openssl/__init__.py b/contrib/python/cryptography/py3/cryptography/hazmat/bindings/openssl/__init__.py new file mode 100644 index 0000000000..4b540884df --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/bindings/openssl/__init__.py @@ -0,0 +1,5 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/bindings/openssl/_conditional.py b/contrib/python/cryptography/py3/cryptography/hazmat/bindings/openssl/_conditional.py new file mode 100644 index 0000000000..ca50fed134 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/bindings/openssl/_conditional.py @@ -0,0 +1,322 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + + +def cryptography_has_ec2m(): + return [ + "EC_POINT_set_affine_coordinates_GF2m", + "EC_POINT_get_affine_coordinates_GF2m", + "EC_POINT_set_compressed_coordinates_GF2m", + ] + + +def cryptography_has_rsa_oaep_md(): + return [ + "EVP_PKEY_CTX_set_rsa_oaep_md", + ] + + +def cryptography_has_rsa_oaep_label(): + return [ + "EVP_PKEY_CTX_set0_rsa_oaep_label", + ] + + +def cryptography_has_ssl3_method(): + return [ + "SSLv3_method", + "SSLv3_client_method", + "SSLv3_server_method", + ] + + +def cryptography_has_102_verification(): + return [ + "X509_V_ERR_SUITE_B_INVALID_VERSION", + "X509_V_ERR_SUITE_B_INVALID_ALGORITHM", + "X509_V_ERR_SUITE_B_INVALID_CURVE", + "X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM", + "X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED", + "X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256", + "X509_V_FLAG_SUITEB_128_LOS_ONLY", + "X509_V_FLAG_SUITEB_192_LOS", + "X509_V_FLAG_SUITEB_128_LOS", + ] + + +def cryptography_has_110_verification_params(): + return ["X509_CHECK_FLAG_NEVER_CHECK_SUBJECT"] + + +def cryptography_has_set_cert_cb(): + return [ + "SSL_CTX_set_cert_cb", + "SSL_set_cert_cb", + ] + + +def cryptography_has_ssl_st(): + return [ + "SSL_ST_BEFORE", + "SSL_ST_OK", + "SSL_ST_INIT", + "SSL_ST_RENEGOTIATE", + ] + + +def cryptography_has_tls_st(): + return [ + "TLS_ST_BEFORE", + "TLS_ST_OK", + ] + + +def cryptography_has_scrypt(): + return [ + "EVP_PBE_scrypt", + ] + + +def cryptography_has_evp_pkey_dhx(): + return [ + "EVP_PKEY_DHX", + ] + + +def cryptography_has_mem_functions(): + return [ + "Cryptography_CRYPTO_set_mem_functions", + ] + + +def cryptography_has_sct(): + return [ + "SCT_get_version", + "SCT_get_log_entry_type", + "SCT_get0_log_id", + "SCT_get0_signature", + "SCT_get_timestamp", + "SCT_set_source", + "sk_SCT_new_null", + "sk_SCT_free", + "sk_SCT_num", + "sk_SCT_value", + "sk_SCT_push", + "SCT_LIST_free", + "SCT_new", + "SCT_set1_log_id", + "SCT_set_timestamp", + "SCT_set_version", + "SCT_set_log_entry_type", + ] + + +def cryptography_has_x509_store_ctx_get_issuer(): + return [ + "X509_STORE_get_get_issuer", + "X509_STORE_set_get_issuer", + ] + + +def cryptography_has_ed448(): + return [ + "EVP_PKEY_ED448", + "NID_ED448", + ] + + +def cryptography_has_ed25519(): + return [ + "NID_ED25519", + "EVP_PKEY_ED25519", + ] + + +def cryptography_has_poly1305(): + return [ + "NID_poly1305", + "EVP_PKEY_POLY1305", + ] + + +def cryptography_has_oneshot_evp_digest_sign_verify(): + return [ + "EVP_DigestSign", + "EVP_DigestVerify", + ] + + +def cryptography_has_evp_digestfinal_xof(): + return [ + "EVP_DigestFinalXOF", + ] + + +def cryptography_has_evp_pkey_get_set_tls_encodedpoint(): + return [ + "EVP_PKEY_get1_tls_encodedpoint", + "EVP_PKEY_set1_tls_encodedpoint", + ] + + +def cryptography_has_fips(): + return [ + "FIPS_mode_set", + "FIPS_mode", + ] + + +def cryptography_has_ssl_sigalgs(): + return [ + "SSL_CTX_set1_sigalgs_list", + "SSL_get_sigalgs", + ] + + +def cryptography_has_psk(): + return [ + "SSL_CTX_use_psk_identity_hint", + "SSL_CTX_set_psk_server_callback", + "SSL_CTX_set_psk_client_callback", + ] + + +def cryptography_has_custom_ext(): + return [ + "SSL_CTX_add_client_custom_ext", + "SSL_CTX_add_server_custom_ext", + "SSL_extension_supported", + ] + + +def cryptography_has_openssl_cleanup(): + return [ + "OPENSSL_cleanup", + ] + + +def cryptography_has_tlsv13(): + return [ + "SSL_OP_NO_TLSv1_3", + "SSL_VERIFY_POST_HANDSHAKE", + "SSL_CTX_set_ciphersuites", + "SSL_verify_client_post_handshake", + "SSL_CTX_set_post_handshake_auth", + "SSL_set_post_handshake_auth", + "SSL_SESSION_get_max_early_data", + "SSL_write_early_data", + "SSL_read_early_data", + "SSL_CTX_set_max_early_data", + ] + + +def cryptography_has_keylog(): + return [ + "SSL_CTX_set_keylog_callback", + "SSL_CTX_get_keylog_callback", + ] + + +def cryptography_has_raw_key(): + return [ + "EVP_PKEY_new_raw_private_key", + "EVP_PKEY_new_raw_public_key", + "EVP_PKEY_get_raw_private_key", + "EVP_PKEY_get_raw_public_key", + ] + + +def cryptography_has_engine(): + return [ + "ENGINE_by_id", + "ENGINE_init", + "ENGINE_finish", + "ENGINE_get_default_RAND", + "ENGINE_set_default_RAND", + "ENGINE_unregister_RAND", + "ENGINE_ctrl_cmd", + "ENGINE_free", + "ENGINE_get_name", + "Cryptography_add_osrandom_engine", + "ENGINE_ctrl_cmd_string", + "ENGINE_load_builtin_engines", + "ENGINE_load_private_key", + "ENGINE_load_public_key", + ] + + +def cryptography_has_verified_chain(): + return [ + "SSL_get0_verified_chain", + ] + + +def cryptography_has_srtp(): + return [ + "SSL_CTX_set_tlsext_use_srtp", + "SSL_set_tlsext_use_srtp", + "SSL_get_selected_srtp_profile", + ] + + +def cryptography_has_get_proto_version(): + return [ + "SSL_CTX_get_min_proto_version", + "SSL_CTX_get_max_proto_version", + "SSL_get_min_proto_version", + "SSL_get_max_proto_version", + ] + + +# This is a mapping of +# {condition: function-returning-names-dependent-on-that-condition} so we can +# loop over them and delete unsupported names at runtime. It will be removed +# when cffi supports #if in cdef. We use functions instead of just a dict of +# lists so we can use coverage to measure which are used. +CONDITIONAL_NAMES = { + "Cryptography_HAS_EC2M": cryptography_has_ec2m, + "Cryptography_HAS_RSA_OAEP_MD": cryptography_has_rsa_oaep_md, + "Cryptography_HAS_RSA_OAEP_LABEL": cryptography_has_rsa_oaep_label, + "Cryptography_HAS_SSL3_METHOD": cryptography_has_ssl3_method, + "Cryptography_HAS_102_VERIFICATION": cryptography_has_102_verification, + "Cryptography_HAS_110_VERIFICATION_PARAMS": ( + cryptography_has_110_verification_params + ), + "Cryptography_HAS_SET_CERT_CB": cryptography_has_set_cert_cb, + "Cryptography_HAS_SSL_ST": cryptography_has_ssl_st, + "Cryptography_HAS_TLS_ST": cryptography_has_tls_st, + "Cryptography_HAS_SCRYPT": cryptography_has_scrypt, + "Cryptography_HAS_EVP_PKEY_DHX": cryptography_has_evp_pkey_dhx, + "Cryptography_HAS_MEM_FUNCTIONS": cryptography_has_mem_functions, + "Cryptography_HAS_SCT": cryptography_has_sct, + "Cryptography_HAS_X509_STORE_CTX_GET_ISSUER": ( + cryptography_has_x509_store_ctx_get_issuer + ), + "Cryptography_HAS_ED448": cryptography_has_ed448, + "Cryptography_HAS_ED25519": cryptography_has_ed25519, + "Cryptography_HAS_POLY1305": cryptography_has_poly1305, + "Cryptography_HAS_ONESHOT_EVP_DIGEST_SIGN_VERIFY": ( + cryptography_has_oneshot_evp_digest_sign_verify + ), + "Cryptography_HAS_EVP_PKEY_get_set_tls_encodedpoint": ( + cryptography_has_evp_pkey_get_set_tls_encodedpoint + ), + "Cryptography_HAS_FIPS": cryptography_has_fips, + "Cryptography_HAS_SIGALGS": cryptography_has_ssl_sigalgs, + "Cryptography_HAS_PSK": cryptography_has_psk, + "Cryptography_HAS_CUSTOM_EXT": cryptography_has_custom_ext, + "Cryptography_HAS_OPENSSL_CLEANUP": cryptography_has_openssl_cleanup, + "Cryptography_HAS_TLSv1_3": cryptography_has_tlsv13, + "Cryptography_HAS_KEYLOG": cryptography_has_keylog, + "Cryptography_HAS_RAW_KEY": cryptography_has_raw_key, + "Cryptography_HAS_EVP_DIGESTFINAL_XOF": ( + cryptography_has_evp_digestfinal_xof + ), + "Cryptography_HAS_ENGINE": cryptography_has_engine, + "Cryptography_HAS_VERIFIED_CHAIN": cryptography_has_verified_chain, + "Cryptography_HAS_SRTP": cryptography_has_srtp, + "Cryptography_HAS_GET_PROTO_VERSION": cryptography_has_get_proto_version, +} diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/bindings/openssl/binding.py b/contrib/python/cryptography/py3/cryptography/hazmat/bindings/openssl/binding.py new file mode 100644 index 0000000000..7a84a340e4 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/bindings/openssl/binding.py @@ -0,0 +1,172 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import collections +import threading +import types + +import cryptography +from cryptography import utils +from cryptography.exceptions import InternalError +from cryptography.hazmat.bindings._openssl import ffi, lib +from cryptography.hazmat.bindings.openssl._conditional import CONDITIONAL_NAMES + +_OpenSSLErrorWithText = collections.namedtuple( + "_OpenSSLErrorWithText", ["code", "lib", "func", "reason", "reason_text"] +) + + +class _OpenSSLError(object): + def __init__(self, code, lib, func, reason): + self._code = code + self._lib = lib + self._func = func + self._reason = reason + + def _lib_reason_match(self, lib, reason): + return lib == self.lib and reason == self.reason + + code = utils.read_only_property("_code") + lib = utils.read_only_property("_lib") + func = utils.read_only_property("_func") + reason = utils.read_only_property("_reason") + + +def _consume_errors(lib): + errors = [] + while True: + code = lib.ERR_get_error() + if code == 0: + break + + err_lib = lib.ERR_GET_LIB(code) + err_func = lib.ERR_GET_FUNC(code) + err_reason = lib.ERR_GET_REASON(code) + + errors.append(_OpenSSLError(code, err_lib, err_func, err_reason)) + + return errors + + +def _errors_with_text(errors): + errors_with_text = [] + for err in errors: + buf = ffi.new("char[]", 256) + lib.ERR_error_string_n(err.code, buf, len(buf)) + err_text_reason = ffi.string(buf) + + errors_with_text.append( + _OpenSSLErrorWithText( + err.code, err.lib, err.func, err.reason, err_text_reason + ) + ) + + return errors_with_text + + +def _consume_errors_with_text(lib): + return _errors_with_text(_consume_errors(lib)) + + +def _openssl_assert(lib, ok, errors=None): + if not ok: + if errors is None: + errors = _consume_errors(lib) + errors_with_text = _errors_with_text(errors) + + raise InternalError( + "Unknown OpenSSL error. This error is commonly encountered when " + "another library is not cleaning up the OpenSSL error stack. If " + "you are using cryptography with another library that uses " + "OpenSSL try disabling it before reporting a bug. Otherwise " + "please file an issue at https://github.com/pyca/cryptography/" + "issues with information on how to reproduce " + "this. ({0!r})".format(errors_with_text), + errors_with_text, + ) + + +def build_conditional_library(lib, conditional_names): + conditional_lib = types.ModuleType("lib") + conditional_lib._original_lib = lib + excluded_names = set() + for condition, names_cb in conditional_names.items(): + if not getattr(lib, condition): + excluded_names.update(names_cb()) + + for attr in dir(lib): + if attr not in excluded_names: + setattr(conditional_lib, attr, getattr(lib, attr)) + + return conditional_lib + + +class Binding(object): + """ + OpenSSL API wrapper. + """ + + lib = None + ffi = ffi + _lib_loaded = False + _init_lock = threading.Lock() + + def __init__(self): + self._ensure_ffi_initialized() + + @classmethod + def _register_osrandom_engine(cls): + # Clear any errors extant in the queue before we start. In many + # scenarios other things may be interacting with OpenSSL in the same + # process space and it has proven untenable to assume that they will + # reliably clear the error queue. Once we clear it here we will + # error on any subsequent unexpected item in the stack. + cls.lib.ERR_clear_error() + if cls.lib.CRYPTOGRAPHY_NEEDS_OSRANDOM_ENGINE: + result = cls.lib.Cryptography_add_osrandom_engine() + _openssl_assert(cls.lib, result in (1, 2)) + + @classmethod + def _ensure_ffi_initialized(cls): + with cls._init_lock: + if not cls._lib_loaded: + cls.lib = build_conditional_library(lib, CONDITIONAL_NAMES) + cls._lib_loaded = True + # initialize the SSL library + cls.lib.SSL_library_init() + # adds all ciphers/digests for EVP + cls.lib.OpenSSL_add_all_algorithms() + cls._register_osrandom_engine() + + @classmethod + def init_static_locks(cls): + cls._ensure_ffi_initialized() + + +def _verify_package_version(version): + # Occasionally we run into situations where the version of the Python + # package does not match the version of the shared object that is loaded. + # This may occur in environments where multiple versions of cryptography + # are installed and available in the python path. To avoid errors cropping + # up later this code checks that the currently imported package and the + # shared object that were loaded have the same version and raise an + # ImportError if they do not + so_package_version = ffi.string(lib.CRYPTOGRAPHY_PACKAGE_VERSION) + if version.encode("ascii") != so_package_version: + raise ImportError( + "The version of cryptography does not match the loaded " + "shared object. This can happen if you have multiple copies of " + "cryptography installed in your Python path. Please try creating " + "a new virtual environment to resolve this issue. " + "Loaded python version: {}, shared object version: {}".format( + version, so_package_version + ) + ) + + +_verify_package_version(cryptography.__version__) + +Binding.init_static_locks() diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/__init__.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/__init__.py new file mode 100644 index 0000000000..4b540884df --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/__init__.py @@ -0,0 +1,5 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/__init__.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/__init__.py new file mode 100644 index 0000000000..494a7a1350 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/__init__.py @@ -0,0 +1,40 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + + +@six.add_metaclass(abc.ABCMeta) +class AsymmetricSignatureContext(object): + @abc.abstractmethod + def update(self, data): + """ + Processes the provided bytes and returns nothing. + """ + + @abc.abstractmethod + def finalize(self): + """ + Returns the signature as bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class AsymmetricVerificationContext(object): + @abc.abstractmethod + def update(self, data): + """ + Processes the provided bytes and returns nothing. + """ + + @abc.abstractmethod + def verify(self): + """ + Raises an exception if the bytes provided to update do not match the + signature or the signature does not match the public key. + """ diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/dh.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/dh.py new file mode 100644 index 0000000000..74a311d501 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/dh.py @@ -0,0 +1,224 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + +from cryptography import utils +from cryptography.hazmat.backends import _get_backend + + +_MIN_MODULUS_SIZE = 512 + + +def generate_parameters(generator, key_size, backend=None): + backend = _get_backend(backend) + return backend.generate_dh_parameters(generator, key_size) + + +class DHPrivateNumbers(object): + def __init__(self, x, public_numbers): + if not isinstance(x, six.integer_types): + raise TypeError("x must be an integer.") + + if not isinstance(public_numbers, DHPublicNumbers): + raise TypeError( + "public_numbers must be an instance of " "DHPublicNumbers." + ) + + self._x = x + self._public_numbers = public_numbers + + def __eq__(self, other): + if not isinstance(other, DHPrivateNumbers): + return NotImplemented + + return ( + self._x == other._x + and self._public_numbers == other._public_numbers + ) + + def __ne__(self, other): + return not self == other + + def private_key(self, backend=None): + backend = _get_backend(backend) + return backend.load_dh_private_numbers(self) + + public_numbers = utils.read_only_property("_public_numbers") + x = utils.read_only_property("_x") + + +class DHPublicNumbers(object): + def __init__(self, y, parameter_numbers): + if not isinstance(y, six.integer_types): + raise TypeError("y must be an integer.") + + if not isinstance(parameter_numbers, DHParameterNumbers): + raise TypeError( + "parameters must be an instance of DHParameterNumbers." + ) + + self._y = y + self._parameter_numbers = parameter_numbers + + def __eq__(self, other): + if not isinstance(other, DHPublicNumbers): + return NotImplemented + + return ( + self._y == other._y + and self._parameter_numbers == other._parameter_numbers + ) + + def __ne__(self, other): + return not self == other + + def public_key(self, backend=None): + backend = _get_backend(backend) + return backend.load_dh_public_numbers(self) + + y = utils.read_only_property("_y") + parameter_numbers = utils.read_only_property("_parameter_numbers") + + +class DHParameterNumbers(object): + def __init__(self, p, g, q=None): + if not isinstance(p, six.integer_types) or not isinstance( + g, six.integer_types + ): + raise TypeError("p and g must be integers") + if q is not None and not isinstance(q, six.integer_types): + raise TypeError("q must be integer or None") + + if g < 2: + raise ValueError("DH generator must be 2 or greater") + + if p.bit_length() < _MIN_MODULUS_SIZE: + raise ValueError( + "p (modulus) must be at least {}-bit".format(_MIN_MODULUS_SIZE) + ) + + self._p = p + self._g = g + self._q = q + + def __eq__(self, other): + if not isinstance(other, DHParameterNumbers): + return NotImplemented + + return ( + self._p == other._p and self._g == other._g and self._q == other._q + ) + + def __ne__(self, other): + return not self == other + + def parameters(self, backend=None): + backend = _get_backend(backend) + return backend.load_dh_parameter_numbers(self) + + p = utils.read_only_property("_p") + g = utils.read_only_property("_g") + q = utils.read_only_property("_q") + + +@six.add_metaclass(abc.ABCMeta) +class DHParameters(object): + @abc.abstractmethod + def generate_private_key(self): + """ + Generates and returns a DHPrivateKey. + """ + + @abc.abstractmethod + def parameter_bytes(self, encoding, format): + """ + Returns the parameters serialized as bytes. + """ + + @abc.abstractmethod + def parameter_numbers(self): + """ + Returns a DHParameterNumbers. + """ + + +DHParametersWithSerialization = DHParameters + + +@six.add_metaclass(abc.ABCMeta) +class DHPrivateKey(object): + @abc.abstractproperty + def key_size(self): + """ + The bit length of the prime modulus. + """ + + @abc.abstractmethod + def public_key(self): + """ + The DHPublicKey associated with this private key. + """ + + @abc.abstractmethod + def parameters(self): + """ + The DHParameters object associated with this private key. + """ + + @abc.abstractmethod + def exchange(self, peer_public_key): + """ + Given peer's DHPublicKey, carry out the key exchange and + return shared key as bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class DHPrivateKeyWithSerialization(DHPrivateKey): + @abc.abstractmethod + def private_numbers(self): + """ + Returns a DHPrivateNumbers. + """ + + @abc.abstractmethod + def private_bytes(self, encoding, format, encryption_algorithm): + """ + Returns the key serialized as bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class DHPublicKey(object): + @abc.abstractproperty + def key_size(self): + """ + The bit length of the prime modulus. + """ + + @abc.abstractmethod + def parameters(self): + """ + The DHParameters object associated with this public key. + """ + + @abc.abstractmethod + def public_numbers(self): + """ + Returns a DHPublicNumbers. + """ + + @abc.abstractmethod + def public_bytes(self, encoding, format): + """ + Returns the key serialized as bytes. + """ + + +DHPublicKeyWithSerialization = DHPublicKey diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/dsa.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/dsa.py new file mode 100644 index 0000000000..8ccc66665f --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/dsa.py @@ -0,0 +1,261 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + +from cryptography import utils +from cryptography.hazmat.backends import _get_backend + + +@six.add_metaclass(abc.ABCMeta) +class DSAParameters(object): + @abc.abstractmethod + def generate_private_key(self): + """ + Generates and returns a DSAPrivateKey. + """ + + +@six.add_metaclass(abc.ABCMeta) +class DSAParametersWithNumbers(DSAParameters): + @abc.abstractmethod + def parameter_numbers(self): + """ + Returns a DSAParameterNumbers. + """ + + +@six.add_metaclass(abc.ABCMeta) +class DSAPrivateKey(object): + @abc.abstractproperty + def key_size(self): + """ + The bit length of the prime modulus. + """ + + @abc.abstractmethod + def public_key(self): + """ + The DSAPublicKey associated with this private key. + """ + + @abc.abstractmethod + def parameters(self): + """ + The DSAParameters object associated with this private key. + """ + + @abc.abstractmethod + def signer(self, signature_algorithm): + """ + Returns an AsymmetricSignatureContext used for signing data. + """ + + @abc.abstractmethod + def sign(self, data, algorithm): + """ + Signs the data + """ + + +@six.add_metaclass(abc.ABCMeta) +class DSAPrivateKeyWithSerialization(DSAPrivateKey): + @abc.abstractmethod + def private_numbers(self): + """ + Returns a DSAPrivateNumbers. + """ + + @abc.abstractmethod + def private_bytes(self, encoding, format, encryption_algorithm): + """ + Returns the key serialized as bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class DSAPublicKey(object): + @abc.abstractproperty + def key_size(self): + """ + The bit length of the prime modulus. + """ + + @abc.abstractmethod + def parameters(self): + """ + The DSAParameters object associated with this public key. + """ + + @abc.abstractmethod + def verifier(self, signature, signature_algorithm): + """ + Returns an AsymmetricVerificationContext used for signing data. + """ + + @abc.abstractmethod + def public_numbers(self): + """ + Returns a DSAPublicNumbers. + """ + + @abc.abstractmethod + def public_bytes(self, encoding, format): + """ + Returns the key serialized as bytes. + """ + + @abc.abstractmethod + def verify(self, signature, data, algorithm): + """ + Verifies the signature of the data. + """ + + +DSAPublicKeyWithSerialization = DSAPublicKey + + +def generate_parameters(key_size, backend=None): + backend = _get_backend(backend) + return backend.generate_dsa_parameters(key_size) + + +def generate_private_key(key_size, backend=None): + backend = _get_backend(backend) + return backend.generate_dsa_private_key_and_parameters(key_size) + + +def _check_dsa_parameters(parameters): + if parameters.p.bit_length() not in [1024, 2048, 3072, 4096]: + raise ValueError( + "p must be exactly 1024, 2048, 3072, or 4096 bits long" + ) + if parameters.q.bit_length() not in [160, 224, 256]: + raise ValueError("q must be exactly 160, 224, or 256 bits long") + + if not (1 < parameters.g < parameters.p): + raise ValueError("g, p don't satisfy 1 < g < p.") + + +def _check_dsa_private_numbers(numbers): + parameters = numbers.public_numbers.parameter_numbers + _check_dsa_parameters(parameters) + if numbers.x <= 0 or numbers.x >= parameters.q: + raise ValueError("x must be > 0 and < q.") + + if numbers.public_numbers.y != pow(parameters.g, numbers.x, parameters.p): + raise ValueError("y must be equal to (g ** x % p).") + + +class DSAParameterNumbers(object): + def __init__(self, p, q, g): + if ( + not isinstance(p, six.integer_types) + or not isinstance(q, six.integer_types) + or not isinstance(g, six.integer_types) + ): + raise TypeError( + "DSAParameterNumbers p, q, and g arguments must be integers." + ) + + self._p = p + self._q = q + self._g = g + + p = utils.read_only_property("_p") + q = utils.read_only_property("_q") + g = utils.read_only_property("_g") + + def parameters(self, backend=None): + backend = _get_backend(backend) + return backend.load_dsa_parameter_numbers(self) + + def __eq__(self, other): + if not isinstance(other, DSAParameterNumbers): + return NotImplemented + + return self.p == other.p and self.q == other.q and self.g == other.g + + def __ne__(self, other): + return not self == other + + def __repr__(self): + return ( + "<DSAParameterNumbers(p={self.p}, q={self.q}, " + "g={self.g})>".format(self=self) + ) + + +class DSAPublicNumbers(object): + def __init__(self, y, parameter_numbers): + if not isinstance(y, six.integer_types): + raise TypeError("DSAPublicNumbers y argument must be an integer.") + + if not isinstance(parameter_numbers, DSAParameterNumbers): + raise TypeError( + "parameter_numbers must be a DSAParameterNumbers instance." + ) + + self._y = y + self._parameter_numbers = parameter_numbers + + y = utils.read_only_property("_y") + parameter_numbers = utils.read_only_property("_parameter_numbers") + + def public_key(self, backend=None): + backend = _get_backend(backend) + return backend.load_dsa_public_numbers(self) + + def __eq__(self, other): + if not isinstance(other, DSAPublicNumbers): + return NotImplemented + + return ( + self.y == other.y + and self.parameter_numbers == other.parameter_numbers + ) + + def __ne__(self, other): + return not self == other + + def __repr__(self): + return ( + "<DSAPublicNumbers(y={self.y}, " + "parameter_numbers={self.parameter_numbers})>".format(self=self) + ) + + +class DSAPrivateNumbers(object): + def __init__(self, x, public_numbers): + if not isinstance(x, six.integer_types): + raise TypeError("DSAPrivateNumbers x argument must be an integer.") + + if not isinstance(public_numbers, DSAPublicNumbers): + raise TypeError( + "public_numbers must be a DSAPublicNumbers instance." + ) + self._public_numbers = public_numbers + self._x = x + + x = utils.read_only_property("_x") + public_numbers = utils.read_only_property("_public_numbers") + + def private_key(self, backend=None): + backend = _get_backend(backend) + return backend.load_dsa_private_numbers(self) + + def __eq__(self, other): + if not isinstance(other, DSAPrivateNumbers): + return NotImplemented + + return ( + self.x == other.x and self.public_numbers == other.public_numbers + ) + + def __ne__(self, other): + return not self == other diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/ec.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/ec.py new file mode 100644 index 0000000000..c7e694fc56 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/ec.py @@ -0,0 +1,502 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc +import warnings + +import six + +from cryptography import utils +from cryptography.hazmat._oid import ObjectIdentifier +from cryptography.hazmat.backends import _get_backend + + +class EllipticCurveOID(object): + SECP192R1 = ObjectIdentifier("1.2.840.10045.3.1.1") + SECP224R1 = ObjectIdentifier("1.3.132.0.33") + SECP256K1 = ObjectIdentifier("1.3.132.0.10") + SECP256R1 = ObjectIdentifier("1.2.840.10045.3.1.7") + SECP384R1 = ObjectIdentifier("1.3.132.0.34") + SECP521R1 = ObjectIdentifier("1.3.132.0.35") + BRAINPOOLP256R1 = ObjectIdentifier("1.3.36.3.3.2.8.1.1.7") + BRAINPOOLP384R1 = ObjectIdentifier("1.3.36.3.3.2.8.1.1.11") + BRAINPOOLP512R1 = ObjectIdentifier("1.3.36.3.3.2.8.1.1.13") + SECT163K1 = ObjectIdentifier("1.3.132.0.1") + SECT163R2 = ObjectIdentifier("1.3.132.0.15") + SECT233K1 = ObjectIdentifier("1.3.132.0.26") + SECT233R1 = ObjectIdentifier("1.3.132.0.27") + SECT283K1 = ObjectIdentifier("1.3.132.0.16") + SECT283R1 = ObjectIdentifier("1.3.132.0.17") + SECT409K1 = ObjectIdentifier("1.3.132.0.36") + SECT409R1 = ObjectIdentifier("1.3.132.0.37") + SECT571K1 = ObjectIdentifier("1.3.132.0.38") + SECT571R1 = ObjectIdentifier("1.3.132.0.39") + + +@six.add_metaclass(abc.ABCMeta) +class EllipticCurve(object): + @abc.abstractproperty + def name(self): + """ + The name of the curve. e.g. secp256r1. + """ + + @abc.abstractproperty + def key_size(self): + """ + Bit size of a secret scalar for the curve. + """ + + +@six.add_metaclass(abc.ABCMeta) +class EllipticCurveSignatureAlgorithm(object): + @abc.abstractproperty + def algorithm(self): + """ + The digest algorithm used with this signature. + """ + + +@six.add_metaclass(abc.ABCMeta) +class EllipticCurvePrivateKey(object): + @abc.abstractmethod + def signer(self, signature_algorithm): + """ + Returns an AsymmetricSignatureContext used for signing data. + """ + + @abc.abstractmethod + def exchange(self, algorithm, peer_public_key): + """ + Performs a key exchange operation using the provided algorithm with the + provided peer's public key. + """ + + @abc.abstractmethod + def public_key(self): + """ + The EllipticCurvePublicKey for this private key. + """ + + @abc.abstractproperty + def curve(self): + """ + The EllipticCurve that this key is on. + """ + + @abc.abstractproperty + def key_size(self): + """ + Bit size of a secret scalar for the curve. + """ + + @abc.abstractmethod + def sign(self, data, signature_algorithm): + """ + Signs the data + """ + + +@six.add_metaclass(abc.ABCMeta) +class EllipticCurvePrivateKeyWithSerialization(EllipticCurvePrivateKey): + @abc.abstractmethod + def private_numbers(self): + """ + Returns an EllipticCurvePrivateNumbers. + """ + + @abc.abstractmethod + def private_bytes(self, encoding, format, encryption_algorithm): + """ + Returns the key serialized as bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class EllipticCurvePublicKey(object): + @abc.abstractmethod + def verifier(self, signature, signature_algorithm): + """ + Returns an AsymmetricVerificationContext used for signing data. + """ + + @abc.abstractproperty + def curve(self): + """ + The EllipticCurve that this key is on. + """ + + @abc.abstractproperty + def key_size(self): + """ + Bit size of a secret scalar for the curve. + """ + + @abc.abstractmethod + def public_numbers(self): + """ + Returns an EllipticCurvePublicNumbers. + """ + + @abc.abstractmethod + def public_bytes(self, encoding, format): + """ + Returns the key serialized as bytes. + """ + + @abc.abstractmethod + def verify(self, signature, data, signature_algorithm): + """ + Verifies the signature of the data. + """ + + @classmethod + def from_encoded_point(cls, curve, data): + utils._check_bytes("data", data) + + if not isinstance(curve, EllipticCurve): + raise TypeError("curve must be an EllipticCurve instance") + + if len(data) == 0: + raise ValueError("data must not be an empty byte string") + + if six.indexbytes(data, 0) not in [0x02, 0x03, 0x04]: + raise ValueError("Unsupported elliptic curve point type") + + from cryptography.hazmat.backends.openssl.backend import backend + + return backend.load_elliptic_curve_public_bytes(curve, data) + + +EllipticCurvePublicKeyWithSerialization = EllipticCurvePublicKey + + +@utils.register_interface(EllipticCurve) +class SECT571R1(object): + name = "sect571r1" + key_size = 570 + + +@utils.register_interface(EllipticCurve) +class SECT409R1(object): + name = "sect409r1" + key_size = 409 + + +@utils.register_interface(EllipticCurve) +class SECT283R1(object): + name = "sect283r1" + key_size = 283 + + +@utils.register_interface(EllipticCurve) +class SECT233R1(object): + name = "sect233r1" + key_size = 233 + + +@utils.register_interface(EllipticCurve) +class SECT163R2(object): + name = "sect163r2" + key_size = 163 + + +@utils.register_interface(EllipticCurve) +class SECT571K1(object): + name = "sect571k1" + key_size = 571 + + +@utils.register_interface(EllipticCurve) +class SECT409K1(object): + name = "sect409k1" + key_size = 409 + + +@utils.register_interface(EllipticCurve) +class SECT283K1(object): + name = "sect283k1" + key_size = 283 + + +@utils.register_interface(EllipticCurve) +class SECT233K1(object): + name = "sect233k1" + key_size = 233 + + +@utils.register_interface(EllipticCurve) +class SECT163K1(object): + name = "sect163k1" + key_size = 163 + + +@utils.register_interface(EllipticCurve) +class SECP521R1(object): + name = "secp521r1" + key_size = 521 + + +@utils.register_interface(EllipticCurve) +class SECP384R1(object): + name = "secp384r1" + key_size = 384 + + +@utils.register_interface(EllipticCurve) +class SECP256R1(object): + name = "secp256r1" + key_size = 256 + + +@utils.register_interface(EllipticCurve) +class SECP256K1(object): + name = "secp256k1" + key_size = 256 + + +@utils.register_interface(EllipticCurve) +class SECP224R1(object): + name = "secp224r1" + key_size = 224 + + +@utils.register_interface(EllipticCurve) +class SECP192R1(object): + name = "secp192r1" + key_size = 192 + + +@utils.register_interface(EllipticCurve) +class BrainpoolP256R1(object): + name = "brainpoolP256r1" + key_size = 256 + + +@utils.register_interface(EllipticCurve) +class BrainpoolP384R1(object): + name = "brainpoolP384r1" + key_size = 384 + + +@utils.register_interface(EllipticCurve) +class BrainpoolP512R1(object): + name = "brainpoolP512r1" + key_size = 512 + + +_CURVE_TYPES = { + "prime192v1": SECP192R1, + "prime256v1": SECP256R1, + "secp192r1": SECP192R1, + "secp224r1": SECP224R1, + "secp256r1": SECP256R1, + "secp384r1": SECP384R1, + "secp521r1": SECP521R1, + "secp256k1": SECP256K1, + "sect163k1": SECT163K1, + "sect233k1": SECT233K1, + "sect283k1": SECT283K1, + "sect409k1": SECT409K1, + "sect571k1": SECT571K1, + "sect163r2": SECT163R2, + "sect233r1": SECT233R1, + "sect283r1": SECT283R1, + "sect409r1": SECT409R1, + "sect571r1": SECT571R1, + "brainpoolP256r1": BrainpoolP256R1, + "brainpoolP384r1": BrainpoolP384R1, + "brainpoolP512r1": BrainpoolP512R1, +} + + +@utils.register_interface(EllipticCurveSignatureAlgorithm) +class ECDSA(object): + def __init__(self, algorithm): + self._algorithm = algorithm + + algorithm = utils.read_only_property("_algorithm") + + +def generate_private_key(curve, backend=None): + backend = _get_backend(backend) + return backend.generate_elliptic_curve_private_key(curve) + + +def derive_private_key(private_value, curve, backend=None): + backend = _get_backend(backend) + if not isinstance(private_value, six.integer_types): + raise TypeError("private_value must be an integer type.") + + if private_value <= 0: + raise ValueError("private_value must be a positive integer.") + + if not isinstance(curve, EllipticCurve): + raise TypeError("curve must provide the EllipticCurve interface.") + + return backend.derive_elliptic_curve_private_key(private_value, curve) + + +class EllipticCurvePublicNumbers(object): + def __init__(self, x, y, curve): + if not isinstance(x, six.integer_types) or not isinstance( + y, six.integer_types + ): + raise TypeError("x and y must be integers.") + + if not isinstance(curve, EllipticCurve): + raise TypeError("curve must provide the EllipticCurve interface.") + + self._y = y + self._x = x + self._curve = curve + + def public_key(self, backend=None): + backend = _get_backend(backend) + return backend.load_elliptic_curve_public_numbers(self) + + def encode_point(self): + warnings.warn( + "encode_point has been deprecated on EllipticCurvePublicNumbers" + " and will be removed in a future version. Please use " + "EllipticCurvePublicKey.public_bytes to obtain both " + "compressed and uncompressed point encoding.", + utils.PersistentlyDeprecated2019, + stacklevel=2, + ) + # key_size is in bits. Convert to bytes and round up + byte_length = (self.curve.key_size + 7) // 8 + return ( + b"\x04" + + utils.int_to_bytes(self.x, byte_length) + + utils.int_to_bytes(self.y, byte_length) + ) + + @classmethod + def from_encoded_point(cls, curve, data): + if not isinstance(curve, EllipticCurve): + raise TypeError("curve must be an EllipticCurve instance") + + warnings.warn( + "Support for unsafe construction of public numbers from " + "encoded data will be removed in a future version. " + "Please use EllipticCurvePublicKey.from_encoded_point", + utils.PersistentlyDeprecated2019, + stacklevel=2, + ) + + if data.startswith(b"\x04"): + # key_size is in bits. Convert to bytes and round up + byte_length = (curve.key_size + 7) // 8 + if len(data) == 2 * byte_length + 1: + x = utils.int_from_bytes(data[1 : byte_length + 1], "big") + y = utils.int_from_bytes(data[byte_length + 1 :], "big") + return cls(x, y, curve) + else: + raise ValueError("Invalid elliptic curve point data length") + else: + raise ValueError("Unsupported elliptic curve point type") + + curve = utils.read_only_property("_curve") + x = utils.read_only_property("_x") + y = utils.read_only_property("_y") + + def __eq__(self, other): + if not isinstance(other, EllipticCurvePublicNumbers): + return NotImplemented + + return ( + self.x == other.x + and self.y == other.y + and self.curve.name == other.curve.name + and self.curve.key_size == other.curve.key_size + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.x, self.y, self.curve.name, self.curve.key_size)) + + def __repr__(self): + return ( + "<EllipticCurvePublicNumbers(curve={0.curve.name}, x={0.x}, " + "y={0.y}>".format(self) + ) + + +class EllipticCurvePrivateNumbers(object): + def __init__(self, private_value, public_numbers): + if not isinstance(private_value, six.integer_types): + raise TypeError("private_value must be an integer.") + + if not isinstance(public_numbers, EllipticCurvePublicNumbers): + raise TypeError( + "public_numbers must be an EllipticCurvePublicNumbers " + "instance." + ) + + self._private_value = private_value + self._public_numbers = public_numbers + + def private_key(self, backend=None): + backend = _get_backend(backend) + return backend.load_elliptic_curve_private_numbers(self) + + private_value = utils.read_only_property("_private_value") + public_numbers = utils.read_only_property("_public_numbers") + + def __eq__(self, other): + if not isinstance(other, EllipticCurvePrivateNumbers): + return NotImplemented + + return ( + self.private_value == other.private_value + and self.public_numbers == other.public_numbers + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.private_value, self.public_numbers)) + + +class ECDH(object): + pass + + +_OID_TO_CURVE = { + EllipticCurveOID.SECP192R1: SECP192R1, + EllipticCurveOID.SECP224R1: SECP224R1, + EllipticCurveOID.SECP256K1: SECP256K1, + EllipticCurveOID.SECP256R1: SECP256R1, + EllipticCurveOID.SECP384R1: SECP384R1, + EllipticCurveOID.SECP521R1: SECP521R1, + EllipticCurveOID.BRAINPOOLP256R1: BrainpoolP256R1, + EllipticCurveOID.BRAINPOOLP384R1: BrainpoolP384R1, + EllipticCurveOID.BRAINPOOLP512R1: BrainpoolP512R1, + EllipticCurveOID.SECT163K1: SECT163K1, + EllipticCurveOID.SECT163R2: SECT163R2, + EllipticCurveOID.SECT233K1: SECT233K1, + EllipticCurveOID.SECT233R1: SECT233R1, + EllipticCurveOID.SECT283K1: SECT283K1, + EllipticCurveOID.SECT283R1: SECT283R1, + EllipticCurveOID.SECT409K1: SECT409K1, + EllipticCurveOID.SECT409R1: SECT409R1, + EllipticCurveOID.SECT571K1: SECT571K1, + EllipticCurveOID.SECT571R1: SECT571R1, +} + + +def get_curve_for_oid(oid): + try: + return _OID_TO_CURVE[oid] + except KeyError: + raise LookupError( + "The provided object identifier has no matching elliptic " + "curve class" + ) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/ed25519.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/ed25519.py new file mode 100644 index 0000000000..2d07a029bc --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/ed25519.py @@ -0,0 +1,87 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + +from cryptography.exceptions import UnsupportedAlgorithm, _Reasons + + +_ED25519_KEY_SIZE = 32 +_ED25519_SIG_SIZE = 64 + + +@six.add_metaclass(abc.ABCMeta) +class Ed25519PublicKey(object): + @classmethod + def from_public_bytes(cls, data): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.ed25519_supported(): + raise UnsupportedAlgorithm( + "ed25519 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, + ) + + return backend.ed25519_load_public_bytes(data) + + @abc.abstractmethod + def public_bytes(self, encoding, format): + """ + The serialized bytes of the public key. + """ + + @abc.abstractmethod + def verify(self, signature, data): + """ + Verify the signature. + """ + + +@six.add_metaclass(abc.ABCMeta) +class Ed25519PrivateKey(object): + @classmethod + def generate(cls): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.ed25519_supported(): + raise UnsupportedAlgorithm( + "ed25519 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, + ) + + return backend.ed25519_generate_key() + + @classmethod + def from_private_bytes(cls, data): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.ed25519_supported(): + raise UnsupportedAlgorithm( + "ed25519 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, + ) + + return backend.ed25519_load_private_bytes(data) + + @abc.abstractmethod + def public_key(self): + """ + The Ed25519PublicKey derived from the private key. + """ + + @abc.abstractmethod + def private_bytes(self, encoding, format, encryption_algorithm): + """ + The serialized bytes of the private key. + """ + + @abc.abstractmethod + def sign(self, data): + """ + Signs the data. + """ diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/ed448.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/ed448.py new file mode 100644 index 0000000000..520ffcbcbc --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/ed448.py @@ -0,0 +1,82 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + +from cryptography.exceptions import UnsupportedAlgorithm, _Reasons + + +@six.add_metaclass(abc.ABCMeta) +class Ed448PublicKey(object): + @classmethod + def from_public_bytes(cls, data): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.ed448_supported(): + raise UnsupportedAlgorithm( + "ed448 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, + ) + + return backend.ed448_load_public_bytes(data) + + @abc.abstractmethod + def public_bytes(self, encoding, format): + """ + The serialized bytes of the public key. + """ + + @abc.abstractmethod + def verify(self, signature, data): + """ + Verify the signature. + """ + + +@six.add_metaclass(abc.ABCMeta) +class Ed448PrivateKey(object): + @classmethod + def generate(cls): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.ed448_supported(): + raise UnsupportedAlgorithm( + "ed448 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, + ) + return backend.ed448_generate_key() + + @classmethod + def from_private_bytes(cls, data): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.ed448_supported(): + raise UnsupportedAlgorithm( + "ed448 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM, + ) + + return backend.ed448_load_private_bytes(data) + + @abc.abstractmethod + def public_key(self): + """ + The Ed448PublicKey derived from the private key. + """ + + @abc.abstractmethod + def sign(self, data): + """ + Signs the data. + """ + + @abc.abstractmethod + def private_bytes(self, encoding, format, encryption_algorithm): + """ + The serialized bytes of the private key. + """ diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/padding.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/padding.py new file mode 100644 index 0000000000..fc8f6e26a9 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/padding.py @@ -0,0 +1,80 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + +from cryptography import utils +from cryptography.hazmat.primitives import hashes +from cryptography.hazmat.primitives.asymmetric import rsa + + +@six.add_metaclass(abc.ABCMeta) +class AsymmetricPadding(object): + @abc.abstractproperty + def name(self): + """ + A string naming this padding (e.g. "PSS", "PKCS1"). + """ + + +@utils.register_interface(AsymmetricPadding) +class PKCS1v15(object): + name = "EMSA-PKCS1-v1_5" + + +@utils.register_interface(AsymmetricPadding) +class PSS(object): + MAX_LENGTH = object() + name = "EMSA-PSS" + + def __init__(self, mgf, salt_length): + self._mgf = mgf + + if ( + not isinstance(salt_length, six.integer_types) + and salt_length is not self.MAX_LENGTH + ): + raise TypeError("salt_length must be an integer.") + + if salt_length is not self.MAX_LENGTH and salt_length < 0: + raise ValueError("salt_length must be zero or greater.") + + self._salt_length = salt_length + + +@utils.register_interface(AsymmetricPadding) +class OAEP(object): + name = "EME-OAEP" + + def __init__(self, mgf, algorithm, label): + if not isinstance(algorithm, hashes.HashAlgorithm): + raise TypeError("Expected instance of hashes.HashAlgorithm.") + + self._mgf = mgf + self._algorithm = algorithm + self._label = label + + +class MGF1(object): + MAX_LENGTH = object() + + def __init__(self, algorithm): + if not isinstance(algorithm, hashes.HashAlgorithm): + raise TypeError("Expected instance of hashes.HashAlgorithm.") + + self._algorithm = algorithm + + +def calculate_max_pss_salt_length(key, hash_algorithm): + if not isinstance(key, (rsa.RSAPrivateKey, rsa.RSAPublicKey)): + raise TypeError("key must be an RSA public or private key") + # bit length - 1 per RFC 3447 + emlen = (key.key_size + 6) // 8 + salt_length = emlen - hash_algorithm.digest_size - 2 + assert salt_length >= 0 + return salt_length diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/rsa.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/rsa.py new file mode 100644 index 0000000000..ea16bbf66e --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/rsa.py @@ -0,0 +1,380 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +try: + # Only available in math in 3.5+ + from math import gcd +except ImportError: + from fractions import gcd + +import six + +from cryptography import utils +from cryptography.exceptions import UnsupportedAlgorithm, _Reasons +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import RSABackend + + +@six.add_metaclass(abc.ABCMeta) +class RSAPrivateKey(object): + @abc.abstractmethod + def signer(self, padding, algorithm): + """ + Returns an AsymmetricSignatureContext used for signing data. + """ + + @abc.abstractmethod + def decrypt(self, ciphertext, padding): + """ + Decrypts the provided ciphertext. + """ + + @abc.abstractproperty + def key_size(self): + """ + The bit length of the public modulus. + """ + + @abc.abstractmethod + def public_key(self): + """ + The RSAPublicKey associated with this private key. + """ + + @abc.abstractmethod + def sign(self, data, padding, algorithm): + """ + Signs the data. + """ + + +@six.add_metaclass(abc.ABCMeta) +class RSAPrivateKeyWithSerialization(RSAPrivateKey): + @abc.abstractmethod + def private_numbers(self): + """ + Returns an RSAPrivateNumbers. + """ + + @abc.abstractmethod + def private_bytes(self, encoding, format, encryption_algorithm): + """ + Returns the key serialized as bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class RSAPublicKey(object): + @abc.abstractmethod + def verifier(self, signature, padding, algorithm): + """ + Returns an AsymmetricVerificationContext used for verifying signatures. + """ + + @abc.abstractmethod + def encrypt(self, plaintext, padding): + """ + Encrypts the given plaintext. + """ + + @abc.abstractproperty + def key_size(self): + """ + The bit length of the public modulus. + """ + + @abc.abstractmethod + def public_numbers(self): + """ + Returns an RSAPublicNumbers + """ + + @abc.abstractmethod + def public_bytes(self, encoding, format): + """ + Returns the key serialized as bytes. + """ + + @abc.abstractmethod + def verify(self, signature, data, padding, algorithm): + """ + Verifies the signature of the data. + """ + + @abc.abstractmethod + def recover_data_from_signature(self, signature, padding, algorithm): + """ + Recovers the original data from the signature. + """ + + +RSAPublicKeyWithSerialization = RSAPublicKey + + +def generate_private_key(public_exponent, key_size, backend=None): + backend = _get_backend(backend) + if not isinstance(backend, RSABackend): + raise UnsupportedAlgorithm( + "Backend object does not implement RSABackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + _verify_rsa_parameters(public_exponent, key_size) + return backend.generate_rsa_private_key(public_exponent, key_size) + + +def _verify_rsa_parameters(public_exponent, key_size): + if public_exponent not in (3, 65537): + raise ValueError( + "public_exponent must be either 3 (for legacy compatibility) or " + "65537. Almost everyone should choose 65537 here!" + ) + + if key_size < 512: + raise ValueError("key_size must be at least 512-bits.") + + +def _check_private_key_components( + p, q, private_exponent, dmp1, dmq1, iqmp, public_exponent, modulus +): + if modulus < 3: + raise ValueError("modulus must be >= 3.") + + if p >= modulus: + raise ValueError("p must be < modulus.") + + if q >= modulus: + raise ValueError("q must be < modulus.") + + if dmp1 >= modulus: + raise ValueError("dmp1 must be < modulus.") + + if dmq1 >= modulus: + raise ValueError("dmq1 must be < modulus.") + + if iqmp >= modulus: + raise ValueError("iqmp must be < modulus.") + + if private_exponent >= modulus: + raise ValueError("private_exponent must be < modulus.") + + if public_exponent < 3 or public_exponent >= modulus: + raise ValueError("public_exponent must be >= 3 and < modulus.") + + if public_exponent & 1 == 0: + raise ValueError("public_exponent must be odd.") + + if dmp1 & 1 == 0: + raise ValueError("dmp1 must be odd.") + + if dmq1 & 1 == 0: + raise ValueError("dmq1 must be odd.") + + if p * q != modulus: + raise ValueError("p*q must equal modulus.") + + +def _check_public_key_components(e, n): + if n < 3: + raise ValueError("n must be >= 3.") + + if e < 3 or e >= n: + raise ValueError("e must be >= 3 and < n.") + + if e & 1 == 0: + raise ValueError("e must be odd.") + + +def _modinv(e, m): + """ + Modular Multiplicative Inverse. Returns x such that: (x*e) mod m == 1 + """ + x1, x2 = 1, 0 + a, b = e, m + while b > 0: + q, r = divmod(a, b) + xn = x1 - q * x2 + a, b, x1, x2 = b, r, x2, xn + return x1 % m + + +def rsa_crt_iqmp(p, q): + """ + Compute the CRT (q ** -1) % p value from RSA primes p and q. + """ + return _modinv(q, p) + + +def rsa_crt_dmp1(private_exponent, p): + """ + Compute the CRT private_exponent % (p - 1) value from the RSA + private_exponent (d) and p. + """ + return private_exponent % (p - 1) + + +def rsa_crt_dmq1(private_exponent, q): + """ + Compute the CRT private_exponent % (q - 1) value from the RSA + private_exponent (d) and q. + """ + return private_exponent % (q - 1) + + +# Controls the number of iterations rsa_recover_prime_factors will perform +# to obtain the prime factors. Each iteration increments by 2 so the actual +# maximum attempts is half this number. +_MAX_RECOVERY_ATTEMPTS = 1000 + + +def rsa_recover_prime_factors(n, e, d): + """ + Compute factors p and q from the private exponent d. We assume that n has + no more than two factors. This function is adapted from code in PyCrypto. + """ + # See 8.2.2(i) in Handbook of Applied Cryptography. + ktot = d * e - 1 + # The quantity d*e-1 is a multiple of phi(n), even, + # and can be represented as t*2^s. + t = ktot + while t % 2 == 0: + t = t // 2 + # Cycle through all multiplicative inverses in Zn. + # The algorithm is non-deterministic, but there is a 50% chance + # any candidate a leads to successful factoring. + # See "Digitalized Signatures and Public Key Functions as Intractable + # as Factorization", M. Rabin, 1979 + spotted = False + a = 2 + while not spotted and a < _MAX_RECOVERY_ATTEMPTS: + k = t + # Cycle through all values a^{t*2^i}=a^k + while k < ktot: + cand = pow(a, k, n) + # Check if a^k is a non-trivial root of unity (mod n) + if cand != 1 and cand != (n - 1) and pow(cand, 2, n) == 1: + # We have found a number such that (cand-1)(cand+1)=0 (mod n). + # Either of the terms divides n. + p = gcd(cand + 1, n) + spotted = True + break + k *= 2 + # This value was not any good... let's try another! + a += 2 + if not spotted: + raise ValueError("Unable to compute factors p and q from exponent d.") + # Found ! + q, r = divmod(n, p) + assert r == 0 + p, q = sorted((p, q), reverse=True) + return (p, q) + + +class RSAPrivateNumbers(object): + def __init__(self, p, q, d, dmp1, dmq1, iqmp, public_numbers): + if ( + not isinstance(p, six.integer_types) + or not isinstance(q, six.integer_types) + or not isinstance(d, six.integer_types) + or not isinstance(dmp1, six.integer_types) + or not isinstance(dmq1, six.integer_types) + or not isinstance(iqmp, six.integer_types) + ): + raise TypeError( + "RSAPrivateNumbers p, q, d, dmp1, dmq1, iqmp arguments must" + " all be an integers." + ) + + if not isinstance(public_numbers, RSAPublicNumbers): + raise TypeError( + "RSAPrivateNumbers public_numbers must be an RSAPublicNumbers" + " instance." + ) + + self._p = p + self._q = q + self._d = d + self._dmp1 = dmp1 + self._dmq1 = dmq1 + self._iqmp = iqmp + self._public_numbers = public_numbers + + p = utils.read_only_property("_p") + q = utils.read_only_property("_q") + d = utils.read_only_property("_d") + dmp1 = utils.read_only_property("_dmp1") + dmq1 = utils.read_only_property("_dmq1") + iqmp = utils.read_only_property("_iqmp") + public_numbers = utils.read_only_property("_public_numbers") + + def private_key(self, backend=None): + backend = _get_backend(backend) + return backend.load_rsa_private_numbers(self) + + def __eq__(self, other): + if not isinstance(other, RSAPrivateNumbers): + return NotImplemented + + return ( + self.p == other.p + and self.q == other.q + and self.d == other.d + and self.dmp1 == other.dmp1 + and self.dmq1 == other.dmq1 + and self.iqmp == other.iqmp + and self.public_numbers == other.public_numbers + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash( + ( + self.p, + self.q, + self.d, + self.dmp1, + self.dmq1, + self.iqmp, + self.public_numbers, + ) + ) + + +class RSAPublicNumbers(object): + def __init__(self, e, n): + if not isinstance(e, six.integer_types) or not isinstance( + n, six.integer_types + ): + raise TypeError("RSAPublicNumbers arguments must be integers.") + + self._e = e + self._n = n + + e = utils.read_only_property("_e") + n = utils.read_only_property("_n") + + def public_key(self, backend=None): + backend = _get_backend(backend) + return backend.load_rsa_public_numbers(self) + + def __repr__(self): + return "<RSAPublicNumbers(e={0.e}, n={0.n})>".format(self) + + def __eq__(self, other): + if not isinstance(other, RSAPublicNumbers): + return NotImplemented + + return self.e == other.e and self.n == other.n + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.e, self.n)) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/utils.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/utils.py new file mode 100644 index 0000000000..5f9b677868 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/utils.py @@ -0,0 +1,41 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.hazmat._der import ( + DERReader, + INTEGER, + SEQUENCE, + encode_der, + encode_der_integer, +) +from cryptography.hazmat.primitives import hashes + + +def decode_dss_signature(signature): + with DERReader(signature).read_single_element(SEQUENCE) as seq: + r = seq.read_element(INTEGER).as_integer() + s = seq.read_element(INTEGER).as_integer() + return r, s + + +def encode_dss_signature(r, s): + return encode_der( + SEQUENCE, + encode_der(INTEGER, encode_der_integer(r)), + encode_der(INTEGER, encode_der_integer(s)), + ) + + +class Prehashed(object): + def __init__(self, algorithm): + if not isinstance(algorithm, hashes.HashAlgorithm): + raise TypeError("Expected instance of HashAlgorithm.") + + self._algorithm = algorithm + self._digest_size = algorithm.digest_size + + digest_size = utils.read_only_property("_digest_size") diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/x25519.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/x25519.py new file mode 100644 index 0000000000..fc63691536 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/x25519.py @@ -0,0 +1,76 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + +from cryptography.exceptions import UnsupportedAlgorithm, _Reasons + + +@six.add_metaclass(abc.ABCMeta) +class X25519PublicKey(object): + @classmethod + def from_public_bytes(cls, data): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.x25519_supported(): + raise UnsupportedAlgorithm( + "X25519 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, + ) + + return backend.x25519_load_public_bytes(data) + + @abc.abstractmethod + def public_bytes(self, encoding, format): + """ + The serialized bytes of the public key. + """ + + +@six.add_metaclass(abc.ABCMeta) +class X25519PrivateKey(object): + @classmethod + def generate(cls): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.x25519_supported(): + raise UnsupportedAlgorithm( + "X25519 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, + ) + return backend.x25519_generate_key() + + @classmethod + def from_private_bytes(cls, data): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.x25519_supported(): + raise UnsupportedAlgorithm( + "X25519 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, + ) + + return backend.x25519_load_private_bytes(data) + + @abc.abstractmethod + def public_key(self): + """ + The serialized bytes of the public key. + """ + + @abc.abstractmethod + def private_bytes(self, encoding, format, encryption_algorithm): + """ + The serialized bytes of the private key. + """ + + @abc.abstractmethod + def exchange(self, peer_public_key): + """ + Performs a key exchange operation using the provided peer's public key. + """ diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/x448.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/x448.py new file mode 100644 index 0000000000..3ac067bfd5 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/asymmetric/x448.py @@ -0,0 +1,76 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + +from cryptography.exceptions import UnsupportedAlgorithm, _Reasons + + +@six.add_metaclass(abc.ABCMeta) +class X448PublicKey(object): + @classmethod + def from_public_bytes(cls, data): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.x448_supported(): + raise UnsupportedAlgorithm( + "X448 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, + ) + + return backend.x448_load_public_bytes(data) + + @abc.abstractmethod + def public_bytes(self, encoding, format): + """ + The serialized bytes of the public key. + """ + + +@six.add_metaclass(abc.ABCMeta) +class X448PrivateKey(object): + @classmethod + def generate(cls): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.x448_supported(): + raise UnsupportedAlgorithm( + "X448 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, + ) + return backend.x448_generate_key() + + @classmethod + def from_private_bytes(cls, data): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.x448_supported(): + raise UnsupportedAlgorithm( + "X448 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_EXCHANGE_ALGORITHM, + ) + + return backend.x448_load_private_bytes(data) + + @abc.abstractmethod + def public_key(self): + """ + The serialized bytes of the public key. + """ + + @abc.abstractmethod + def private_bytes(self, encoding, format, encryption_algorithm): + """ + The serialized bytes of the private key. + """ + + @abc.abstractmethod + def exchange(self, peer_public_key): + """ + Performs a key exchange operation using the provided peer's public key. + """ diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/__init__.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/__init__.py new file mode 100644 index 0000000000..4380f72b2e --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/__init__.py @@ -0,0 +1,26 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography.hazmat.primitives.ciphers.base import ( + AEADCipherContext, + AEADDecryptionContext, + AEADEncryptionContext, + BlockCipherAlgorithm, + Cipher, + CipherAlgorithm, + CipherContext, +) + + +__all__ = [ + "Cipher", + "CipherAlgorithm", + "BlockCipherAlgorithm", + "CipherContext", + "AEADCipherContext", + "AEADDecryptionContext", + "AEADEncryptionContext", +] diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/aead.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/aead.py new file mode 100644 index 0000000000..c8c93955ce --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/aead.py @@ -0,0 +1,174 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import os + +from cryptography import exceptions, utils +from cryptography.hazmat.backends.openssl import aead +from cryptography.hazmat.backends.openssl.backend import backend + + +class ChaCha20Poly1305(object): + _MAX_SIZE = 2 ** 32 + + def __init__(self, key): + if not backend.aead_cipher_supported(self): + raise exceptions.UnsupportedAlgorithm( + "ChaCha20Poly1305 is not supported by this version of OpenSSL", + exceptions._Reasons.UNSUPPORTED_CIPHER, + ) + utils._check_byteslike("key", key) + + if len(key) != 32: + raise ValueError("ChaCha20Poly1305 key must be 32 bytes.") + + self._key = key + + @classmethod + def generate_key(cls): + return os.urandom(32) + + def encrypt(self, nonce, data, associated_data): + if associated_data is None: + associated_data = b"" + + if len(data) > self._MAX_SIZE or len(associated_data) > self._MAX_SIZE: + # This is OverflowError to match what cffi would raise + raise OverflowError( + "Data or associated data too long. Max 2**32 bytes" + ) + + self._check_params(nonce, data, associated_data) + return aead._encrypt(backend, self, nonce, data, associated_data, 16) + + def decrypt(self, nonce, data, associated_data): + if associated_data is None: + associated_data = b"" + + self._check_params(nonce, data, associated_data) + return aead._decrypt(backend, self, nonce, data, associated_data, 16) + + def _check_params(self, nonce, data, associated_data): + utils._check_byteslike("nonce", nonce) + utils._check_bytes("data", data) + utils._check_bytes("associated_data", associated_data) + if len(nonce) != 12: + raise ValueError("Nonce must be 12 bytes") + + +class AESCCM(object): + _MAX_SIZE = 2 ** 32 + + def __init__(self, key, tag_length=16): + utils._check_byteslike("key", key) + if len(key) not in (16, 24, 32): + raise ValueError("AESCCM key must be 128, 192, or 256 bits.") + + self._key = key + if not isinstance(tag_length, int): + raise TypeError("tag_length must be an integer") + + if tag_length not in (4, 6, 8, 10, 12, 14, 16): + raise ValueError("Invalid tag_length") + + self._tag_length = tag_length + + @classmethod + def generate_key(cls, bit_length): + if not isinstance(bit_length, int): + raise TypeError("bit_length must be an integer") + + if bit_length not in (128, 192, 256): + raise ValueError("bit_length must be 128, 192, or 256") + + return os.urandom(bit_length // 8) + + def encrypt(self, nonce, data, associated_data): + if associated_data is None: + associated_data = b"" + + if len(data) > self._MAX_SIZE or len(associated_data) > self._MAX_SIZE: + # This is OverflowError to match what cffi would raise + raise OverflowError( + "Data or associated data too long. Max 2**32 bytes" + ) + + self._check_params(nonce, data, associated_data) + self._validate_lengths(nonce, len(data)) + return aead._encrypt( + backend, self, nonce, data, associated_data, self._tag_length + ) + + def decrypt(self, nonce, data, associated_data): + if associated_data is None: + associated_data = b"" + + self._check_params(nonce, data, associated_data) + return aead._decrypt( + backend, self, nonce, data, associated_data, self._tag_length + ) + + def _validate_lengths(self, nonce, data_len): + # For information about computing this, see + # https://tools.ietf.org/html/rfc3610#section-2.1 + l_val = 15 - len(nonce) + if 2 ** (8 * l_val) < data_len: + raise ValueError("Data too long for nonce") + + def _check_params(self, nonce, data, associated_data): + utils._check_byteslike("nonce", nonce) + utils._check_bytes("data", data) + utils._check_bytes("associated_data", associated_data) + if not 7 <= len(nonce) <= 13: + raise ValueError("Nonce must be between 7 and 13 bytes") + + +class AESGCM(object): + _MAX_SIZE = 2 ** 32 + + def __init__(self, key): + utils._check_byteslike("key", key) + if len(key) not in (16, 24, 32): + raise ValueError("AESGCM key must be 128, 192, or 256 bits.") + + self._key = key + + @classmethod + def generate_key(cls, bit_length): + if not isinstance(bit_length, int): + raise TypeError("bit_length must be an integer") + + if bit_length not in (128, 192, 256): + raise ValueError("bit_length must be 128, 192, or 256") + + return os.urandom(bit_length // 8) + + def encrypt(self, nonce, data, associated_data): + if associated_data is None: + associated_data = b"" + + if len(data) > self._MAX_SIZE or len(associated_data) > self._MAX_SIZE: + # This is OverflowError to match what cffi would raise + raise OverflowError( + "Data or associated data too long. Max 2**32 bytes" + ) + + self._check_params(nonce, data, associated_data) + return aead._encrypt(backend, self, nonce, data, associated_data, 16) + + def decrypt(self, nonce, data, associated_data): + if associated_data is None: + associated_data = b"" + + self._check_params(nonce, data, associated_data) + return aead._decrypt(backend, self, nonce, data, associated_data, 16) + + def _check_params(self, nonce, data, associated_data): + utils._check_byteslike("nonce", nonce) + utils._check_bytes("data", data) + utils._check_bytes("associated_data", associated_data) + if len(nonce) < 8 or len(nonce) > 128: + raise ValueError("Nonce must be between 8 and 128 bytes") diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/algorithms.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/algorithms.py new file mode 100644 index 0000000000..8072cedd17 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/algorithms.py @@ -0,0 +1,170 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.hazmat.primitives.ciphers import ( + BlockCipherAlgorithm, + CipherAlgorithm, +) +from cryptography.hazmat.primitives.ciphers.modes import ModeWithNonce + + +def _verify_key_size(algorithm, key): + # Verify that the key is instance of bytes + utils._check_byteslike("key", key) + + # Verify that the key size matches the expected key size + if len(key) * 8 not in algorithm.key_sizes: + raise ValueError( + "Invalid key size ({}) for {}.".format( + len(key) * 8, algorithm.name + ) + ) + return key + + +@utils.register_interface(BlockCipherAlgorithm) +@utils.register_interface(CipherAlgorithm) +class AES(object): + name = "AES" + block_size = 128 + # 512 added to support AES-256-XTS, which uses 512-bit keys + key_sizes = frozenset([128, 192, 256, 512]) + + def __init__(self, key): + self.key = _verify_key_size(self, key) + + @property + def key_size(self): + return len(self.key) * 8 + + +@utils.register_interface(BlockCipherAlgorithm) +@utils.register_interface(CipherAlgorithm) +class Camellia(object): + name = "camellia" + block_size = 128 + key_sizes = frozenset([128, 192, 256]) + + def __init__(self, key): + self.key = _verify_key_size(self, key) + + @property + def key_size(self): + return len(self.key) * 8 + + +@utils.register_interface(BlockCipherAlgorithm) +@utils.register_interface(CipherAlgorithm) +class TripleDES(object): + name = "3DES" + block_size = 64 + key_sizes = frozenset([64, 128, 192]) + + def __init__(self, key): + if len(key) == 8: + key += key + key + elif len(key) == 16: + key += key[:8] + self.key = _verify_key_size(self, key) + + @property + def key_size(self): + return len(self.key) * 8 + + +@utils.register_interface(BlockCipherAlgorithm) +@utils.register_interface(CipherAlgorithm) +class Blowfish(object): + name = "Blowfish" + block_size = 64 + key_sizes = frozenset(range(32, 449, 8)) + + def __init__(self, key): + self.key = _verify_key_size(self, key) + + @property + def key_size(self): + return len(self.key) * 8 + + +@utils.register_interface(BlockCipherAlgorithm) +@utils.register_interface(CipherAlgorithm) +class CAST5(object): + name = "CAST5" + block_size = 64 + key_sizes = frozenset(range(40, 129, 8)) + + def __init__(self, key): + self.key = _verify_key_size(self, key) + + @property + def key_size(self): + return len(self.key) * 8 + + +@utils.register_interface(CipherAlgorithm) +class ARC4(object): + name = "RC4" + key_sizes = frozenset([40, 56, 64, 80, 128, 160, 192, 256]) + + def __init__(self, key): + self.key = _verify_key_size(self, key) + + @property + def key_size(self): + return len(self.key) * 8 + + +@utils.register_interface(CipherAlgorithm) +class IDEA(object): + name = "IDEA" + block_size = 64 + key_sizes = frozenset([128]) + + def __init__(self, key): + self.key = _verify_key_size(self, key) + + @property + def key_size(self): + return len(self.key) * 8 + + +@utils.register_interface(BlockCipherAlgorithm) +@utils.register_interface(CipherAlgorithm) +class SEED(object): + name = "SEED" + block_size = 128 + key_sizes = frozenset([128]) + + def __init__(self, key): + self.key = _verify_key_size(self, key) + + @property + def key_size(self): + return len(self.key) * 8 + + +@utils.register_interface(CipherAlgorithm) +@utils.register_interface(ModeWithNonce) +class ChaCha20(object): + name = "ChaCha20" + key_sizes = frozenset([256]) + + def __init__(self, key, nonce): + self.key = _verify_key_size(self, key) + utils._check_byteslike("nonce", nonce) + + if len(nonce) != 16: + raise ValueError("nonce must be 128-bits (16 bytes)") + + self._nonce = nonce + + nonce = utils.read_only_property("_nonce") + + @property + def key_size(self): + return len(self.key) * 8 diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/base.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/base.py new file mode 100644 index 0000000000..dae425a299 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/base.py @@ -0,0 +1,241 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + +from cryptography import utils +from cryptography.exceptions import ( + AlreadyFinalized, + AlreadyUpdated, + NotYetFinalized, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import CipherBackend +from cryptography.hazmat.primitives.ciphers import modes + + +@six.add_metaclass(abc.ABCMeta) +class CipherAlgorithm(object): + @abc.abstractproperty + def name(self): + """ + A string naming this mode (e.g. "AES", "Camellia"). + """ + + @abc.abstractproperty + def key_size(self): + """ + The size of the key being used as an integer in bits (e.g. 128, 256). + """ + + +@six.add_metaclass(abc.ABCMeta) +class BlockCipherAlgorithm(object): + @abc.abstractproperty + def block_size(self): + """ + The size of a block as an integer in bits (e.g. 64, 128). + """ + + +@six.add_metaclass(abc.ABCMeta) +class CipherContext(object): + @abc.abstractmethod + def update(self, data): + """ + Processes the provided bytes through the cipher and returns the results + as bytes. + """ + + @abc.abstractmethod + def update_into(self, data, buf): + """ + Processes the provided bytes and writes the resulting data into the + provided buffer. Returns the number of bytes written. + """ + + @abc.abstractmethod + def finalize(self): + """ + Returns the results of processing the final block as bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class AEADCipherContext(object): + @abc.abstractmethod + def authenticate_additional_data(self, data): + """ + Authenticates the provided bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class AEADDecryptionContext(object): + @abc.abstractmethod + def finalize_with_tag(self, tag): + """ + Returns the results of processing the final block as bytes and allows + delayed passing of the authentication tag. + """ + + +@six.add_metaclass(abc.ABCMeta) +class AEADEncryptionContext(object): + @abc.abstractproperty + def tag(self): + """ + Returns tag bytes. This is only available after encryption is + finalized. + """ + + +class Cipher(object): + def __init__(self, algorithm, mode, backend=None): + backend = _get_backend(backend) + if not isinstance(backend, CipherBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement CipherBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + if not isinstance(algorithm, CipherAlgorithm): + raise TypeError("Expected interface of CipherAlgorithm.") + + if mode is not None: + mode.validate_for_algorithm(algorithm) + + self.algorithm = algorithm + self.mode = mode + self._backend = backend + + def encryptor(self): + if isinstance(self.mode, modes.ModeWithAuthenticationTag): + if self.mode.tag is not None: + raise ValueError( + "Authentication tag must be None when encrypting." + ) + ctx = self._backend.create_symmetric_encryption_ctx( + self.algorithm, self.mode + ) + return self._wrap_ctx(ctx, encrypt=True) + + def decryptor(self): + ctx = self._backend.create_symmetric_decryption_ctx( + self.algorithm, self.mode + ) + return self._wrap_ctx(ctx, encrypt=False) + + def _wrap_ctx(self, ctx, encrypt): + if isinstance(self.mode, modes.ModeWithAuthenticationTag): + if encrypt: + return _AEADEncryptionContext(ctx) + else: + return _AEADCipherContext(ctx) + else: + return _CipherContext(ctx) + + +@utils.register_interface(CipherContext) +class _CipherContext(object): + def __init__(self, ctx): + self._ctx = ctx + + def update(self, data): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + return self._ctx.update(data) + + def update_into(self, data, buf): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + return self._ctx.update_into(data, buf) + + def finalize(self): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + data = self._ctx.finalize() + self._ctx = None + return data + + +@utils.register_interface(AEADCipherContext) +@utils.register_interface(CipherContext) +@utils.register_interface(AEADDecryptionContext) +class _AEADCipherContext(object): + def __init__(self, ctx): + self._ctx = ctx + self._bytes_processed = 0 + self._aad_bytes_processed = 0 + self._tag = None + self._updated = False + + def _check_limit(self, data_size): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + self._updated = True + self._bytes_processed += data_size + if self._bytes_processed > self._ctx._mode._MAX_ENCRYPTED_BYTES: + raise ValueError( + "{} has a maximum encrypted byte limit of {}".format( + self._ctx._mode.name, self._ctx._mode._MAX_ENCRYPTED_BYTES + ) + ) + + def update(self, data): + self._check_limit(len(data)) + return self._ctx.update(data) + + def update_into(self, data, buf): + self._check_limit(len(data)) + return self._ctx.update_into(data, buf) + + def finalize(self): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + data = self._ctx.finalize() + self._tag = self._ctx.tag + self._ctx = None + return data + + def finalize_with_tag(self, tag): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + data = self._ctx.finalize_with_tag(tag) + self._tag = self._ctx.tag + self._ctx = None + return data + + def authenticate_additional_data(self, data): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + if self._updated: + raise AlreadyUpdated("Update has been called on this context.") + + self._aad_bytes_processed += len(data) + if self._aad_bytes_processed > self._ctx._mode._MAX_AAD_BYTES: + raise ValueError( + "{} has a maximum AAD byte limit of {}".format( + self._ctx._mode.name, self._ctx._mode._MAX_AAD_BYTES + ) + ) + + self._ctx.authenticate_additional_data(data) + + +@utils.register_interface(AEADEncryptionContext) +class _AEADEncryptionContext(_AEADCipherContext): + @property + def tag(self): + if self._ctx is not None: + raise NotYetFinalized( + "You must finalize encryption before " "getting the tag." + ) + return self._tag diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/modes.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/modes.py new file mode 100644 index 0000000000..0ba0f2b5a1 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/ciphers/modes.py @@ -0,0 +1,225 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + +from cryptography import utils + + +@six.add_metaclass(abc.ABCMeta) +class Mode(object): + @abc.abstractproperty + def name(self): + """ + A string naming this mode (e.g. "ECB", "CBC"). + """ + + @abc.abstractmethod + def validate_for_algorithm(self, algorithm): + """ + Checks that all the necessary invariants of this (mode, algorithm) + combination are met. + """ + + +@six.add_metaclass(abc.ABCMeta) +class ModeWithInitializationVector(object): + @abc.abstractproperty + def initialization_vector(self): + """ + The value of the initialization vector for this mode as bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class ModeWithTweak(object): + @abc.abstractproperty + def tweak(self): + """ + The value of the tweak for this mode as bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class ModeWithNonce(object): + @abc.abstractproperty + def nonce(self): + """ + The value of the nonce for this mode as bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class ModeWithAuthenticationTag(object): + @abc.abstractproperty + def tag(self): + """ + The value of the tag supplied to the constructor of this mode. + """ + + +def _check_aes_key_length(self, algorithm): + if algorithm.key_size > 256 and algorithm.name == "AES": + raise ValueError( + "Only 128, 192, and 256 bit keys are allowed for this AES mode" + ) + + +def _check_iv_length(self, algorithm): + if len(self.initialization_vector) * 8 != algorithm.block_size: + raise ValueError( + "Invalid IV size ({}) for {}.".format( + len(self.initialization_vector), self.name + ) + ) + + +def _check_iv_and_key_length(self, algorithm): + _check_aes_key_length(self, algorithm) + _check_iv_length(self, algorithm) + + +@utils.register_interface(Mode) +@utils.register_interface(ModeWithInitializationVector) +class CBC(object): + name = "CBC" + + def __init__(self, initialization_vector): + utils._check_byteslike("initialization_vector", initialization_vector) + self._initialization_vector = initialization_vector + + initialization_vector = utils.read_only_property("_initialization_vector") + validate_for_algorithm = _check_iv_and_key_length + + +@utils.register_interface(Mode) +@utils.register_interface(ModeWithTweak) +class XTS(object): + name = "XTS" + + def __init__(self, tweak): + utils._check_byteslike("tweak", tweak) + + if len(tweak) != 16: + raise ValueError("tweak must be 128-bits (16 bytes)") + + self._tweak = tweak + + tweak = utils.read_only_property("_tweak") + + def validate_for_algorithm(self, algorithm): + if algorithm.key_size not in (256, 512): + raise ValueError( + "The XTS specification requires a 256-bit key for AES-128-XTS" + " and 512-bit key for AES-256-XTS" + ) + + +@utils.register_interface(Mode) +class ECB(object): + name = "ECB" + + validate_for_algorithm = _check_aes_key_length + + +@utils.register_interface(Mode) +@utils.register_interface(ModeWithInitializationVector) +class OFB(object): + name = "OFB" + + def __init__(self, initialization_vector): + utils._check_byteslike("initialization_vector", initialization_vector) + self._initialization_vector = initialization_vector + + initialization_vector = utils.read_only_property("_initialization_vector") + validate_for_algorithm = _check_iv_and_key_length + + +@utils.register_interface(Mode) +@utils.register_interface(ModeWithInitializationVector) +class CFB(object): + name = "CFB" + + def __init__(self, initialization_vector): + utils._check_byteslike("initialization_vector", initialization_vector) + self._initialization_vector = initialization_vector + + initialization_vector = utils.read_only_property("_initialization_vector") + validate_for_algorithm = _check_iv_and_key_length + + +@utils.register_interface(Mode) +@utils.register_interface(ModeWithInitializationVector) +class CFB8(object): + name = "CFB8" + + def __init__(self, initialization_vector): + utils._check_byteslike("initialization_vector", initialization_vector) + self._initialization_vector = initialization_vector + + initialization_vector = utils.read_only_property("_initialization_vector") + validate_for_algorithm = _check_iv_and_key_length + + +@utils.register_interface(Mode) +@utils.register_interface(ModeWithNonce) +class CTR(object): + name = "CTR" + + def __init__(self, nonce): + utils._check_byteslike("nonce", nonce) + self._nonce = nonce + + nonce = utils.read_only_property("_nonce") + + def validate_for_algorithm(self, algorithm): + _check_aes_key_length(self, algorithm) + if len(self.nonce) * 8 != algorithm.block_size: + raise ValueError( + "Invalid nonce size ({}) for {}.".format( + len(self.nonce), self.name + ) + ) + + +@utils.register_interface(Mode) +@utils.register_interface(ModeWithInitializationVector) +@utils.register_interface(ModeWithAuthenticationTag) +class GCM(object): + name = "GCM" + _MAX_ENCRYPTED_BYTES = (2 ** 39 - 256) // 8 + _MAX_AAD_BYTES = (2 ** 64) // 8 + + def __init__(self, initialization_vector, tag=None, min_tag_length=16): + # OpenSSL 3.0.0 constrains GCM IVs to [64, 1024] bits inclusive + # This is a sane limit anyway so we'll enforce it here. + utils._check_byteslike("initialization_vector", initialization_vector) + if len(initialization_vector) < 8 or len(initialization_vector) > 128: + raise ValueError( + "initialization_vector must be between 8 and 128 bytes (64 " + "and 1024 bits)." + ) + self._initialization_vector = initialization_vector + if tag is not None: + utils._check_bytes("tag", tag) + if min_tag_length < 4: + raise ValueError("min_tag_length must be >= 4") + if len(tag) < min_tag_length: + raise ValueError( + "Authentication tag must be {} bytes or longer.".format( + min_tag_length + ) + ) + self._tag = tag + self._min_tag_length = min_tag_length + + tag = utils.read_only_property("_tag") + initialization_vector = utils.read_only_property("_initialization_vector") + + def validate_for_algorithm(self, algorithm): + _check_aes_key_length(self, algorithm) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/cmac.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/cmac.py new file mode 100644 index 0000000000..bf962c9069 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/cmac.py @@ -0,0 +1,64 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.exceptions import ( + AlreadyFinalized, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import CMACBackend +from cryptography.hazmat.primitives import ciphers + + +class CMAC(object): + def __init__(self, algorithm, backend=None, ctx=None): + backend = _get_backend(backend) + if not isinstance(backend, CMACBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement CMACBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + if not isinstance(algorithm, ciphers.BlockCipherAlgorithm): + raise TypeError("Expected instance of BlockCipherAlgorithm.") + self._algorithm = algorithm + + self._backend = backend + if ctx is None: + self._ctx = self._backend.create_cmac_ctx(self._algorithm) + else: + self._ctx = ctx + + def update(self, data): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + + utils._check_bytes("data", data) + self._ctx.update(data) + + def finalize(self): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + digest = self._ctx.finalize() + self._ctx = None + return digest + + def verify(self, signature): + utils._check_bytes("signature", signature) + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + + ctx, self._ctx = self._ctx, None + ctx.verify(signature) + + def copy(self): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + return CMAC( + self._algorithm, backend=self._backend, ctx=self._ctx.copy() + ) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/constant_time.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/constant_time.py new file mode 100644 index 0000000000..7f41b9efa5 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/constant_time.py @@ -0,0 +1,14 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import hmac + + +def bytes_eq(a, b): + if not isinstance(a, bytes) or not isinstance(b, bytes): + raise TypeError("a and b must be bytes.") + + return hmac.compare_digest(a, b) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/hashes.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/hashes.py new file mode 100644 index 0000000000..18e2bab363 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/hashes.py @@ -0,0 +1,259 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + +from cryptography import utils +from cryptography.exceptions import ( + AlreadyFinalized, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import HashBackend + + +@six.add_metaclass(abc.ABCMeta) +class HashAlgorithm(object): + @abc.abstractproperty + def name(self): + """ + A string naming this algorithm (e.g. "sha256", "md5"). + """ + + @abc.abstractproperty + def digest_size(self): + """ + The size of the resulting digest in bytes. + """ + + +@six.add_metaclass(abc.ABCMeta) +class HashContext(object): + @abc.abstractproperty + def algorithm(self): + """ + A HashAlgorithm that will be used by this context. + """ + + @abc.abstractmethod + def update(self, data): + """ + Processes the provided bytes through the hash. + """ + + @abc.abstractmethod + def finalize(self): + """ + Finalizes the hash context and returns the hash digest as bytes. + """ + + @abc.abstractmethod + def copy(self): + """ + Return a HashContext that is a copy of the current context. + """ + + +@six.add_metaclass(abc.ABCMeta) +class ExtendableOutputFunction(object): + """ + An interface for extendable output functions. + """ + + +@utils.register_interface(HashContext) +class Hash(object): + def __init__(self, algorithm, backend=None, ctx=None): + backend = _get_backend(backend) + if not isinstance(backend, HashBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement HashBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + if not isinstance(algorithm, HashAlgorithm): + raise TypeError("Expected instance of hashes.HashAlgorithm.") + self._algorithm = algorithm + + self._backend = backend + + if ctx is None: + self._ctx = self._backend.create_hash_ctx(self.algorithm) + else: + self._ctx = ctx + + algorithm = utils.read_only_property("_algorithm") + + def update(self, data): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + utils._check_byteslike("data", data) + self._ctx.update(data) + + def copy(self): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + return Hash( + self.algorithm, backend=self._backend, ctx=self._ctx.copy() + ) + + def finalize(self): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + digest = self._ctx.finalize() + self._ctx = None + return digest + + +@utils.register_interface(HashAlgorithm) +class SHA1(object): + name = "sha1" + digest_size = 20 + block_size = 64 + + +@utils.register_interface(HashAlgorithm) +class SHA512_224(object): # noqa: N801 + name = "sha512-224" + digest_size = 28 + block_size = 128 + + +@utils.register_interface(HashAlgorithm) +class SHA512_256(object): # noqa: N801 + name = "sha512-256" + digest_size = 32 + block_size = 128 + + +@utils.register_interface(HashAlgorithm) +class SHA224(object): + name = "sha224" + digest_size = 28 + block_size = 64 + + +@utils.register_interface(HashAlgorithm) +class SHA256(object): + name = "sha256" + digest_size = 32 + block_size = 64 + + +@utils.register_interface(HashAlgorithm) +class SHA384(object): + name = "sha384" + digest_size = 48 + block_size = 128 + + +@utils.register_interface(HashAlgorithm) +class SHA512(object): + name = "sha512" + digest_size = 64 + block_size = 128 + + +@utils.register_interface(HashAlgorithm) +class SHA3_224(object): # noqa: N801 + name = "sha3-224" + digest_size = 28 + + +@utils.register_interface(HashAlgorithm) +class SHA3_256(object): # noqa: N801 + name = "sha3-256" + digest_size = 32 + + +@utils.register_interface(HashAlgorithm) +class SHA3_384(object): # noqa: N801 + name = "sha3-384" + digest_size = 48 + + +@utils.register_interface(HashAlgorithm) +class SHA3_512(object): # noqa: N801 + name = "sha3-512" + digest_size = 64 + + +@utils.register_interface(HashAlgorithm) +@utils.register_interface(ExtendableOutputFunction) +class SHAKE128(object): + name = "shake128" + + def __init__(self, digest_size): + if not isinstance(digest_size, six.integer_types): + raise TypeError("digest_size must be an integer") + + if digest_size < 1: + raise ValueError("digest_size must be a positive integer") + + self._digest_size = digest_size + + digest_size = utils.read_only_property("_digest_size") + + +@utils.register_interface(HashAlgorithm) +@utils.register_interface(ExtendableOutputFunction) +class SHAKE256(object): + name = "shake256" + + def __init__(self, digest_size): + if not isinstance(digest_size, six.integer_types): + raise TypeError("digest_size must be an integer") + + if digest_size < 1: + raise ValueError("digest_size must be a positive integer") + + self._digest_size = digest_size + + digest_size = utils.read_only_property("_digest_size") + + +@utils.register_interface(HashAlgorithm) +class MD5(object): + name = "md5" + digest_size = 16 + block_size = 64 + + +@utils.register_interface(HashAlgorithm) +class BLAKE2b(object): + name = "blake2b" + _max_digest_size = 64 + _min_digest_size = 1 + block_size = 128 + + def __init__(self, digest_size): + + if digest_size != 64: + raise ValueError("Digest size must be 64") + + self._digest_size = digest_size + + digest_size = utils.read_only_property("_digest_size") + + +@utils.register_interface(HashAlgorithm) +class BLAKE2s(object): + name = "blake2s" + block_size = 64 + _max_digest_size = 32 + _min_digest_size = 1 + + def __init__(self, digest_size): + + if digest_size != 32: + raise ValueError("Digest size must be 32") + + self._digest_size = digest_size + + digest_size = utils.read_only_property("_digest_size") diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/hmac.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/hmac.py new file mode 100644 index 0000000000..8c421dc68d --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/hmac.py @@ -0,0 +1,70 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.exceptions import ( + AlreadyFinalized, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import HMACBackend +from cryptography.hazmat.primitives import hashes + + +@utils.register_interface(hashes.HashContext) +class HMAC(object): + def __init__(self, key, algorithm, backend=None, ctx=None): + backend = _get_backend(backend) + if not isinstance(backend, HMACBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement HMACBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + if not isinstance(algorithm, hashes.HashAlgorithm): + raise TypeError("Expected instance of hashes.HashAlgorithm.") + self._algorithm = algorithm + + self._backend = backend + self._key = key + if ctx is None: + self._ctx = self._backend.create_hmac_ctx(key, self.algorithm) + else: + self._ctx = ctx + + algorithm = utils.read_only_property("_algorithm") + + def update(self, data): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + utils._check_byteslike("data", data) + self._ctx.update(data) + + def copy(self): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + return HMAC( + self._key, + self.algorithm, + backend=self._backend, + ctx=self._ctx.copy(), + ) + + def finalize(self): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + digest = self._ctx.finalize() + self._ctx = None + return digest + + def verify(self, signature): + utils._check_bytes("signature", signature) + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + + ctx, self._ctx = self._ctx, None + ctx.verify(signature) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/__init__.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/__init__.py new file mode 100644 index 0000000000..2d0724e5da --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/__init__.py @@ -0,0 +1,26 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + + +@six.add_metaclass(abc.ABCMeta) +class KeyDerivationFunction(object): + @abc.abstractmethod + def derive(self, key_material): + """ + Deterministically generates and returns a new key based on the existing + key material. + """ + + @abc.abstractmethod + def verify(self, key_material, expected_key): + """ + Checks whether the key generated by the key material matches the + expected derived key. Raises an exception if they do not match. + """ diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/concatkdf.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/concatkdf.py new file mode 100644 index 0000000000..7cc0324fc4 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/concatkdf.py @@ -0,0 +1,131 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import struct + +from cryptography import utils +from cryptography.exceptions import ( + AlreadyFinalized, + InvalidKey, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import HMACBackend +from cryptography.hazmat.backends.interfaces import HashBackend +from cryptography.hazmat.primitives import constant_time, hashes, hmac +from cryptography.hazmat.primitives.kdf import KeyDerivationFunction + + +def _int_to_u32be(n): + return struct.pack(">I", n) + + +def _common_args_checks(algorithm, length, otherinfo): + max_length = algorithm.digest_size * (2 ** 32 - 1) + if length > max_length: + raise ValueError( + "Can not derive keys larger than {} bits.".format(max_length) + ) + if otherinfo is not None: + utils._check_bytes("otherinfo", otherinfo) + + +def _concatkdf_derive(key_material, length, auxfn, otherinfo): + utils._check_byteslike("key_material", key_material) + output = [b""] + outlen = 0 + counter = 1 + + while length > outlen: + h = auxfn() + h.update(_int_to_u32be(counter)) + h.update(key_material) + h.update(otherinfo) + output.append(h.finalize()) + outlen += len(output[-1]) + counter += 1 + + return b"".join(output)[:length] + + +@utils.register_interface(KeyDerivationFunction) +class ConcatKDFHash(object): + def __init__(self, algorithm, length, otherinfo, backend=None): + backend = _get_backend(backend) + + _common_args_checks(algorithm, length, otherinfo) + self._algorithm = algorithm + self._length = length + self._otherinfo = otherinfo + if self._otherinfo is None: + self._otherinfo = b"" + + if not isinstance(backend, HashBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement HashBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + self._backend = backend + self._used = False + + def _hash(self): + return hashes.Hash(self._algorithm, self._backend) + + def derive(self, key_material): + if self._used: + raise AlreadyFinalized + self._used = True + return _concatkdf_derive( + key_material, self._length, self._hash, self._otherinfo + ) + + def verify(self, key_material, expected_key): + if not constant_time.bytes_eq(self.derive(key_material), expected_key): + raise InvalidKey + + +@utils.register_interface(KeyDerivationFunction) +class ConcatKDFHMAC(object): + def __init__(self, algorithm, length, salt, otherinfo, backend=None): + backend = _get_backend(backend) + + _common_args_checks(algorithm, length, otherinfo) + self._algorithm = algorithm + self._length = length + self._otherinfo = otherinfo + if self._otherinfo is None: + self._otherinfo = b"" + + if salt is None: + salt = b"\x00" * algorithm.block_size + else: + utils._check_bytes("salt", salt) + + self._salt = salt + + if not isinstance(backend, HMACBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement HMACBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + self._backend = backend + self._used = False + + def _hmac(self): + return hmac.HMAC(self._salt, self._algorithm, self._backend) + + def derive(self, key_material): + if self._used: + raise AlreadyFinalized + self._used = True + return _concatkdf_derive( + key_material, self._length, self._hmac, self._otherinfo + ) + + def verify(self, key_material, expected_key): + if not constant_time.bytes_eq(self.derive(key_material), expected_key): + raise InvalidKey diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/hkdf.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/hkdf.py new file mode 100644 index 0000000000..9bb6bc2132 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/hkdf.py @@ -0,0 +1,115 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import six + +from cryptography import utils +from cryptography.exceptions import ( + AlreadyFinalized, + InvalidKey, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import HMACBackend +from cryptography.hazmat.primitives import constant_time, hmac +from cryptography.hazmat.primitives.kdf import KeyDerivationFunction + + +@utils.register_interface(KeyDerivationFunction) +class HKDF(object): + def __init__(self, algorithm, length, salt, info, backend=None): + backend = _get_backend(backend) + if not isinstance(backend, HMACBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement HMACBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + self._algorithm = algorithm + + if salt is None: + salt = b"\x00" * self._algorithm.digest_size + else: + utils._check_bytes("salt", salt) + + self._salt = salt + + self._backend = backend + + self._hkdf_expand = HKDFExpand(self._algorithm, length, info, backend) + + def _extract(self, key_material): + h = hmac.HMAC(self._salt, self._algorithm, backend=self._backend) + h.update(key_material) + return h.finalize() + + def derive(self, key_material): + utils._check_byteslike("key_material", key_material) + return self._hkdf_expand.derive(self._extract(key_material)) + + def verify(self, key_material, expected_key): + if not constant_time.bytes_eq(self.derive(key_material), expected_key): + raise InvalidKey + + +@utils.register_interface(KeyDerivationFunction) +class HKDFExpand(object): + def __init__(self, algorithm, length, info, backend=None): + backend = _get_backend(backend) + if not isinstance(backend, HMACBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement HMACBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + self._algorithm = algorithm + + self._backend = backend + + max_length = 255 * algorithm.digest_size + + if length > max_length: + raise ValueError( + "Can not derive keys larger than {} octets.".format(max_length) + ) + + self._length = length + + if info is None: + info = b"" + else: + utils._check_bytes("info", info) + + self._info = info + + self._used = False + + def _expand(self, key_material): + output = [b""] + counter = 1 + + while self._algorithm.digest_size * (len(output) - 1) < self._length: + h = hmac.HMAC(key_material, self._algorithm, backend=self._backend) + h.update(output[-1]) + h.update(self._info) + h.update(six.int2byte(counter)) + output.append(h.finalize()) + counter += 1 + + return b"".join(output)[: self._length] + + def derive(self, key_material): + utils._check_byteslike("key_material", key_material) + if self._used: + raise AlreadyFinalized + + self._used = True + return self._expand(key_material) + + def verify(self, key_material, expected_key): + if not constant_time.bytes_eq(self.derive(key_material), expected_key): + raise InvalidKey diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/kbkdf.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/kbkdf.py new file mode 100644 index 0000000000..864337001c --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/kbkdf.py @@ -0,0 +1,162 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from enum import Enum + +from six.moves import range + +from cryptography import utils +from cryptography.exceptions import ( + AlreadyFinalized, + InvalidKey, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import HMACBackend +from cryptography.hazmat.primitives import constant_time, hashes, hmac +from cryptography.hazmat.primitives.kdf import KeyDerivationFunction + + +class Mode(Enum): + CounterMode = "ctr" + + +class CounterLocation(Enum): + BeforeFixed = "before_fixed" + AfterFixed = "after_fixed" + + +@utils.register_interface(KeyDerivationFunction) +class KBKDFHMAC(object): + def __init__( + self, + algorithm, + mode, + length, + rlen, + llen, + location, + label, + context, + fixed, + backend=None, + ): + backend = _get_backend(backend) + if not isinstance(backend, HMACBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement HMACBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + if not isinstance(algorithm, hashes.HashAlgorithm): + raise UnsupportedAlgorithm( + "Algorithm supplied is not a supported hash algorithm.", + _Reasons.UNSUPPORTED_HASH, + ) + + if not backend.hmac_supported(algorithm): + raise UnsupportedAlgorithm( + "Algorithm supplied is not a supported hmac algorithm.", + _Reasons.UNSUPPORTED_HASH, + ) + + if not isinstance(mode, Mode): + raise TypeError("mode must be of type Mode") + + if not isinstance(location, CounterLocation): + raise TypeError("location must be of type CounterLocation") + + if (label or context) and fixed: + raise ValueError( + "When supplying fixed data, " "label and context are ignored." + ) + + if rlen is None or not self._valid_byte_length(rlen): + raise ValueError("rlen must be between 1 and 4") + + if llen is None and fixed is None: + raise ValueError("Please specify an llen") + + if llen is not None and not isinstance(llen, int): + raise TypeError("llen must be an integer") + + if label is None: + label = b"" + + if context is None: + context = b"" + + utils._check_bytes("label", label) + utils._check_bytes("context", context) + self._algorithm = algorithm + self._mode = mode + self._length = length + self._rlen = rlen + self._llen = llen + self._location = location + self._label = label + self._context = context + self._backend = backend + self._used = False + self._fixed_data = fixed + + def _valid_byte_length(self, value): + if not isinstance(value, int): + raise TypeError("value must be of type int") + + value_bin = utils.int_to_bytes(1, value) + if not 1 <= len(value_bin) <= 4: + return False + return True + + def derive(self, key_material): + if self._used: + raise AlreadyFinalized + + utils._check_byteslike("key_material", key_material) + self._used = True + + # inverse floor division (equivalent to ceiling) + rounds = -(-self._length // self._algorithm.digest_size) + + output = [b""] + + # For counter mode, the number of iterations shall not be + # larger than 2^r-1, where r <= 32 is the binary length of the counter + # This ensures that the counter values used as an input to the + # PRF will not repeat during a particular call to the KDF function. + r_bin = utils.int_to_bytes(1, self._rlen) + if rounds > pow(2, len(r_bin) * 8) - 1: + raise ValueError("There are too many iterations.") + + for i in range(1, rounds + 1): + h = hmac.HMAC(key_material, self._algorithm, backend=self._backend) + + counter = utils.int_to_bytes(i, self._rlen) + if self._location == CounterLocation.BeforeFixed: + h.update(counter) + + h.update(self._generate_fixed_input()) + + if self._location == CounterLocation.AfterFixed: + h.update(counter) + + output.append(h.finalize()) + + return b"".join(output)[: self._length] + + def _generate_fixed_input(self): + if self._fixed_data and isinstance(self._fixed_data, bytes): + return self._fixed_data + + l_val = utils.int_to_bytes(self._length * 8, self._llen) + + return b"".join([self._label, b"\x00", self._context, l_val]) + + def verify(self, key_material, expected_key): + if not constant_time.bytes_eq(self.derive(key_material), expected_key): + raise InvalidKey diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/pbkdf2.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/pbkdf2.py new file mode 100644 index 0000000000..5b67d48bba --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/pbkdf2.py @@ -0,0 +1,62 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import utils +from cryptography.exceptions import ( + AlreadyFinalized, + InvalidKey, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import PBKDF2HMACBackend +from cryptography.hazmat.primitives import constant_time +from cryptography.hazmat.primitives.kdf import KeyDerivationFunction + + +@utils.register_interface(KeyDerivationFunction) +class PBKDF2HMAC(object): + def __init__(self, algorithm, length, salt, iterations, backend=None): + backend = _get_backend(backend) + if not isinstance(backend, PBKDF2HMACBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement PBKDF2HMACBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + if not backend.pbkdf2_hmac_supported(algorithm): + raise UnsupportedAlgorithm( + "{} is not supported for PBKDF2 by this backend.".format( + algorithm.name + ), + _Reasons.UNSUPPORTED_HASH, + ) + self._used = False + self._algorithm = algorithm + self._length = length + utils._check_bytes("salt", salt) + self._salt = salt + self._iterations = iterations + self._backend = backend + + def derive(self, key_material): + if self._used: + raise AlreadyFinalized("PBKDF2 instances can only be used once.") + self._used = True + + utils._check_byteslike("key_material", key_material) + return self._backend.derive_pbkdf2_hmac( + self._algorithm, + self._length, + self._salt, + self._iterations, + key_material, + ) + + def verify(self, key_material, expected_key): + derived_key = self.derive(key_material) + if not constant_time.bytes_eq(derived_key, expected_key): + raise InvalidKey("Keys do not match.") diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/scrypt.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/scrypt.py new file mode 100644 index 0000000000..f028646aa0 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/scrypt.py @@ -0,0 +1,68 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import sys + +from cryptography import utils +from cryptography.exceptions import ( + AlreadyFinalized, + InvalidKey, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import ScryptBackend +from cryptography.hazmat.primitives import constant_time +from cryptography.hazmat.primitives.kdf import KeyDerivationFunction + + +# This is used by the scrypt tests to skip tests that require more memory +# than the MEM_LIMIT +_MEM_LIMIT = sys.maxsize // 2 + + +@utils.register_interface(KeyDerivationFunction) +class Scrypt(object): + def __init__(self, salt, length, n, r, p, backend=None): + backend = _get_backend(backend) + if not isinstance(backend, ScryptBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement ScryptBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + self._length = length + utils._check_bytes("salt", salt) + if n < 2 or (n & (n - 1)) != 0: + raise ValueError("n must be greater than 1 and be a power of 2.") + + if r < 1: + raise ValueError("r must be greater than or equal to 1.") + + if p < 1: + raise ValueError("p must be greater than or equal to 1.") + + self._used = False + self._salt = salt + self._n = n + self._r = r + self._p = p + self._backend = backend + + def derive(self, key_material): + if self._used: + raise AlreadyFinalized("Scrypt instances can only be used once.") + self._used = True + + utils._check_byteslike("key_material", key_material) + return self._backend.derive_scrypt( + key_material, self._salt, self._length, self._n, self._r, self._p + ) + + def verify(self, key_material, expected_key): + derived_key = self.derive(key_material) + if not constant_time.bytes_eq(derived_key, expected_key): + raise InvalidKey("Keys do not match.") diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/x963kdf.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/x963kdf.py new file mode 100644 index 0000000000..1898d526a4 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/kdf/x963kdf.py @@ -0,0 +1,74 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import struct + +from cryptography import utils +from cryptography.exceptions import ( + AlreadyFinalized, + InvalidKey, + UnsupportedAlgorithm, + _Reasons, +) +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import HashBackend +from cryptography.hazmat.primitives import constant_time, hashes +from cryptography.hazmat.primitives.kdf import KeyDerivationFunction + + +def _int_to_u32be(n): + return struct.pack(">I", n) + + +@utils.register_interface(KeyDerivationFunction) +class X963KDF(object): + def __init__(self, algorithm, length, sharedinfo, backend=None): + backend = _get_backend(backend) + + max_len = algorithm.digest_size * (2 ** 32 - 1) + if length > max_len: + raise ValueError( + "Can not derive keys larger than {} bits.".format(max_len) + ) + if sharedinfo is not None: + utils._check_bytes("sharedinfo", sharedinfo) + + self._algorithm = algorithm + self._length = length + self._sharedinfo = sharedinfo + + if not isinstance(backend, HashBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement HashBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + self._backend = backend + self._used = False + + def derive(self, key_material): + if self._used: + raise AlreadyFinalized + self._used = True + utils._check_byteslike("key_material", key_material) + output = [b""] + outlen = 0 + counter = 1 + + while self._length > outlen: + h = hashes.Hash(self._algorithm, self._backend) + h.update(key_material) + h.update(_int_to_u32be(counter)) + if self._sharedinfo is not None: + h.update(self._sharedinfo) + output.append(h.finalize()) + outlen += len(output[-1]) + counter += 1 + + return b"".join(output)[: self._length] + + def verify(self, key_material, expected_key): + if not constant_time.bytes_eq(self.derive(key_material), expected_key): + raise InvalidKey diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/keywrap.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/keywrap.py new file mode 100644 index 0000000000..2439cafe6d --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/keywrap.py @@ -0,0 +1,161 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import struct + +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.primitives.ciphers import Cipher +from cryptography.hazmat.primitives.ciphers.algorithms import AES +from cryptography.hazmat.primitives.ciphers.modes import ECB +from cryptography.hazmat.primitives.constant_time import bytes_eq + + +def _wrap_core(wrapping_key, a, r, backend): + # RFC 3394 Key Wrap - 2.2.1 (index method) + encryptor = Cipher(AES(wrapping_key), ECB(), backend).encryptor() + n = len(r) + for j in range(6): + for i in range(n): + # every encryption operation is a discrete 16 byte chunk (because + # AES has a 128-bit block size) and since we're using ECB it is + # safe to reuse the encryptor for the entire operation + b = encryptor.update(a + r[i]) + # pack/unpack are safe as these are always 64-bit chunks + a = struct.pack( + ">Q", struct.unpack(">Q", b[:8])[0] ^ ((n * j) + i + 1) + ) + r[i] = b[-8:] + + assert encryptor.finalize() == b"" + + return a + b"".join(r) + + +def aes_key_wrap(wrapping_key, key_to_wrap, backend=None): + backend = _get_backend(backend) + if len(wrapping_key) not in [16, 24, 32]: + raise ValueError("The wrapping key must be a valid AES key length") + + if len(key_to_wrap) < 16: + raise ValueError("The key to wrap must be at least 16 bytes") + + if len(key_to_wrap) % 8 != 0: + raise ValueError("The key to wrap must be a multiple of 8 bytes") + + a = b"\xa6\xa6\xa6\xa6\xa6\xa6\xa6\xa6" + r = [key_to_wrap[i : i + 8] for i in range(0, len(key_to_wrap), 8)] + return _wrap_core(wrapping_key, a, r, backend) + + +def _unwrap_core(wrapping_key, a, r, backend): + # Implement RFC 3394 Key Unwrap - 2.2.2 (index method) + decryptor = Cipher(AES(wrapping_key), ECB(), backend).decryptor() + n = len(r) + for j in reversed(range(6)): + for i in reversed(range(n)): + # pack/unpack are safe as these are always 64-bit chunks + atr = ( + struct.pack( + ">Q", struct.unpack(">Q", a)[0] ^ ((n * j) + i + 1) + ) + + r[i] + ) + # every decryption operation is a discrete 16 byte chunk so + # it is safe to reuse the decryptor for the entire operation + b = decryptor.update(atr) + a = b[:8] + r[i] = b[-8:] + + assert decryptor.finalize() == b"" + return a, r + + +def aes_key_wrap_with_padding(wrapping_key, key_to_wrap, backend=None): + backend = _get_backend(backend) + if len(wrapping_key) not in [16, 24, 32]: + raise ValueError("The wrapping key must be a valid AES key length") + + aiv = b"\xA6\x59\x59\xA6" + struct.pack(">i", len(key_to_wrap)) + # pad the key to wrap if necessary + pad = (8 - (len(key_to_wrap) % 8)) % 8 + key_to_wrap = key_to_wrap + b"\x00" * pad + if len(key_to_wrap) == 8: + # RFC 5649 - 4.1 - exactly 8 octets after padding + encryptor = Cipher(AES(wrapping_key), ECB(), backend).encryptor() + b = encryptor.update(aiv + key_to_wrap) + assert encryptor.finalize() == b"" + return b + else: + r = [key_to_wrap[i : i + 8] for i in range(0, len(key_to_wrap), 8)] + return _wrap_core(wrapping_key, aiv, r, backend) + + +def aes_key_unwrap_with_padding(wrapping_key, wrapped_key, backend=None): + backend = _get_backend(backend) + if len(wrapped_key) < 16: + raise InvalidUnwrap("Must be at least 16 bytes") + + if len(wrapping_key) not in [16, 24, 32]: + raise ValueError("The wrapping key must be a valid AES key length") + + if len(wrapped_key) == 16: + # RFC 5649 - 4.2 - exactly two 64-bit blocks + decryptor = Cipher(AES(wrapping_key), ECB(), backend).decryptor() + b = decryptor.update(wrapped_key) + assert decryptor.finalize() == b"" + a = b[:8] + data = b[8:] + n = 1 + else: + r = [wrapped_key[i : i + 8] for i in range(0, len(wrapped_key), 8)] + encrypted_aiv = r.pop(0) + n = len(r) + a, r = _unwrap_core(wrapping_key, encrypted_aiv, r, backend) + data = b"".join(r) + + # 1) Check that MSB(32,A) = A65959A6. + # 2) Check that 8*(n-1) < LSB(32,A) <= 8*n. If so, let + # MLI = LSB(32,A). + # 3) Let b = (8*n)-MLI, and then check that the rightmost b octets of + # the output data are zero. + (mli,) = struct.unpack(">I", a[4:]) + b = (8 * n) - mli + if ( + not bytes_eq(a[:4], b"\xa6\x59\x59\xa6") + or not 8 * (n - 1) < mli <= 8 * n + or (b != 0 and not bytes_eq(data[-b:], b"\x00" * b)) + ): + raise InvalidUnwrap() + + if b == 0: + return data + else: + return data[:-b] + + +def aes_key_unwrap(wrapping_key, wrapped_key, backend=None): + backend = _get_backend(backend) + if len(wrapped_key) < 24: + raise InvalidUnwrap("Must be at least 24 bytes") + + if len(wrapped_key) % 8 != 0: + raise InvalidUnwrap("The wrapped key must be a multiple of 8 bytes") + + if len(wrapping_key) not in [16, 24, 32]: + raise ValueError("The wrapping key must be a valid AES key length") + + aiv = b"\xa6\xa6\xa6\xa6\xa6\xa6\xa6\xa6" + r = [wrapped_key[i : i + 8] for i in range(0, len(wrapped_key), 8)] + a = r.pop(0) + a, r = _unwrap_core(wrapping_key, a, r, backend) + if not bytes_eq(a, aiv): + raise InvalidUnwrap() + + return b"".join(r) + + +class InvalidUnwrap(Exception): + pass diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/padding.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/padding.py new file mode 100644 index 0000000000..98abffbc08 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/padding.py @@ -0,0 +1,214 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc + +import six + +from cryptography import utils +from cryptography.exceptions import AlreadyFinalized +from cryptography.hazmat.bindings._padding import lib + + +@six.add_metaclass(abc.ABCMeta) +class PaddingContext(object): + @abc.abstractmethod + def update(self, data): + """ + Pads the provided bytes and returns any available data as bytes. + """ + + @abc.abstractmethod + def finalize(self): + """ + Finalize the padding, returns bytes. + """ + + +def _byte_padding_check(block_size): + if not (0 <= block_size <= 2040): + raise ValueError("block_size must be in range(0, 2041).") + + if block_size % 8 != 0: + raise ValueError("block_size must be a multiple of 8.") + + +def _byte_padding_update(buffer_, data, block_size): + if buffer_ is None: + raise AlreadyFinalized("Context was already finalized.") + + utils._check_byteslike("data", data) + + # six.PY2: Only coerce non-bytes objects to avoid triggering bad behavior + # of future's newbytes type. Unconditionally call bytes() after Python 2 + # support is gone. + buffer_ += data if isinstance(data, bytes) else bytes(data) + + finished_blocks = len(buffer_) // (block_size // 8) + + result = buffer_[: finished_blocks * (block_size // 8)] + buffer_ = buffer_[finished_blocks * (block_size // 8) :] + + return buffer_, result + + +def _byte_padding_pad(buffer_, block_size, paddingfn): + if buffer_ is None: + raise AlreadyFinalized("Context was already finalized.") + + pad_size = block_size // 8 - len(buffer_) + return buffer_ + paddingfn(pad_size) + + +def _byte_unpadding_update(buffer_, data, block_size): + if buffer_ is None: + raise AlreadyFinalized("Context was already finalized.") + + utils._check_byteslike("data", data) + + # six.PY2: Only coerce non-bytes objects to avoid triggering bad behavior + # of future's newbytes type. Unconditionally call bytes() after Python 2 + # support is gone. + buffer_ += data if isinstance(data, bytes) else bytes(data) + + finished_blocks = max(len(buffer_) // (block_size // 8) - 1, 0) + + result = buffer_[: finished_blocks * (block_size // 8)] + buffer_ = buffer_[finished_blocks * (block_size // 8) :] + + return buffer_, result + + +def _byte_unpadding_check(buffer_, block_size, checkfn): + if buffer_ is None: + raise AlreadyFinalized("Context was already finalized.") + + if len(buffer_) != block_size // 8: + raise ValueError("Invalid padding bytes.") + + valid = checkfn(buffer_, block_size // 8) + + if not valid: + raise ValueError("Invalid padding bytes.") + + pad_size = six.indexbytes(buffer_, -1) + return buffer_[:-pad_size] + + +class PKCS7(object): + def __init__(self, block_size): + _byte_padding_check(block_size) + self.block_size = block_size + + def padder(self): + return _PKCS7PaddingContext(self.block_size) + + def unpadder(self): + return _PKCS7UnpaddingContext(self.block_size) + + +@utils.register_interface(PaddingContext) +class _PKCS7PaddingContext(object): + def __init__(self, block_size): + self.block_size = block_size + # TODO: more copies than necessary, we should use zero-buffer (#193) + self._buffer = b"" + + def update(self, data): + self._buffer, result = _byte_padding_update( + self._buffer, data, self.block_size + ) + return result + + def _padding(self, size): + return six.int2byte(size) * size + + def finalize(self): + result = _byte_padding_pad( + self._buffer, self.block_size, self._padding + ) + self._buffer = None + return result + + +@utils.register_interface(PaddingContext) +class _PKCS7UnpaddingContext(object): + def __init__(self, block_size): + self.block_size = block_size + # TODO: more copies than necessary, we should use zero-buffer (#193) + self._buffer = b"" + + def update(self, data): + self._buffer, result = _byte_unpadding_update( + self._buffer, data, self.block_size + ) + return result + + def finalize(self): + result = _byte_unpadding_check( + self._buffer, self.block_size, lib.Cryptography_check_pkcs7_padding + ) + self._buffer = None + return result + + +class ANSIX923(object): + def __init__(self, block_size): + _byte_padding_check(block_size) + self.block_size = block_size + + def padder(self): + return _ANSIX923PaddingContext(self.block_size) + + def unpadder(self): + return _ANSIX923UnpaddingContext(self.block_size) + + +@utils.register_interface(PaddingContext) +class _ANSIX923PaddingContext(object): + def __init__(self, block_size): + self.block_size = block_size + # TODO: more copies than necessary, we should use zero-buffer (#193) + self._buffer = b"" + + def update(self, data): + self._buffer, result = _byte_padding_update( + self._buffer, data, self.block_size + ) + return result + + def _padding(self, size): + return six.int2byte(0) * (size - 1) + six.int2byte(size) + + def finalize(self): + result = _byte_padding_pad( + self._buffer, self.block_size, self._padding + ) + self._buffer = None + return result + + +@utils.register_interface(PaddingContext) +class _ANSIX923UnpaddingContext(object): + def __init__(self, block_size): + self.block_size = block_size + # TODO: more copies than necessary, we should use zero-buffer (#193) + self._buffer = b"" + + def update(self, data): + self._buffer, result = _byte_unpadding_update( + self._buffer, data, self.block_size + ) + return result + + def finalize(self): + result = _byte_unpadding_check( + self._buffer, + self.block_size, + lib.Cryptography_check_ansix923_padding, + ) + self._buffer = None + return result diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/poly1305.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/poly1305.py new file mode 100644 index 0000000000..6439686202 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/poly1305.py @@ -0,0 +1,58 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + + +from cryptography import utils +from cryptography.exceptions import ( + AlreadyFinalized, + UnsupportedAlgorithm, + _Reasons, +) + + +class Poly1305(object): + def __init__(self, key): + from cryptography.hazmat.backends.openssl.backend import backend + + if not backend.poly1305_supported(): + raise UnsupportedAlgorithm( + "poly1305 is not supported by this version of OpenSSL.", + _Reasons.UNSUPPORTED_MAC, + ) + self._ctx = backend.create_poly1305_ctx(key) + + def update(self, data): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + utils._check_byteslike("data", data) + self._ctx.update(data) + + def finalize(self): + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + mac = self._ctx.finalize() + self._ctx = None + return mac + + def verify(self, tag): + utils._check_bytes("tag", tag) + if self._ctx is None: + raise AlreadyFinalized("Context was already finalized.") + + ctx, self._ctx = self._ctx, None + ctx.verify(tag) + + @classmethod + def generate_tag(cls, key, data): + p = Poly1305(key) + p.update(data) + return p.finalize() + + @classmethod + def verify_tag(cls, key, data, tag): + p = Poly1305(key) + p.update(data) + p.verify(tag) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/__init__.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/__init__.py new file mode 100644 index 0000000000..c2f9b014a6 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/__init__.py @@ -0,0 +1,44 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography.hazmat.primitives.serialization.base import ( + BestAvailableEncryption, + Encoding, + KeySerializationEncryption, + NoEncryption, + ParameterFormat, + PrivateFormat, + PublicFormat, + load_der_parameters, + load_der_private_key, + load_der_public_key, + load_pem_parameters, + load_pem_private_key, + load_pem_public_key, +) +from cryptography.hazmat.primitives.serialization.ssh import ( + load_ssh_private_key, + load_ssh_public_key, +) + + +__all__ = [ + "load_der_parameters", + "load_der_private_key", + "load_der_public_key", + "load_pem_parameters", + "load_pem_private_key", + "load_pem_public_key", + "load_ssh_private_key", + "load_ssh_public_key", + "Encoding", + "PrivateFormat", + "PublicFormat", + "ParameterFormat", + "KeySerializationEncryption", + "BestAvailableEncryption", + "NoEncryption", +] diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/base.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/base.py new file mode 100644 index 0000000000..fc27235c5c --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/base.py @@ -0,0 +1,91 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc +from enum import Enum + +import six + +from cryptography import utils +from cryptography.hazmat.backends import _get_backend + + +def load_pem_private_key(data, password, backend=None): + backend = _get_backend(backend) + return backend.load_pem_private_key(data, password) + + +def load_pem_public_key(data, backend=None): + backend = _get_backend(backend) + return backend.load_pem_public_key(data) + + +def load_pem_parameters(data, backend=None): + backend = _get_backend(backend) + return backend.load_pem_parameters(data) + + +def load_der_private_key(data, password, backend=None): + backend = _get_backend(backend) + return backend.load_der_private_key(data, password) + + +def load_der_public_key(data, backend=None): + backend = _get_backend(backend) + return backend.load_der_public_key(data) + + +def load_der_parameters(data, backend=None): + backend = _get_backend(backend) + return backend.load_der_parameters(data) + + +class Encoding(Enum): + PEM = "PEM" + DER = "DER" + OpenSSH = "OpenSSH" + Raw = "Raw" + X962 = "ANSI X9.62" + SMIME = "S/MIME" + + +class PrivateFormat(Enum): + PKCS8 = "PKCS8" + TraditionalOpenSSL = "TraditionalOpenSSL" + Raw = "Raw" + OpenSSH = "OpenSSH" + + +class PublicFormat(Enum): + SubjectPublicKeyInfo = "X.509 subjectPublicKeyInfo with PKCS#1" + PKCS1 = "Raw PKCS#1" + OpenSSH = "OpenSSH" + Raw = "Raw" + CompressedPoint = "X9.62 Compressed Point" + UncompressedPoint = "X9.62 Uncompressed Point" + + +class ParameterFormat(Enum): + PKCS3 = "PKCS3" + + +@six.add_metaclass(abc.ABCMeta) +class KeySerializationEncryption(object): + pass + + +@utils.register_interface(KeySerializationEncryption) +class BestAvailableEncryption(object): + def __init__(self, password): + if not isinstance(password, bytes) or len(password) == 0: + raise ValueError("Password must be 1 or more bytes.") + + self.password = password + + +@utils.register_interface(KeySerializationEncryption) +class NoEncryption(object): + pass diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/pkcs12.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/pkcs12.py new file mode 100644 index 0000000000..201f32941c --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/pkcs12.py @@ -0,0 +1,50 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography import x509 +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.primitives import serialization +from cryptography.hazmat.primitives.asymmetric import dsa, ec, rsa + + +def load_key_and_certificates(data, password, backend=None): + backend = _get_backend(backend) + return backend.load_key_and_certificates_from_pkcs12(data, password) + + +def serialize_key_and_certificates(name, key, cert, cas, encryption_algorithm): + if key is not None and not isinstance( + key, + ( + rsa.RSAPrivateKeyWithSerialization, + dsa.DSAPrivateKeyWithSerialization, + ec.EllipticCurvePrivateKeyWithSerialization, + ), + ): + raise TypeError("Key must be RSA, DSA, or EllipticCurve private key.") + if cert is not None and not isinstance(cert, x509.Certificate): + raise TypeError("cert must be a certificate") + + if cas is not None: + cas = list(cas) + if not all(isinstance(val, x509.Certificate) for val in cas): + raise TypeError("all values in cas must be certificates") + + if not isinstance( + encryption_algorithm, serialization.KeySerializationEncryption + ): + raise TypeError( + "Key encryption algorithm must be a " + "KeySerializationEncryption instance" + ) + + if key is None and cert is None and not cas: + raise ValueError("You must supply at least one of key, cert, or cas") + + backend = _get_backend(None) + return backend.serialize_key_and_certificates_to_pkcs12( + name, key, cert, cas, encryption_algorithm + ) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/pkcs7.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/pkcs7.py new file mode 100644 index 0000000000..1e11e28ef5 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/pkcs7.py @@ -0,0 +1,132 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from enum import Enum + +from cryptography import x509 +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.primitives import hashes, serialization +from cryptography.hazmat.primitives.asymmetric import ec, rsa +from cryptography.utils import _check_byteslike + + +def load_pem_pkcs7_certificates(data): + backend = _get_backend(None) + return backend.load_pem_pkcs7_certificates(data) + + +def load_der_pkcs7_certificates(data): + backend = _get_backend(None) + return backend.load_der_pkcs7_certificates(data) + + +class PKCS7SignatureBuilder(object): + def __init__(self, data=None, signers=[], additional_certs=[]): + self._data = data + self._signers = signers + self._additional_certs = additional_certs + + def set_data(self, data): + _check_byteslike("data", data) + if self._data is not None: + raise ValueError("data may only be set once") + + return PKCS7SignatureBuilder(data, self._signers) + + def add_signer(self, certificate, private_key, hash_algorithm): + if not isinstance( + hash_algorithm, + ( + hashes.SHA1, + hashes.SHA224, + hashes.SHA256, + hashes.SHA384, + hashes.SHA512, + ), + ): + raise TypeError( + "hash_algorithm must be one of hashes.SHA1, SHA224, " + "SHA256, SHA384, or SHA512" + ) + if not isinstance(certificate, x509.Certificate): + raise TypeError("certificate must be a x509.Certificate") + + if not isinstance( + private_key, (rsa.RSAPrivateKey, ec.EllipticCurvePrivateKey) + ): + raise TypeError("Only RSA & EC keys are supported at this time.") + + return PKCS7SignatureBuilder( + self._data, + self._signers + [(certificate, private_key, hash_algorithm)], + ) + + def add_certificate(self, certificate): + if not isinstance(certificate, x509.Certificate): + raise TypeError("certificate must be a x509.Certificate") + + return PKCS7SignatureBuilder( + self._data, self._signers, self._additional_certs + [certificate] + ) + + def sign(self, encoding, options, backend=None): + if len(self._signers) == 0: + raise ValueError("Must have at least one signer") + if self._data is None: + raise ValueError("You must add data to sign") + options = list(options) + if not all(isinstance(x, PKCS7Options) for x in options): + raise ValueError("options must be from the PKCS7Options enum") + if encoding not in ( + serialization.Encoding.PEM, + serialization.Encoding.DER, + serialization.Encoding.SMIME, + ): + raise ValueError( + "Must be PEM, DER, or SMIME from the Encoding enum" + ) + + # Text is a meaningless option unless it is accompanied by + # DetachedSignature + if ( + PKCS7Options.Text in options + and PKCS7Options.DetachedSignature not in options + ): + raise ValueError( + "When passing the Text option you must also pass " + "DetachedSignature" + ) + + if PKCS7Options.Text in options and encoding in ( + serialization.Encoding.DER, + serialization.Encoding.PEM, + ): + raise ValueError( + "The Text option is only available for SMIME serialization" + ) + + # No attributes implies no capabilities so we'll error if you try to + # pass both. + if ( + PKCS7Options.NoAttributes in options + and PKCS7Options.NoCapabilities in options + ): + raise ValueError( + "NoAttributes is a superset of NoCapabilities. Do not pass " + "both values." + ) + + backend = _get_backend(backend) + return backend.pkcs7_sign(self, encoding, options) + + +class PKCS7Options(Enum): + Text = "Add text/plain MIME type" + Binary = "Don't translate input data into canonical MIME format" + DetachedSignature = "Don't embed data in the PKCS7 structure" + NoCapabilities = "Don't embed SMIME capabilities" + NoAttributes = "Don't embed authenticatedAttributes" + NoCerts = "Don't embed signer certificate" diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/ssh.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/ssh.py new file mode 100644 index 0000000000..5ecae59f8a --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/serialization/ssh.py @@ -0,0 +1,683 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import binascii +import os +import re +import struct + +import six + +from cryptography import utils +from cryptography.exceptions import UnsupportedAlgorithm +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.primitives.asymmetric import dsa, ec, ed25519, rsa +from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes +from cryptography.hazmat.primitives.serialization import ( + Encoding, + NoEncryption, + PrivateFormat, + PublicFormat, +) + +try: + from bcrypt import kdf as _bcrypt_kdf + + _bcrypt_supported = True +except ImportError: + _bcrypt_supported = False + + def _bcrypt_kdf(*args, **kwargs): + raise UnsupportedAlgorithm("Need bcrypt module") + + +try: + from base64 import encodebytes as _base64_encode +except ImportError: + from base64 import encodestring as _base64_encode + +_SSH_ED25519 = b"ssh-ed25519" +_SSH_RSA = b"ssh-rsa" +_SSH_DSA = b"ssh-dss" +_ECDSA_NISTP256 = b"ecdsa-sha2-nistp256" +_ECDSA_NISTP384 = b"ecdsa-sha2-nistp384" +_ECDSA_NISTP521 = b"ecdsa-sha2-nistp521" +_CERT_SUFFIX = b"-cert-v01@openssh.com" + +_SSH_PUBKEY_RC = re.compile(br"\A(\S+)[ \t]+(\S+)") +_SK_MAGIC = b"openssh-key-v1\0" +_SK_START = b"-----BEGIN OPENSSH PRIVATE KEY-----" +_SK_END = b"-----END OPENSSH PRIVATE KEY-----" +_BCRYPT = b"bcrypt" +_NONE = b"none" +_DEFAULT_CIPHER = b"aes256-ctr" +_DEFAULT_ROUNDS = 16 +_MAX_PASSWORD = 72 + +# re is only way to work on bytes-like data +_PEM_RC = re.compile(_SK_START + b"(.*?)" + _SK_END, re.DOTALL) + +# padding for max blocksize +_PADDING = memoryview(bytearray(range(1, 1 + 16))) + +# ciphers that are actually used in key wrapping +_SSH_CIPHERS = { + b"aes256-ctr": (algorithms.AES, 32, modes.CTR, 16), + b"aes256-cbc": (algorithms.AES, 32, modes.CBC, 16), +} + +# map local curve name to key type +_ECDSA_KEY_TYPE = { + "secp256r1": _ECDSA_NISTP256, + "secp384r1": _ECDSA_NISTP384, + "secp521r1": _ECDSA_NISTP521, +} + +_U32 = struct.Struct(b">I") +_U64 = struct.Struct(b">Q") + + +def _ecdsa_key_type(public_key): + """Return SSH key_type and curve_name for private key.""" + curve = public_key.curve + if curve.name not in _ECDSA_KEY_TYPE: + raise ValueError( + "Unsupported curve for ssh private key: %r" % curve.name + ) + return _ECDSA_KEY_TYPE[curve.name] + + +def _ssh_pem_encode(data, prefix=_SK_START + b"\n", suffix=_SK_END + b"\n"): + return b"".join([prefix, _base64_encode(data), suffix]) + + +def _check_block_size(data, block_len): + """Require data to be full blocks""" + if not data or len(data) % block_len != 0: + raise ValueError("Corrupt data: missing padding") + + +def _check_empty(data): + """All data should have been parsed.""" + if data: + raise ValueError("Corrupt data: unparsed data") + + +def _init_cipher(ciphername, password, salt, rounds, backend): + """Generate key + iv and return cipher.""" + if not password: + raise ValueError("Key is password-protected.") + + algo, key_len, mode, iv_len = _SSH_CIPHERS[ciphername] + seed = _bcrypt_kdf(password, salt, key_len + iv_len, rounds, True) + return Cipher(algo(seed[:key_len]), mode(seed[key_len:]), backend) + + +def _get_u32(data): + """Uint32""" + if len(data) < 4: + raise ValueError("Invalid data") + return _U32.unpack(data[:4])[0], data[4:] + + +def _get_u64(data): + """Uint64""" + if len(data) < 8: + raise ValueError("Invalid data") + return _U64.unpack(data[:8])[0], data[8:] + + +def _get_sshstr(data): + """Bytes with u32 length prefix""" + n, data = _get_u32(data) + if n > len(data): + raise ValueError("Invalid data") + return data[:n], data[n:] + + +def _get_mpint(data): + """Big integer.""" + val, data = _get_sshstr(data) + if val and six.indexbytes(val, 0) > 0x7F: + raise ValueError("Invalid data") + return utils.int_from_bytes(val, "big"), data + + +def _to_mpint(val): + """Storage format for signed bigint.""" + if val < 0: + raise ValueError("negative mpint not allowed") + if not val: + return b"" + nbytes = (val.bit_length() + 8) // 8 + return utils.int_to_bytes(val, nbytes) + + +class _FragList(object): + """Build recursive structure without data copy.""" + + def __init__(self, init=None): + self.flist = [] + if init: + self.flist.extend(init) + + def put_raw(self, val): + """Add plain bytes""" + self.flist.append(val) + + def put_u32(self, val): + """Big-endian uint32""" + self.flist.append(_U32.pack(val)) + + def put_sshstr(self, val): + """Bytes prefixed with u32 length""" + if isinstance(val, (bytes, memoryview, bytearray)): + self.put_u32(len(val)) + self.flist.append(val) + else: + self.put_u32(val.size()) + self.flist.extend(val.flist) + + def put_mpint(self, val): + """Big-endian bigint prefixed with u32 length""" + self.put_sshstr(_to_mpint(val)) + + def size(self): + """Current number of bytes""" + return sum(map(len, self.flist)) + + def render(self, dstbuf, pos=0): + """Write into bytearray""" + for frag in self.flist: + flen = len(frag) + start, pos = pos, pos + flen + dstbuf[start:pos] = frag + return pos + + def tobytes(self): + """Return as bytes""" + buf = memoryview(bytearray(self.size())) + self.render(buf) + return buf.tobytes() + + +class _SSHFormatRSA(object): + """Format for RSA keys. + + Public: + mpint e, n + Private: + mpint n, e, d, iqmp, p, q + """ + + def get_public(self, data): + """RSA public fields""" + e, data = _get_mpint(data) + n, data = _get_mpint(data) + return (e, n), data + + def load_public(self, key_type, data, backend): + """Make RSA public key from data.""" + (e, n), data = self.get_public(data) + public_numbers = rsa.RSAPublicNumbers(e, n) + public_key = public_numbers.public_key(backend) + return public_key, data + + def load_private(self, data, pubfields, backend): + """Make RSA private key from data.""" + n, data = _get_mpint(data) + e, data = _get_mpint(data) + d, data = _get_mpint(data) + iqmp, data = _get_mpint(data) + p, data = _get_mpint(data) + q, data = _get_mpint(data) + + if (e, n) != pubfields: + raise ValueError("Corrupt data: rsa field mismatch") + dmp1 = rsa.rsa_crt_dmp1(d, p) + dmq1 = rsa.rsa_crt_dmq1(d, q) + public_numbers = rsa.RSAPublicNumbers(e, n) + private_numbers = rsa.RSAPrivateNumbers( + p, q, d, dmp1, dmq1, iqmp, public_numbers + ) + private_key = private_numbers.private_key(backend) + return private_key, data + + def encode_public(self, public_key, f_pub): + """Write RSA public key""" + pubn = public_key.public_numbers() + f_pub.put_mpint(pubn.e) + f_pub.put_mpint(pubn.n) + + def encode_private(self, private_key, f_priv): + """Write RSA private key""" + private_numbers = private_key.private_numbers() + public_numbers = private_numbers.public_numbers + + f_priv.put_mpint(public_numbers.n) + f_priv.put_mpint(public_numbers.e) + + f_priv.put_mpint(private_numbers.d) + f_priv.put_mpint(private_numbers.iqmp) + f_priv.put_mpint(private_numbers.p) + f_priv.put_mpint(private_numbers.q) + + +class _SSHFormatDSA(object): + """Format for DSA keys. + + Public: + mpint p, q, g, y + Private: + mpint p, q, g, y, x + """ + + def get_public(self, data): + """DSA public fields""" + p, data = _get_mpint(data) + q, data = _get_mpint(data) + g, data = _get_mpint(data) + y, data = _get_mpint(data) + return (p, q, g, y), data + + def load_public(self, key_type, data, backend): + """Make DSA public key from data.""" + (p, q, g, y), data = self.get_public(data) + parameter_numbers = dsa.DSAParameterNumbers(p, q, g) + public_numbers = dsa.DSAPublicNumbers(y, parameter_numbers) + self._validate(public_numbers) + public_key = public_numbers.public_key(backend) + return public_key, data + + def load_private(self, data, pubfields, backend): + """Make DSA private key from data.""" + (p, q, g, y), data = self.get_public(data) + x, data = _get_mpint(data) + + if (p, q, g, y) != pubfields: + raise ValueError("Corrupt data: dsa field mismatch") + parameter_numbers = dsa.DSAParameterNumbers(p, q, g) + public_numbers = dsa.DSAPublicNumbers(y, parameter_numbers) + self._validate(public_numbers) + private_numbers = dsa.DSAPrivateNumbers(x, public_numbers) + private_key = private_numbers.private_key(backend) + return private_key, data + + def encode_public(self, public_key, f_pub): + """Write DSA public key""" + public_numbers = public_key.public_numbers() + parameter_numbers = public_numbers.parameter_numbers + self._validate(public_numbers) + + f_pub.put_mpint(parameter_numbers.p) + f_pub.put_mpint(parameter_numbers.q) + f_pub.put_mpint(parameter_numbers.g) + f_pub.put_mpint(public_numbers.y) + + def encode_private(self, private_key, f_priv): + """Write DSA private key""" + self.encode_public(private_key.public_key(), f_priv) + f_priv.put_mpint(private_key.private_numbers().x) + + def _validate(self, public_numbers): + parameter_numbers = public_numbers.parameter_numbers + if parameter_numbers.p.bit_length() != 1024: + raise ValueError("SSH supports only 1024 bit DSA keys") + + +class _SSHFormatECDSA(object): + """Format for ECDSA keys. + + Public: + str curve + bytes point + Private: + str curve + bytes point + mpint secret + """ + + def __init__(self, ssh_curve_name, curve): + self.ssh_curve_name = ssh_curve_name + self.curve = curve + + def get_public(self, data): + """ECDSA public fields""" + curve, data = _get_sshstr(data) + point, data = _get_sshstr(data) + if curve != self.ssh_curve_name: + raise ValueError("Curve name mismatch") + if six.indexbytes(point, 0) != 4: + raise NotImplementedError("Need uncompressed point") + return (curve, point), data + + def load_public(self, key_type, data, backend): + """Make ECDSA public key from data.""" + (curve_name, point), data = self.get_public(data) + public_key = ec.EllipticCurvePublicKey.from_encoded_point( + self.curve, point.tobytes() + ) + return public_key, data + + def load_private(self, data, pubfields, backend): + """Make ECDSA private key from data.""" + (curve_name, point), data = self.get_public(data) + secret, data = _get_mpint(data) + + if (curve_name, point) != pubfields: + raise ValueError("Corrupt data: ecdsa field mismatch") + private_key = ec.derive_private_key(secret, self.curve, backend) + return private_key, data + + def encode_public(self, public_key, f_pub): + """Write ECDSA public key""" + point = public_key.public_bytes( + Encoding.X962, PublicFormat.UncompressedPoint + ) + f_pub.put_sshstr(self.ssh_curve_name) + f_pub.put_sshstr(point) + + def encode_private(self, private_key, f_priv): + """Write ECDSA private key""" + public_key = private_key.public_key() + private_numbers = private_key.private_numbers() + + self.encode_public(public_key, f_priv) + f_priv.put_mpint(private_numbers.private_value) + + +class _SSHFormatEd25519(object): + """Format for Ed25519 keys. + + Public: + bytes point + Private: + bytes point + bytes secret_and_point + """ + + def get_public(self, data): + """Ed25519 public fields""" + point, data = _get_sshstr(data) + return (point,), data + + def load_public(self, key_type, data, backend): + """Make Ed25519 public key from data.""" + (point,), data = self.get_public(data) + public_key = ed25519.Ed25519PublicKey.from_public_bytes( + point.tobytes() + ) + return public_key, data + + def load_private(self, data, pubfields, backend): + """Make Ed25519 private key from data.""" + (point,), data = self.get_public(data) + keypair, data = _get_sshstr(data) + + secret = keypair[:32] + point2 = keypair[32:] + if point != point2 or (point,) != pubfields: + raise ValueError("Corrupt data: ed25519 field mismatch") + private_key = ed25519.Ed25519PrivateKey.from_private_bytes(secret) + return private_key, data + + def encode_public(self, public_key, f_pub): + """Write Ed25519 public key""" + raw_public_key = public_key.public_bytes( + Encoding.Raw, PublicFormat.Raw + ) + f_pub.put_sshstr(raw_public_key) + + def encode_private(self, private_key, f_priv): + """Write Ed25519 private key""" + public_key = private_key.public_key() + raw_private_key = private_key.private_bytes( + Encoding.Raw, PrivateFormat.Raw, NoEncryption() + ) + raw_public_key = public_key.public_bytes( + Encoding.Raw, PublicFormat.Raw + ) + f_keypair = _FragList([raw_private_key, raw_public_key]) + + self.encode_public(public_key, f_priv) + f_priv.put_sshstr(f_keypair) + + +_KEY_FORMATS = { + _SSH_RSA: _SSHFormatRSA(), + _SSH_DSA: _SSHFormatDSA(), + _SSH_ED25519: _SSHFormatEd25519(), + _ECDSA_NISTP256: _SSHFormatECDSA(b"nistp256", ec.SECP256R1()), + _ECDSA_NISTP384: _SSHFormatECDSA(b"nistp384", ec.SECP384R1()), + _ECDSA_NISTP521: _SSHFormatECDSA(b"nistp521", ec.SECP521R1()), +} + + +def _lookup_kformat(key_type): + """Return valid format or throw error""" + if not isinstance(key_type, bytes): + key_type = memoryview(key_type).tobytes() + if key_type in _KEY_FORMATS: + return _KEY_FORMATS[key_type] + raise UnsupportedAlgorithm("Unsupported key type: %r" % key_type) + + +def load_ssh_private_key(data, password, backend=None): + """Load private key from OpenSSH custom encoding.""" + utils._check_byteslike("data", data) + backend = _get_backend(backend) + if password is not None: + utils._check_bytes("password", password) + + m = _PEM_RC.search(data) + if not m: + raise ValueError("Not OpenSSH private key format") + p1 = m.start(1) + p2 = m.end(1) + data = binascii.a2b_base64(memoryview(data)[p1:p2]) + if not data.startswith(_SK_MAGIC): + raise ValueError("Not OpenSSH private key format") + data = memoryview(data)[len(_SK_MAGIC) :] + + # parse header + ciphername, data = _get_sshstr(data) + kdfname, data = _get_sshstr(data) + kdfoptions, data = _get_sshstr(data) + nkeys, data = _get_u32(data) + if nkeys != 1: + raise ValueError("Only one key supported") + + # load public key data + pubdata, data = _get_sshstr(data) + pub_key_type, pubdata = _get_sshstr(pubdata) + kformat = _lookup_kformat(pub_key_type) + pubfields, pubdata = kformat.get_public(pubdata) + _check_empty(pubdata) + + # load secret data + edata, data = _get_sshstr(data) + _check_empty(data) + + if (ciphername, kdfname) != (_NONE, _NONE): + ciphername = ciphername.tobytes() + if ciphername not in _SSH_CIPHERS: + raise UnsupportedAlgorithm("Unsupported cipher: %r" % ciphername) + if kdfname != _BCRYPT: + raise UnsupportedAlgorithm("Unsupported KDF: %r" % kdfname) + blklen = _SSH_CIPHERS[ciphername][3] + _check_block_size(edata, blklen) + salt, kbuf = _get_sshstr(kdfoptions) + rounds, kbuf = _get_u32(kbuf) + _check_empty(kbuf) + ciph = _init_cipher( + ciphername, password, salt.tobytes(), rounds, backend + ) + edata = memoryview(ciph.decryptor().update(edata)) + else: + blklen = 8 + _check_block_size(edata, blklen) + ck1, edata = _get_u32(edata) + ck2, edata = _get_u32(edata) + if ck1 != ck2: + raise ValueError("Corrupt data: broken checksum") + + # load per-key struct + key_type, edata = _get_sshstr(edata) + if key_type != pub_key_type: + raise ValueError("Corrupt data: key type mismatch") + private_key, edata = kformat.load_private(edata, pubfields, backend) + comment, edata = _get_sshstr(edata) + + # yes, SSH does padding check *after* all other parsing is done. + # need to follow as it writes zero-byte padding too. + if edata != _PADDING[: len(edata)]: + raise ValueError("Corrupt data: invalid padding") + + return private_key + + +def serialize_ssh_private_key(private_key, password=None): + """Serialize private key with OpenSSH custom encoding.""" + if password is not None: + utils._check_bytes("password", password) + if password and len(password) > _MAX_PASSWORD: + raise ValueError( + "Passwords longer than 72 bytes are not supported by " + "OpenSSH private key format" + ) + + if isinstance(private_key, ec.EllipticCurvePrivateKey): + key_type = _ecdsa_key_type(private_key.public_key()) + elif isinstance(private_key, rsa.RSAPrivateKey): + key_type = _SSH_RSA + elif isinstance(private_key, dsa.DSAPrivateKey): + key_type = _SSH_DSA + elif isinstance(private_key, ed25519.Ed25519PrivateKey): + key_type = _SSH_ED25519 + else: + raise ValueError("Unsupported key type") + kformat = _lookup_kformat(key_type) + + # setup parameters + f_kdfoptions = _FragList() + if password: + ciphername = _DEFAULT_CIPHER + blklen = _SSH_CIPHERS[ciphername][3] + kdfname = _BCRYPT + rounds = _DEFAULT_ROUNDS + salt = os.urandom(16) + f_kdfoptions.put_sshstr(salt) + f_kdfoptions.put_u32(rounds) + backend = _get_backend(None) + ciph = _init_cipher(ciphername, password, salt, rounds, backend) + else: + ciphername = kdfname = _NONE + blklen = 8 + ciph = None + nkeys = 1 + checkval = os.urandom(4) + comment = b"" + + # encode public and private parts together + f_public_key = _FragList() + f_public_key.put_sshstr(key_type) + kformat.encode_public(private_key.public_key(), f_public_key) + + f_secrets = _FragList([checkval, checkval]) + f_secrets.put_sshstr(key_type) + kformat.encode_private(private_key, f_secrets) + f_secrets.put_sshstr(comment) + f_secrets.put_raw(_PADDING[: blklen - (f_secrets.size() % blklen)]) + + # top-level structure + f_main = _FragList() + f_main.put_raw(_SK_MAGIC) + f_main.put_sshstr(ciphername) + f_main.put_sshstr(kdfname) + f_main.put_sshstr(f_kdfoptions) + f_main.put_u32(nkeys) + f_main.put_sshstr(f_public_key) + f_main.put_sshstr(f_secrets) + + # copy result info bytearray + slen = f_secrets.size() + mlen = f_main.size() + buf = memoryview(bytearray(mlen + blklen)) + f_main.render(buf) + ofs = mlen - slen + + # encrypt in-place + if ciph is not None: + ciph.encryptor().update_into(buf[ofs:mlen], buf[ofs:]) + + txt = _ssh_pem_encode(buf[:mlen]) + buf[ofs:mlen] = bytearray(slen) + return txt + + +def load_ssh_public_key(data, backend=None): + """Load public key from OpenSSH one-line format.""" + backend = _get_backend(backend) + utils._check_byteslike("data", data) + + m = _SSH_PUBKEY_RC.match(data) + if not m: + raise ValueError("Invalid line format") + key_type = orig_key_type = m.group(1) + key_body = m.group(2) + with_cert = False + if _CERT_SUFFIX == key_type[-len(_CERT_SUFFIX) :]: + with_cert = True + key_type = key_type[: -len(_CERT_SUFFIX)] + kformat = _lookup_kformat(key_type) + + try: + data = memoryview(binascii.a2b_base64(key_body)) + except (TypeError, binascii.Error): + raise ValueError("Invalid key format") + + inner_key_type, data = _get_sshstr(data) + if inner_key_type != orig_key_type: + raise ValueError("Invalid key format") + if with_cert: + nonce, data = _get_sshstr(data) + public_key, data = kformat.load_public(key_type, data, backend) + if with_cert: + serial, data = _get_u64(data) + cctype, data = _get_u32(data) + key_id, data = _get_sshstr(data) + principals, data = _get_sshstr(data) + valid_after, data = _get_u64(data) + valid_before, data = _get_u64(data) + crit_options, data = _get_sshstr(data) + extensions, data = _get_sshstr(data) + reserved, data = _get_sshstr(data) + sig_key, data = _get_sshstr(data) + signature, data = _get_sshstr(data) + _check_empty(data) + return public_key + + +def serialize_ssh_public_key(public_key): + """One-line public key format for OpenSSH""" + if isinstance(public_key, ec.EllipticCurvePublicKey): + key_type = _ecdsa_key_type(public_key) + elif isinstance(public_key, rsa.RSAPublicKey): + key_type = _SSH_RSA + elif isinstance(public_key, dsa.DSAPublicKey): + key_type = _SSH_DSA + elif isinstance(public_key, ed25519.Ed25519PublicKey): + key_type = _SSH_ED25519 + else: + raise ValueError("Unsupported key type") + kformat = _lookup_kformat(key_type) + + f_pub = _FragList() + f_pub.put_sshstr(key_type) + kformat.encode_public(public_key, f_pub) + + pub = binascii.b2a_base64(f_pub.tobytes()).strip() + return b"".join([key_type, b" ", pub]) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/__init__.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/__init__.py new file mode 100644 index 0000000000..e71f9e67a3 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/__init__.py @@ -0,0 +1,9 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + + +class InvalidToken(Exception): + pass diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/hotp.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/hotp.py new file mode 100644 index 0000000000..c00eec0e54 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/hotp.py @@ -0,0 +1,69 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import struct + +import six + +from cryptography.exceptions import UnsupportedAlgorithm, _Reasons +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import HMACBackend +from cryptography.hazmat.primitives import constant_time, hmac +from cryptography.hazmat.primitives.hashes import SHA1, SHA256, SHA512 +from cryptography.hazmat.primitives.twofactor import InvalidToken +from cryptography.hazmat.primitives.twofactor.utils import _generate_uri + + +class HOTP(object): + def __init__( + self, key, length, algorithm, backend=None, enforce_key_length=True + ): + backend = _get_backend(backend) + if not isinstance(backend, HMACBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement HMACBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + if len(key) < 16 and enforce_key_length is True: + raise ValueError("Key length has to be at least 128 bits.") + + if not isinstance(length, six.integer_types): + raise TypeError("Length parameter must be an integer type.") + + if length < 6 or length > 8: + raise ValueError("Length of HOTP has to be between 6 to 8.") + + if not isinstance(algorithm, (SHA1, SHA256, SHA512)): + raise TypeError("Algorithm must be SHA1, SHA256 or SHA512.") + + self._key = key + self._length = length + self._algorithm = algorithm + self._backend = backend + + def generate(self, counter): + truncated_value = self._dynamic_truncate(counter) + hotp = truncated_value % (10 ** self._length) + return "{0:0{1}}".format(hotp, self._length).encode() + + def verify(self, hotp, counter): + if not constant_time.bytes_eq(self.generate(counter), hotp): + raise InvalidToken("Supplied HOTP value does not match.") + + def _dynamic_truncate(self, counter): + ctx = hmac.HMAC(self._key, self._algorithm, self._backend) + ctx.update(struct.pack(">Q", counter)) + hmac_value = ctx.finalize() + + offset = six.indexbytes(hmac_value, len(hmac_value) - 1) & 0b1111 + p = hmac_value[offset : offset + 4] + return struct.unpack(">I", p)[0] & 0x7FFFFFFF + + def get_provisioning_uri(self, account_name, counter, issuer): + return _generate_uri( + self, "hotp", account_name, issuer, [("counter", int(counter))] + ) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/totp.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/totp.py new file mode 100644 index 0000000000..d59539b3f9 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/totp.py @@ -0,0 +1,51 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography.exceptions import UnsupportedAlgorithm, _Reasons +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.backends.interfaces import HMACBackend +from cryptography.hazmat.primitives import constant_time +from cryptography.hazmat.primitives.twofactor import InvalidToken +from cryptography.hazmat.primitives.twofactor.hotp import HOTP +from cryptography.hazmat.primitives.twofactor.utils import _generate_uri + + +class TOTP(object): + def __init__( + self, + key, + length, + algorithm, + time_step, + backend=None, + enforce_key_length=True, + ): + backend = _get_backend(backend) + if not isinstance(backend, HMACBackend): + raise UnsupportedAlgorithm( + "Backend object does not implement HMACBackend.", + _Reasons.BACKEND_MISSING_INTERFACE, + ) + + self._time_step = time_step + self._hotp = HOTP(key, length, algorithm, backend, enforce_key_length) + + def generate(self, time): + counter = int(time / self._time_step) + return self._hotp.generate(counter) + + def verify(self, totp, time): + if not constant_time.bytes_eq(self.generate(time), totp): + raise InvalidToken("Supplied TOTP value does not match.") + + def get_provisioning_uri(self, account_name, issuer): + return _generate_uri( + self._hotp, + "totp", + account_name, + issuer, + [("period", int(self._time_step))], + ) diff --git a/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/utils.py b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/utils.py new file mode 100644 index 0000000000..0afa1ccc04 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/hazmat/primitives/twofactor/utils.py @@ -0,0 +1,33 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import base64 + +from six.moves.urllib.parse import quote, urlencode + + +def _generate_uri(hotp, type_name, account_name, issuer, extra_parameters): + parameters = [ + ("digits", hotp._length), + ("secret", base64.b32encode(hotp._key)), + ("algorithm", hotp._algorithm.name.upper()), + ] + + if issuer is not None: + parameters.append(("issuer", issuer)) + + parameters.extend(extra_parameters) + + uriparts = { + "type": type_name, + "label": ( + "%s:%s" % (quote(issuer), quote(account_name)) + if issuer + else quote(account_name) + ), + "parameters": urlencode(parameters), + } + return "otpauth://{type}/{label}?{parameters}".format(**uriparts) diff --git a/contrib/python/cryptography/py3/cryptography/utils.py b/contrib/python/cryptography/py3/cryptography/utils.py new file mode 100644 index 0000000000..bdb3dbf477 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/utils.py @@ -0,0 +1,171 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc +import binascii +import inspect +import sys +import warnings + + +# We use a UserWarning subclass, instead of DeprecationWarning, because CPython +# decided deprecation warnings should be invisble by default. +class CryptographyDeprecationWarning(UserWarning): + pass + + +# Several APIs were deprecated with no specific end-of-life date because of the +# ubiquity of their use. They should not be removed until we agree on when that +# cycle ends. +PersistentlyDeprecated2017 = CryptographyDeprecationWarning +PersistentlyDeprecated2019 = CryptographyDeprecationWarning + + +def _check_bytes(name, value): + if not isinstance(value, bytes): + raise TypeError("{} must be bytes".format(name)) + + +def _check_byteslike(name, value): + try: + memoryview(value) + except TypeError: + raise TypeError("{} must be bytes-like".format(name)) + + +def read_only_property(name): + return property(lambda self: getattr(self, name)) + + +def register_interface(iface): + def register_decorator(klass): + verify_interface(iface, klass) + iface.register(klass) + return klass + + return register_decorator + + +def register_interface_if(predicate, iface): + def register_decorator(klass): + if predicate: + verify_interface(iface, klass) + iface.register(klass) + return klass + + return register_decorator + + +if hasattr(int, "from_bytes"): + int_from_bytes = int.from_bytes +else: + + def int_from_bytes(data, byteorder, signed=False): + assert byteorder == "big" + assert not signed + + return int(binascii.hexlify(data), 16) + + +if hasattr(int, "to_bytes"): + + def int_to_bytes(integer, length=None): + return integer.to_bytes( + length or (integer.bit_length() + 7) // 8 or 1, "big" + ) + + +else: + + def int_to_bytes(integer, length=None): + hex_string = "%x" % integer + if length is None: + n = len(hex_string) + else: + n = length * 2 + return binascii.unhexlify(hex_string.zfill(n + (n & 1))) + + +class InterfaceNotImplemented(Exception): + pass + + +if hasattr(inspect, "signature"): + signature = inspect.signature +else: + signature = inspect.getargspec + + +def verify_interface(iface, klass): + for method in iface.__abstractmethods__: + if not hasattr(klass, method): + raise InterfaceNotImplemented( + "{} is missing a {!r} method".format(klass, method) + ) + if isinstance(getattr(iface, method), abc.abstractproperty): + # Can't properly verify these yet. + continue + sig = signature(getattr(iface, method)) + actual = signature(getattr(klass, method)) + if sig != actual: + raise InterfaceNotImplemented( + "{}.{}'s signature differs from the expected. Expected: " + "{!r}. Received: {!r}".format(klass, method, sig, actual) + ) + + +class _DeprecatedValue(object): + def __init__(self, value, message, warning_class): + self.value = value + self.message = message + self.warning_class = warning_class + + +class _ModuleWithDeprecations(object): + def __init__(self, module): + self.__dict__["_module"] = module + + def __getattr__(self, attr): + obj = getattr(self._module, attr) + if isinstance(obj, _DeprecatedValue): + warnings.warn(obj.message, obj.warning_class, stacklevel=2) + obj = obj.value + return obj + + def __setattr__(self, attr, value): + setattr(self._module, attr, value) + + def __delattr__(self, attr): + obj = getattr(self._module, attr) + if isinstance(obj, _DeprecatedValue): + warnings.warn(obj.message, obj.warning_class, stacklevel=2) + + delattr(self._module, attr) + + def __dir__(self): + return ["_module"] + dir(self._module) + + +def deprecated(value, module_name, message, warning_class): + module = sys.modules[module_name] + if not isinstance(module, _ModuleWithDeprecations): + sys.modules[module_name] = _ModuleWithDeprecations(module) + return _DeprecatedValue(value, message, warning_class) + + +def cached_property(func): + cached_name = "_cached_{}".format(func) + sentinel = object() + + def inner(instance): + cache = getattr(instance, cached_name, sentinel) + if cache is not sentinel: + return cache + result = func(instance) + setattr(instance, cached_name, result) + return result + + return property(inner) diff --git a/contrib/python/cryptography/py3/cryptography/x509/__init__.py b/contrib/python/cryptography/py3/cryptography/x509/__init__.py new file mode 100644 index 0000000000..69630e4cba --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/x509/__init__.py @@ -0,0 +1,248 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography.x509 import certificate_transparency +from cryptography.x509.base import ( + AttributeNotFound, + Certificate, + CertificateBuilder, + CertificateRevocationList, + CertificateRevocationListBuilder, + CertificateSigningRequest, + CertificateSigningRequestBuilder, + InvalidVersion, + RevokedCertificate, + RevokedCertificateBuilder, + Version, + load_der_x509_certificate, + load_der_x509_crl, + load_der_x509_csr, + load_pem_x509_certificate, + load_pem_x509_crl, + load_pem_x509_csr, + random_serial_number, +) +from cryptography.x509.extensions import ( + AccessDescription, + AuthorityInformationAccess, + AuthorityKeyIdentifier, + BasicConstraints, + CRLDistributionPoints, + CRLNumber, + CRLReason, + CertificateIssuer, + CertificatePolicies, + DeltaCRLIndicator, + DistributionPoint, + DuplicateExtension, + ExtendedKeyUsage, + Extension, + ExtensionNotFound, + ExtensionType, + Extensions, + FreshestCRL, + GeneralNames, + InhibitAnyPolicy, + InvalidityDate, + IssuerAlternativeName, + IssuingDistributionPoint, + KeyUsage, + NameConstraints, + NoticeReference, + OCSPNoCheck, + OCSPNonce, + PolicyConstraints, + PolicyInformation, + PrecertPoison, + PrecertificateSignedCertificateTimestamps, + ReasonFlags, + SignedCertificateTimestamps, + SubjectAlternativeName, + SubjectInformationAccess, + SubjectKeyIdentifier, + TLSFeature, + TLSFeatureType, + UnrecognizedExtension, + UserNotice, +) +from cryptography.x509.general_name import ( + DNSName, + DirectoryName, + GeneralName, + IPAddress, + OtherName, + RFC822Name, + RegisteredID, + UniformResourceIdentifier, + UnsupportedGeneralNameType, + _GENERAL_NAMES, +) +from cryptography.x509.name import ( + Name, + NameAttribute, + RelativeDistinguishedName, +) +from cryptography.x509.oid import ( + AuthorityInformationAccessOID, + CRLEntryExtensionOID, + CertificatePoliciesOID, + ExtendedKeyUsageOID, + ExtensionOID, + NameOID, + ObjectIdentifier, + SignatureAlgorithmOID, + _SIG_OIDS_TO_HASH, +) + + +OID_AUTHORITY_INFORMATION_ACCESS = ExtensionOID.AUTHORITY_INFORMATION_ACCESS +OID_AUTHORITY_KEY_IDENTIFIER = ExtensionOID.AUTHORITY_KEY_IDENTIFIER +OID_BASIC_CONSTRAINTS = ExtensionOID.BASIC_CONSTRAINTS +OID_CERTIFICATE_POLICIES = ExtensionOID.CERTIFICATE_POLICIES +OID_CRL_DISTRIBUTION_POINTS = ExtensionOID.CRL_DISTRIBUTION_POINTS +OID_EXTENDED_KEY_USAGE = ExtensionOID.EXTENDED_KEY_USAGE +OID_FRESHEST_CRL = ExtensionOID.FRESHEST_CRL +OID_INHIBIT_ANY_POLICY = ExtensionOID.INHIBIT_ANY_POLICY +OID_ISSUER_ALTERNATIVE_NAME = ExtensionOID.ISSUER_ALTERNATIVE_NAME +OID_KEY_USAGE = ExtensionOID.KEY_USAGE +OID_NAME_CONSTRAINTS = ExtensionOID.NAME_CONSTRAINTS +OID_OCSP_NO_CHECK = ExtensionOID.OCSP_NO_CHECK +OID_POLICY_CONSTRAINTS = ExtensionOID.POLICY_CONSTRAINTS +OID_POLICY_MAPPINGS = ExtensionOID.POLICY_MAPPINGS +OID_SUBJECT_ALTERNATIVE_NAME = ExtensionOID.SUBJECT_ALTERNATIVE_NAME +OID_SUBJECT_DIRECTORY_ATTRIBUTES = ExtensionOID.SUBJECT_DIRECTORY_ATTRIBUTES +OID_SUBJECT_INFORMATION_ACCESS = ExtensionOID.SUBJECT_INFORMATION_ACCESS +OID_SUBJECT_KEY_IDENTIFIER = ExtensionOID.SUBJECT_KEY_IDENTIFIER + +OID_DSA_WITH_SHA1 = SignatureAlgorithmOID.DSA_WITH_SHA1 +OID_DSA_WITH_SHA224 = SignatureAlgorithmOID.DSA_WITH_SHA224 +OID_DSA_WITH_SHA256 = SignatureAlgorithmOID.DSA_WITH_SHA256 +OID_ECDSA_WITH_SHA1 = SignatureAlgorithmOID.ECDSA_WITH_SHA1 +OID_ECDSA_WITH_SHA224 = SignatureAlgorithmOID.ECDSA_WITH_SHA224 +OID_ECDSA_WITH_SHA256 = SignatureAlgorithmOID.ECDSA_WITH_SHA256 +OID_ECDSA_WITH_SHA384 = SignatureAlgorithmOID.ECDSA_WITH_SHA384 +OID_ECDSA_WITH_SHA512 = SignatureAlgorithmOID.ECDSA_WITH_SHA512 +OID_RSA_WITH_MD5 = SignatureAlgorithmOID.RSA_WITH_MD5 +OID_RSA_WITH_SHA1 = SignatureAlgorithmOID.RSA_WITH_SHA1 +OID_RSA_WITH_SHA224 = SignatureAlgorithmOID.RSA_WITH_SHA224 +OID_RSA_WITH_SHA256 = SignatureAlgorithmOID.RSA_WITH_SHA256 +OID_RSA_WITH_SHA384 = SignatureAlgorithmOID.RSA_WITH_SHA384 +OID_RSA_WITH_SHA512 = SignatureAlgorithmOID.RSA_WITH_SHA512 +OID_RSASSA_PSS = SignatureAlgorithmOID.RSASSA_PSS + +OID_COMMON_NAME = NameOID.COMMON_NAME +OID_COUNTRY_NAME = NameOID.COUNTRY_NAME +OID_DOMAIN_COMPONENT = NameOID.DOMAIN_COMPONENT +OID_DN_QUALIFIER = NameOID.DN_QUALIFIER +OID_EMAIL_ADDRESS = NameOID.EMAIL_ADDRESS +OID_GENERATION_QUALIFIER = NameOID.GENERATION_QUALIFIER +OID_GIVEN_NAME = NameOID.GIVEN_NAME +OID_LOCALITY_NAME = NameOID.LOCALITY_NAME +OID_ORGANIZATIONAL_UNIT_NAME = NameOID.ORGANIZATIONAL_UNIT_NAME +OID_ORGANIZATION_NAME = NameOID.ORGANIZATION_NAME +OID_PSEUDONYM = NameOID.PSEUDONYM +OID_SERIAL_NUMBER = NameOID.SERIAL_NUMBER +OID_STATE_OR_PROVINCE_NAME = NameOID.STATE_OR_PROVINCE_NAME +OID_SURNAME = NameOID.SURNAME +OID_TITLE = NameOID.TITLE + +OID_CLIENT_AUTH = ExtendedKeyUsageOID.CLIENT_AUTH +OID_CODE_SIGNING = ExtendedKeyUsageOID.CODE_SIGNING +OID_EMAIL_PROTECTION = ExtendedKeyUsageOID.EMAIL_PROTECTION +OID_OCSP_SIGNING = ExtendedKeyUsageOID.OCSP_SIGNING +OID_SERVER_AUTH = ExtendedKeyUsageOID.SERVER_AUTH +OID_TIME_STAMPING = ExtendedKeyUsageOID.TIME_STAMPING + +OID_ANY_POLICY = CertificatePoliciesOID.ANY_POLICY +OID_CPS_QUALIFIER = CertificatePoliciesOID.CPS_QUALIFIER +OID_CPS_USER_NOTICE = CertificatePoliciesOID.CPS_USER_NOTICE + +OID_CERTIFICATE_ISSUER = CRLEntryExtensionOID.CERTIFICATE_ISSUER +OID_CRL_REASON = CRLEntryExtensionOID.CRL_REASON +OID_INVALIDITY_DATE = CRLEntryExtensionOID.INVALIDITY_DATE + +OID_CA_ISSUERS = AuthorityInformationAccessOID.CA_ISSUERS +OID_OCSP = AuthorityInformationAccessOID.OCSP + +__all__ = [ + "certificate_transparency", + "load_pem_x509_certificate", + "load_der_x509_certificate", + "load_pem_x509_csr", + "load_der_x509_csr", + "load_pem_x509_crl", + "load_der_x509_crl", + "random_serial_number", + "AttributeNotFound", + "InvalidVersion", + "DeltaCRLIndicator", + "DuplicateExtension", + "ExtensionNotFound", + "UnsupportedGeneralNameType", + "NameAttribute", + "Name", + "RelativeDistinguishedName", + "ObjectIdentifier", + "ExtensionType", + "Extensions", + "Extension", + "ExtendedKeyUsage", + "FreshestCRL", + "IssuingDistributionPoint", + "TLSFeature", + "TLSFeatureType", + "OCSPNoCheck", + "BasicConstraints", + "CRLNumber", + "KeyUsage", + "AuthorityInformationAccess", + "SubjectInformationAccess", + "AccessDescription", + "CertificatePolicies", + "PolicyInformation", + "UserNotice", + "NoticeReference", + "SubjectKeyIdentifier", + "NameConstraints", + "CRLDistributionPoints", + "DistributionPoint", + "ReasonFlags", + "InhibitAnyPolicy", + "SubjectAlternativeName", + "IssuerAlternativeName", + "AuthorityKeyIdentifier", + "GeneralNames", + "GeneralName", + "RFC822Name", + "DNSName", + "UniformResourceIdentifier", + "RegisteredID", + "DirectoryName", + "IPAddress", + "OtherName", + "Certificate", + "CertificateRevocationList", + "CertificateRevocationListBuilder", + "CertificateSigningRequest", + "RevokedCertificate", + "RevokedCertificateBuilder", + "CertificateSigningRequestBuilder", + "CertificateBuilder", + "Version", + "_SIG_OIDS_TO_HASH", + "OID_CA_ISSUERS", + "OID_OCSP", + "_GENERAL_NAMES", + "CertificateIssuer", + "CRLReason", + "InvalidityDate", + "UnrecognizedExtension", + "PolicyConstraints", + "PrecertificateSignedCertificateTimestamps", + "PrecertPoison", + "OCSPNonce", + "SignedCertificateTimestamps", +] diff --git a/contrib/python/cryptography/py3/cryptography/x509/base.py b/contrib/python/cryptography/py3/cryptography/x509/base.py new file mode 100644 index 0000000000..f3bc872b94 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/x509/base.py @@ -0,0 +1,892 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc +import datetime +import os +from enum import Enum + +import six + +from cryptography import utils +from cryptography.hazmat.backends import _get_backend +from cryptography.hazmat.primitives.asymmetric import ( + dsa, + ec, + ed25519, + ed448, + rsa, +) +from cryptography.x509.extensions import Extension, ExtensionType +from cryptography.x509.name import Name +from cryptography.x509.oid import ObjectIdentifier + + +_EARLIEST_UTC_TIME = datetime.datetime(1950, 1, 1) + + +class AttributeNotFound(Exception): + def __init__(self, msg, oid): + super(AttributeNotFound, self).__init__(msg) + self.oid = oid + + +def _reject_duplicate_extension(extension, extensions): + # This is quadratic in the number of extensions + for e in extensions: + if e.oid == extension.oid: + raise ValueError("This extension has already been set.") + + +def _reject_duplicate_attribute(oid, attributes): + # This is quadratic in the number of attributes + for attr_oid, _ in attributes: + if attr_oid == oid: + raise ValueError("This attribute has already been set.") + + +def _convert_to_naive_utc_time(time): + """Normalizes a datetime to a naive datetime in UTC. + + time -- datetime to normalize. Assumed to be in UTC if not timezone + aware. + """ + if time.tzinfo is not None: + offset = time.utcoffset() + offset = offset if offset else datetime.timedelta() + return time.replace(tzinfo=None) - offset + else: + return time + + +class Version(Enum): + v1 = 0 + v3 = 2 + + +def load_pem_x509_certificate(data, backend=None): + backend = _get_backend(backend) + return backend.load_pem_x509_certificate(data) + + +def load_der_x509_certificate(data, backend=None): + backend = _get_backend(backend) + return backend.load_der_x509_certificate(data) + + +def load_pem_x509_csr(data, backend=None): + backend = _get_backend(backend) + return backend.load_pem_x509_csr(data) + + +def load_der_x509_csr(data, backend=None): + backend = _get_backend(backend) + return backend.load_der_x509_csr(data) + + +def load_pem_x509_crl(data, backend=None): + backend = _get_backend(backend) + return backend.load_pem_x509_crl(data) + + +def load_der_x509_crl(data, backend=None): + backend = _get_backend(backend) + return backend.load_der_x509_crl(data) + + +class InvalidVersion(Exception): + def __init__(self, msg, parsed_version): + super(InvalidVersion, self).__init__(msg) + self.parsed_version = parsed_version + + +@six.add_metaclass(abc.ABCMeta) +class Certificate(object): + @abc.abstractmethod + def fingerprint(self, algorithm): + """ + Returns bytes using digest passed. + """ + + @abc.abstractproperty + def serial_number(self): + """ + Returns certificate serial number + """ + + @abc.abstractproperty + def version(self): + """ + Returns the certificate version + """ + + @abc.abstractmethod + def public_key(self): + """ + Returns the public key + """ + + @abc.abstractproperty + def not_valid_before(self): + """ + Not before time (represented as UTC datetime) + """ + + @abc.abstractproperty + def not_valid_after(self): + """ + Not after time (represented as UTC datetime) + """ + + @abc.abstractproperty + def issuer(self): + """ + Returns the issuer name object. + """ + + @abc.abstractproperty + def subject(self): + """ + Returns the subject name object. + """ + + @abc.abstractproperty + def signature_hash_algorithm(self): + """ + Returns a HashAlgorithm corresponding to the type of the digest signed + in the certificate. + """ + + @abc.abstractproperty + def signature_algorithm_oid(self): + """ + Returns the ObjectIdentifier of the signature algorithm. + """ + + @abc.abstractproperty + def extensions(self): + """ + Returns an Extensions object. + """ + + @abc.abstractproperty + def signature(self): + """ + Returns the signature bytes. + """ + + @abc.abstractproperty + def tbs_certificate_bytes(self): + """ + Returns the tbsCertificate payload bytes as defined in RFC 5280. + """ + + @abc.abstractmethod + def __eq__(self, other): + """ + Checks equality. + """ + + @abc.abstractmethod + def __ne__(self, other): + """ + Checks not equal. + """ + + @abc.abstractmethod + def __hash__(self): + """ + Computes a hash. + """ + + @abc.abstractmethod + def public_bytes(self, encoding): + """ + Serializes the certificate to PEM or DER format. + """ + + +@six.add_metaclass(abc.ABCMeta) +class CertificateRevocationList(object): + @abc.abstractmethod + def public_bytes(self, encoding): + """ + Serializes the CRL to PEM or DER format. + """ + + @abc.abstractmethod + def fingerprint(self, algorithm): + """ + Returns bytes using digest passed. + """ + + @abc.abstractmethod + def get_revoked_certificate_by_serial_number(self, serial_number): + """ + Returns an instance of RevokedCertificate or None if the serial_number + is not in the CRL. + """ + + @abc.abstractproperty + def signature_hash_algorithm(self): + """ + Returns a HashAlgorithm corresponding to the type of the digest signed + in the certificate. + """ + + @abc.abstractproperty + def signature_algorithm_oid(self): + """ + Returns the ObjectIdentifier of the signature algorithm. + """ + + @abc.abstractproperty + def issuer(self): + """ + Returns the X509Name with the issuer of this CRL. + """ + + @abc.abstractproperty + def next_update(self): + """ + Returns the date of next update for this CRL. + """ + + @abc.abstractproperty + def last_update(self): + """ + Returns the date of last update for this CRL. + """ + + @abc.abstractproperty + def extensions(self): + """ + Returns an Extensions object containing a list of CRL extensions. + """ + + @abc.abstractproperty + def signature(self): + """ + Returns the signature bytes. + """ + + @abc.abstractproperty + def tbs_certlist_bytes(self): + """ + Returns the tbsCertList payload bytes as defined in RFC 5280. + """ + + @abc.abstractmethod + def __eq__(self, other): + """ + Checks equality. + """ + + @abc.abstractmethod + def __ne__(self, other): + """ + Checks not equal. + """ + + @abc.abstractmethod + def __len__(self): + """ + Number of revoked certificates in the CRL. + """ + + @abc.abstractmethod + def __getitem__(self, idx): + """ + Returns a revoked certificate (or slice of revoked certificates). + """ + + @abc.abstractmethod + def __iter__(self): + """ + Iterator over the revoked certificates + """ + + @abc.abstractmethod + def is_signature_valid(self, public_key): + """ + Verifies signature of revocation list against given public key. + """ + + +@six.add_metaclass(abc.ABCMeta) +class CertificateSigningRequest(object): + @abc.abstractmethod + def __eq__(self, other): + """ + Checks equality. + """ + + @abc.abstractmethod + def __ne__(self, other): + """ + Checks not equal. + """ + + @abc.abstractmethod + def __hash__(self): + """ + Computes a hash. + """ + + @abc.abstractmethod + def public_key(self): + """ + Returns the public key + """ + + @abc.abstractproperty + def subject(self): + """ + Returns the subject name object. + """ + + @abc.abstractproperty + def signature_hash_algorithm(self): + """ + Returns a HashAlgorithm corresponding to the type of the digest signed + in the certificate. + """ + + @abc.abstractproperty + def signature_algorithm_oid(self): + """ + Returns the ObjectIdentifier of the signature algorithm. + """ + + @abc.abstractproperty + def extensions(self): + """ + Returns the extensions in the signing request. + """ + + @abc.abstractmethod + def public_bytes(self, encoding): + """ + Encodes the request to PEM or DER format. + """ + + @abc.abstractproperty + def signature(self): + """ + Returns the signature bytes. + """ + + @abc.abstractproperty + def tbs_certrequest_bytes(self): + """ + Returns the PKCS#10 CertificationRequestInfo bytes as defined in RFC + 2986. + """ + + @abc.abstractproperty + def is_signature_valid(self): + """ + Verifies signature of signing request. + """ + + @abc.abstractproperty + def get_attribute_for_oid(self): + """ + Get the attribute value for a given OID. + """ + + +@six.add_metaclass(abc.ABCMeta) +class RevokedCertificate(object): + @abc.abstractproperty + def serial_number(self): + """ + Returns the serial number of the revoked certificate. + """ + + @abc.abstractproperty + def revocation_date(self): + """ + Returns the date of when this certificate was revoked. + """ + + @abc.abstractproperty + def extensions(self): + """ + Returns an Extensions object containing a list of Revoked extensions. + """ + + +class CertificateSigningRequestBuilder(object): + def __init__(self, subject_name=None, extensions=[], attributes=[]): + """ + Creates an empty X.509 certificate request (v1). + """ + self._subject_name = subject_name + self._extensions = extensions + self._attributes = attributes + + def subject_name(self, name): + """ + Sets the certificate requestor's distinguished name. + """ + if not isinstance(name, Name): + raise TypeError("Expecting x509.Name object.") + if self._subject_name is not None: + raise ValueError("The subject name may only be set once.") + return CertificateSigningRequestBuilder( + name, self._extensions, self._attributes + ) + + def add_extension(self, extension, critical): + """ + Adds an X.509 extension to the certificate request. + """ + if not isinstance(extension, ExtensionType): + raise TypeError("extension must be an ExtensionType") + + extension = Extension(extension.oid, critical, extension) + _reject_duplicate_extension(extension, self._extensions) + + return CertificateSigningRequestBuilder( + self._subject_name, + self._extensions + [extension], + self._attributes, + ) + + def add_attribute(self, oid, value): + """ + Adds an X.509 attribute with an OID and associated value. + """ + if not isinstance(oid, ObjectIdentifier): + raise TypeError("oid must be an ObjectIdentifier") + + if not isinstance(value, bytes): + raise TypeError("value must be bytes") + + _reject_duplicate_attribute(oid, self._attributes) + + return CertificateSigningRequestBuilder( + self._subject_name, + self._extensions, + self._attributes + [(oid, value)], + ) + + def sign(self, private_key, algorithm, backend=None): + """ + Signs the request using the requestor's private key. + """ + backend = _get_backend(backend) + if self._subject_name is None: + raise ValueError("A CertificateSigningRequest must have a subject") + return backend.create_x509_csr(self, private_key, algorithm) + + +class CertificateBuilder(object): + def __init__( + self, + issuer_name=None, + subject_name=None, + public_key=None, + serial_number=None, + not_valid_before=None, + not_valid_after=None, + extensions=[], + ): + self._version = Version.v3 + self._issuer_name = issuer_name + self._subject_name = subject_name + self._public_key = public_key + self._serial_number = serial_number + self._not_valid_before = not_valid_before + self._not_valid_after = not_valid_after + self._extensions = extensions + + def issuer_name(self, name): + """ + Sets the CA's distinguished name. + """ + if not isinstance(name, Name): + raise TypeError("Expecting x509.Name object.") + if self._issuer_name is not None: + raise ValueError("The issuer name may only be set once.") + return CertificateBuilder( + name, + self._subject_name, + self._public_key, + self._serial_number, + self._not_valid_before, + self._not_valid_after, + self._extensions, + ) + + def subject_name(self, name): + """ + Sets the requestor's distinguished name. + """ + if not isinstance(name, Name): + raise TypeError("Expecting x509.Name object.") + if self._subject_name is not None: + raise ValueError("The subject name may only be set once.") + return CertificateBuilder( + self._issuer_name, + name, + self._public_key, + self._serial_number, + self._not_valid_before, + self._not_valid_after, + self._extensions, + ) + + def public_key(self, key): + """ + Sets the requestor's public key (as found in the signing request). + """ + if not isinstance( + key, + ( + dsa.DSAPublicKey, + rsa.RSAPublicKey, + ec.EllipticCurvePublicKey, + ed25519.Ed25519PublicKey, + ed448.Ed448PublicKey, + ), + ): + raise TypeError( + "Expecting one of DSAPublicKey, RSAPublicKey," + " EllipticCurvePublicKey, Ed25519PublicKey or" + " Ed448PublicKey." + ) + if self._public_key is not None: + raise ValueError("The public key may only be set once.") + return CertificateBuilder( + self._issuer_name, + self._subject_name, + key, + self._serial_number, + self._not_valid_before, + self._not_valid_after, + self._extensions, + ) + + def serial_number(self, number): + """ + Sets the certificate serial number. + """ + if not isinstance(number, six.integer_types): + raise TypeError("Serial number must be of integral type.") + if self._serial_number is not None: + raise ValueError("The serial number may only be set once.") + if number <= 0: + raise ValueError("The serial number should be positive.") + + # ASN.1 integers are always signed, so most significant bit must be + # zero. + if number.bit_length() >= 160: # As defined in RFC 5280 + raise ValueError( + "The serial number should not be more than 159 " "bits." + ) + return CertificateBuilder( + self._issuer_name, + self._subject_name, + self._public_key, + number, + self._not_valid_before, + self._not_valid_after, + self._extensions, + ) + + def not_valid_before(self, time): + """ + Sets the certificate activation time. + """ + if not isinstance(time, datetime.datetime): + raise TypeError("Expecting datetime object.") + if self._not_valid_before is not None: + raise ValueError("The not valid before may only be set once.") + time = _convert_to_naive_utc_time(time) + if time < _EARLIEST_UTC_TIME: + raise ValueError( + "The not valid before date must be on or after" + " 1950 January 1)." + ) + if self._not_valid_after is not None and time > self._not_valid_after: + raise ValueError( + "The not valid before date must be before the not valid after " + "date." + ) + return CertificateBuilder( + self._issuer_name, + self._subject_name, + self._public_key, + self._serial_number, + time, + self._not_valid_after, + self._extensions, + ) + + def not_valid_after(self, time): + """ + Sets the certificate expiration time. + """ + if not isinstance(time, datetime.datetime): + raise TypeError("Expecting datetime object.") + if self._not_valid_after is not None: + raise ValueError("The not valid after may only be set once.") + time = _convert_to_naive_utc_time(time) + if time < _EARLIEST_UTC_TIME: + raise ValueError( + "The not valid after date must be on or after" + " 1950 January 1." + ) + if ( + self._not_valid_before is not None + and time < self._not_valid_before + ): + raise ValueError( + "The not valid after date must be after the not valid before " + "date." + ) + return CertificateBuilder( + self._issuer_name, + self._subject_name, + self._public_key, + self._serial_number, + self._not_valid_before, + time, + self._extensions, + ) + + def add_extension(self, extension, critical): + """ + Adds an X.509 extension to the certificate. + """ + if not isinstance(extension, ExtensionType): + raise TypeError("extension must be an ExtensionType") + + extension = Extension(extension.oid, critical, extension) + _reject_duplicate_extension(extension, self._extensions) + + return CertificateBuilder( + self._issuer_name, + self._subject_name, + self._public_key, + self._serial_number, + self._not_valid_before, + self._not_valid_after, + self._extensions + [extension], + ) + + def sign(self, private_key, algorithm, backend=None): + """ + Signs the certificate using the CA's private key. + """ + backend = _get_backend(backend) + if self._subject_name is None: + raise ValueError("A certificate must have a subject name") + + if self._issuer_name is None: + raise ValueError("A certificate must have an issuer name") + + if self._serial_number is None: + raise ValueError("A certificate must have a serial number") + + if self._not_valid_before is None: + raise ValueError("A certificate must have a not valid before time") + + if self._not_valid_after is None: + raise ValueError("A certificate must have a not valid after time") + + if self._public_key is None: + raise ValueError("A certificate must have a public key") + + return backend.create_x509_certificate(self, private_key, algorithm) + + +class CertificateRevocationListBuilder(object): + def __init__( + self, + issuer_name=None, + last_update=None, + next_update=None, + extensions=[], + revoked_certificates=[], + ): + self._issuer_name = issuer_name + self._last_update = last_update + self._next_update = next_update + self._extensions = extensions + self._revoked_certificates = revoked_certificates + + def issuer_name(self, issuer_name): + if not isinstance(issuer_name, Name): + raise TypeError("Expecting x509.Name object.") + if self._issuer_name is not None: + raise ValueError("The issuer name may only be set once.") + return CertificateRevocationListBuilder( + issuer_name, + self._last_update, + self._next_update, + self._extensions, + self._revoked_certificates, + ) + + def last_update(self, last_update): + if not isinstance(last_update, datetime.datetime): + raise TypeError("Expecting datetime object.") + if self._last_update is not None: + raise ValueError("Last update may only be set once.") + last_update = _convert_to_naive_utc_time(last_update) + if last_update < _EARLIEST_UTC_TIME: + raise ValueError( + "The last update date must be on or after" " 1950 January 1." + ) + if self._next_update is not None and last_update > self._next_update: + raise ValueError( + "The last update date must be before the next update date." + ) + return CertificateRevocationListBuilder( + self._issuer_name, + last_update, + self._next_update, + self._extensions, + self._revoked_certificates, + ) + + def next_update(self, next_update): + if not isinstance(next_update, datetime.datetime): + raise TypeError("Expecting datetime object.") + if self._next_update is not None: + raise ValueError("Last update may only be set once.") + next_update = _convert_to_naive_utc_time(next_update) + if next_update < _EARLIEST_UTC_TIME: + raise ValueError( + "The last update date must be on or after" " 1950 January 1." + ) + if self._last_update is not None and next_update < self._last_update: + raise ValueError( + "The next update date must be after the last update date." + ) + return CertificateRevocationListBuilder( + self._issuer_name, + self._last_update, + next_update, + self._extensions, + self._revoked_certificates, + ) + + def add_extension(self, extension, critical): + """ + Adds an X.509 extension to the certificate revocation list. + """ + if not isinstance(extension, ExtensionType): + raise TypeError("extension must be an ExtensionType") + + extension = Extension(extension.oid, critical, extension) + _reject_duplicate_extension(extension, self._extensions) + return CertificateRevocationListBuilder( + self._issuer_name, + self._last_update, + self._next_update, + self._extensions + [extension], + self._revoked_certificates, + ) + + def add_revoked_certificate(self, revoked_certificate): + """ + Adds a revoked certificate to the CRL. + """ + if not isinstance(revoked_certificate, RevokedCertificate): + raise TypeError("Must be an instance of RevokedCertificate") + + return CertificateRevocationListBuilder( + self._issuer_name, + self._last_update, + self._next_update, + self._extensions, + self._revoked_certificates + [revoked_certificate], + ) + + def sign(self, private_key, algorithm, backend=None): + backend = _get_backend(backend) + if self._issuer_name is None: + raise ValueError("A CRL must have an issuer name") + + if self._last_update is None: + raise ValueError("A CRL must have a last update time") + + if self._next_update is None: + raise ValueError("A CRL must have a next update time") + + return backend.create_x509_crl(self, private_key, algorithm) + + +class RevokedCertificateBuilder(object): + def __init__( + self, serial_number=None, revocation_date=None, extensions=[] + ): + self._serial_number = serial_number + self._revocation_date = revocation_date + self._extensions = extensions + + def serial_number(self, number): + if not isinstance(number, six.integer_types): + raise TypeError("Serial number must be of integral type.") + if self._serial_number is not None: + raise ValueError("The serial number may only be set once.") + if number <= 0: + raise ValueError("The serial number should be positive") + + # ASN.1 integers are always signed, so most significant bit must be + # zero. + if number.bit_length() >= 160: # As defined in RFC 5280 + raise ValueError( + "The serial number should not be more than 159 " "bits." + ) + return RevokedCertificateBuilder( + number, self._revocation_date, self._extensions + ) + + def revocation_date(self, time): + if not isinstance(time, datetime.datetime): + raise TypeError("Expecting datetime object.") + if self._revocation_date is not None: + raise ValueError("The revocation date may only be set once.") + time = _convert_to_naive_utc_time(time) + if time < _EARLIEST_UTC_TIME: + raise ValueError( + "The revocation date must be on or after" " 1950 January 1." + ) + return RevokedCertificateBuilder( + self._serial_number, time, self._extensions + ) + + def add_extension(self, extension, critical): + if not isinstance(extension, ExtensionType): + raise TypeError("extension must be an ExtensionType") + + extension = Extension(extension.oid, critical, extension) + _reject_duplicate_extension(extension, self._extensions) + return RevokedCertificateBuilder( + self._serial_number, + self._revocation_date, + self._extensions + [extension], + ) + + def build(self, backend=None): + backend = _get_backend(backend) + if self._serial_number is None: + raise ValueError("A revoked certificate must have a serial number") + if self._revocation_date is None: + raise ValueError( + "A revoked certificate must have a revocation date" + ) + + return backend.create_x509_revoked_certificate(self) + + +def random_serial_number(): + return utils.int_from_bytes(os.urandom(20), "big") >> 1 diff --git a/contrib/python/cryptography/py3/cryptography/x509/certificate_transparency.py b/contrib/python/cryptography/py3/cryptography/x509/certificate_transparency.py new file mode 100644 index 0000000000..d00fe81269 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/x509/certificate_transparency.py @@ -0,0 +1,46 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc +from enum import Enum + +import six + + +class LogEntryType(Enum): + X509_CERTIFICATE = 0 + PRE_CERTIFICATE = 1 + + +class Version(Enum): + v1 = 0 + + +@six.add_metaclass(abc.ABCMeta) +class SignedCertificateTimestamp(object): + @abc.abstractproperty + def version(self): + """ + Returns the SCT version. + """ + + @abc.abstractproperty + def log_id(self): + """ + Returns an identifier indicating which log this SCT is for. + """ + + @abc.abstractproperty + def timestamp(self): + """ + Returns the timestamp for this SCT. + """ + + @abc.abstractproperty + def entry_type(self): + """ + Returns whether this is an SCT for a certificate or pre-certificate. + """ diff --git a/contrib/python/cryptography/py3/cryptography/x509/extensions.py b/contrib/python/cryptography/py3/cryptography/x509/extensions.py new file mode 100644 index 0000000000..130ba69b87 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/x509/extensions.py @@ -0,0 +1,1702 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc +import datetime +import hashlib +import ipaddress +from enum import Enum + +import six + +from cryptography import utils +from cryptography.hazmat._der import ( + BIT_STRING, + DERReader, + OBJECT_IDENTIFIER, + SEQUENCE, +) +from cryptography.hazmat.primitives import constant_time, serialization +from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePublicKey +from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicKey +from cryptography.x509.certificate_transparency import ( + SignedCertificateTimestamp, +) +from cryptography.x509.general_name import GeneralName, IPAddress, OtherName +from cryptography.x509.name import RelativeDistinguishedName +from cryptography.x509.oid import ( + CRLEntryExtensionOID, + ExtensionOID, + OCSPExtensionOID, + ObjectIdentifier, +) + + +def _key_identifier_from_public_key(public_key): + if isinstance(public_key, RSAPublicKey): + data = public_key.public_bytes( + serialization.Encoding.DER, + serialization.PublicFormat.PKCS1, + ) + elif isinstance(public_key, EllipticCurvePublicKey): + data = public_key.public_bytes( + serialization.Encoding.X962, + serialization.PublicFormat.UncompressedPoint, + ) + else: + # This is a very slow way to do this. + serialized = public_key.public_bytes( + serialization.Encoding.DER, + serialization.PublicFormat.SubjectPublicKeyInfo, + ) + + reader = DERReader(serialized) + with reader.read_single_element(SEQUENCE) as public_key_info: + algorithm = public_key_info.read_element(SEQUENCE) + public_key = public_key_info.read_element(BIT_STRING) + + # Double-check the algorithm structure. + with algorithm: + algorithm.read_element(OBJECT_IDENTIFIER) + if not algorithm.is_empty(): + # Skip the optional parameters field. + algorithm.read_any_element() + + # BIT STRING contents begin with the number of padding bytes added. It + # must be zero for SubjectPublicKeyInfo structures. + if public_key.read_byte() != 0: + raise ValueError("Invalid public key encoding") + + data = public_key.data + + return hashlib.sha1(data).digest() + + +def _make_sequence_methods(field_name): + def len_method(self): + return len(getattr(self, field_name)) + + def iter_method(self): + return iter(getattr(self, field_name)) + + def getitem_method(self, idx): + return getattr(self, field_name)[idx] + + return len_method, iter_method, getitem_method + + +class DuplicateExtension(Exception): + def __init__(self, msg, oid): + super(DuplicateExtension, self).__init__(msg) + self.oid = oid + + +class ExtensionNotFound(Exception): + def __init__(self, msg, oid): + super(ExtensionNotFound, self).__init__(msg) + self.oid = oid + + +@six.add_metaclass(abc.ABCMeta) +class ExtensionType(object): + @abc.abstractproperty + def oid(self): + """ + Returns the oid associated with the given extension type. + """ + + +class Extensions(object): + def __init__(self, extensions): + self._extensions = extensions + + def get_extension_for_oid(self, oid): + for ext in self: + if ext.oid == oid: + return ext + + raise ExtensionNotFound("No {} extension was found".format(oid), oid) + + def get_extension_for_class(self, extclass): + if extclass is UnrecognizedExtension: + raise TypeError( + "UnrecognizedExtension can't be used with " + "get_extension_for_class because more than one instance of the" + " class may be present." + ) + + for ext in self: + if isinstance(ext.value, extclass): + return ext + + raise ExtensionNotFound( + "No {} extension was found".format(extclass), extclass.oid + ) + + __len__, __iter__, __getitem__ = _make_sequence_methods("_extensions") + + def __repr__(self): + return "<Extensions({})>".format(self._extensions) + + +@utils.register_interface(ExtensionType) +class CRLNumber(object): + oid = ExtensionOID.CRL_NUMBER + + def __init__(self, crl_number): + if not isinstance(crl_number, six.integer_types): + raise TypeError("crl_number must be an integer") + + self._crl_number = crl_number + + def __eq__(self, other): + if not isinstance(other, CRLNumber): + return NotImplemented + + return self.crl_number == other.crl_number + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.crl_number) + + def __repr__(self): + return "<CRLNumber({})>".format(self.crl_number) + + crl_number = utils.read_only_property("_crl_number") + + +@utils.register_interface(ExtensionType) +class AuthorityKeyIdentifier(object): + oid = ExtensionOID.AUTHORITY_KEY_IDENTIFIER + + def __init__( + self, + key_identifier, + authority_cert_issuer, + authority_cert_serial_number, + ): + if (authority_cert_issuer is None) != ( + authority_cert_serial_number is None + ): + raise ValueError( + "authority_cert_issuer and authority_cert_serial_number " + "must both be present or both None" + ) + + if authority_cert_issuer is not None: + authority_cert_issuer = list(authority_cert_issuer) + if not all( + isinstance(x, GeneralName) for x in authority_cert_issuer + ): + raise TypeError( + "authority_cert_issuer must be a list of GeneralName " + "objects" + ) + + if authority_cert_serial_number is not None and not isinstance( + authority_cert_serial_number, six.integer_types + ): + raise TypeError("authority_cert_serial_number must be an integer") + + self._key_identifier = key_identifier + self._authority_cert_issuer = authority_cert_issuer + self._authority_cert_serial_number = authority_cert_serial_number + + @classmethod + def from_issuer_public_key(cls, public_key): + digest = _key_identifier_from_public_key(public_key) + return cls( + key_identifier=digest, + authority_cert_issuer=None, + authority_cert_serial_number=None, + ) + + @classmethod + def from_issuer_subject_key_identifier(cls, ski): + return cls( + key_identifier=ski.digest, + authority_cert_issuer=None, + authority_cert_serial_number=None, + ) + + def __repr__(self): + return ( + "<AuthorityKeyIdentifier(key_identifier={0.key_identifier!r}, " + "authority_cert_issuer={0.authority_cert_issuer}, " + "authority_cert_serial_number={0.authority_cert_serial_number}" + ")>".format(self) + ) + + def __eq__(self, other): + if not isinstance(other, AuthorityKeyIdentifier): + return NotImplemented + + return ( + self.key_identifier == other.key_identifier + and self.authority_cert_issuer == other.authority_cert_issuer + and self.authority_cert_serial_number + == other.authority_cert_serial_number + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + if self.authority_cert_issuer is None: + aci = None + else: + aci = tuple(self.authority_cert_issuer) + return hash( + (self.key_identifier, aci, self.authority_cert_serial_number) + ) + + key_identifier = utils.read_only_property("_key_identifier") + authority_cert_issuer = utils.read_only_property("_authority_cert_issuer") + authority_cert_serial_number = utils.read_only_property( + "_authority_cert_serial_number" + ) + + +@utils.register_interface(ExtensionType) +class SubjectKeyIdentifier(object): + oid = ExtensionOID.SUBJECT_KEY_IDENTIFIER + + def __init__(self, digest): + self._digest = digest + + @classmethod + def from_public_key(cls, public_key): + return cls(_key_identifier_from_public_key(public_key)) + + digest = utils.read_only_property("_digest") + + def __repr__(self): + return "<SubjectKeyIdentifier(digest={0!r})>".format(self.digest) + + def __eq__(self, other): + if not isinstance(other, SubjectKeyIdentifier): + return NotImplemented + + return constant_time.bytes_eq(self.digest, other.digest) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.digest) + + +@utils.register_interface(ExtensionType) +class AuthorityInformationAccess(object): + oid = ExtensionOID.AUTHORITY_INFORMATION_ACCESS + + def __init__(self, descriptions): + descriptions = list(descriptions) + if not all(isinstance(x, AccessDescription) for x in descriptions): + raise TypeError( + "Every item in the descriptions list must be an " + "AccessDescription" + ) + + self._descriptions = descriptions + + __len__, __iter__, __getitem__ = _make_sequence_methods("_descriptions") + + def __repr__(self): + return "<AuthorityInformationAccess({})>".format(self._descriptions) + + def __eq__(self, other): + if not isinstance(other, AuthorityInformationAccess): + return NotImplemented + + return self._descriptions == other._descriptions + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(tuple(self._descriptions)) + + +@utils.register_interface(ExtensionType) +class SubjectInformationAccess(object): + oid = ExtensionOID.SUBJECT_INFORMATION_ACCESS + + def __init__(self, descriptions): + descriptions = list(descriptions) + if not all(isinstance(x, AccessDescription) for x in descriptions): + raise TypeError( + "Every item in the descriptions list must be an " + "AccessDescription" + ) + + self._descriptions = descriptions + + __len__, __iter__, __getitem__ = _make_sequence_methods("_descriptions") + + def __repr__(self): + return "<SubjectInformationAccess({})>".format(self._descriptions) + + def __eq__(self, other): + if not isinstance(other, SubjectInformationAccess): + return NotImplemented + + return self._descriptions == other._descriptions + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(tuple(self._descriptions)) + + +class AccessDescription(object): + def __init__(self, access_method, access_location): + if not isinstance(access_method, ObjectIdentifier): + raise TypeError("access_method must be an ObjectIdentifier") + + if not isinstance(access_location, GeneralName): + raise TypeError("access_location must be a GeneralName") + + self._access_method = access_method + self._access_location = access_location + + def __repr__(self): + return ( + "<AccessDescription(access_method={0.access_method}, access_locati" + "on={0.access_location})>".format(self) + ) + + def __eq__(self, other): + if not isinstance(other, AccessDescription): + return NotImplemented + + return ( + self.access_method == other.access_method + and self.access_location == other.access_location + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.access_method, self.access_location)) + + access_method = utils.read_only_property("_access_method") + access_location = utils.read_only_property("_access_location") + + +@utils.register_interface(ExtensionType) +class BasicConstraints(object): + oid = ExtensionOID.BASIC_CONSTRAINTS + + def __init__(self, ca, path_length): + if not isinstance(ca, bool): + raise TypeError("ca must be a boolean value") + + if path_length is not None and not ca: + raise ValueError("path_length must be None when ca is False") + + if path_length is not None and ( + not isinstance(path_length, six.integer_types) or path_length < 0 + ): + raise TypeError( + "path_length must be a non-negative integer or None" + ) + + self._ca = ca + self._path_length = path_length + + ca = utils.read_only_property("_ca") + path_length = utils.read_only_property("_path_length") + + def __repr__(self): + return ( + "<BasicConstraints(ca={0.ca}, " "path_length={0.path_length})>" + ).format(self) + + def __eq__(self, other): + if not isinstance(other, BasicConstraints): + return NotImplemented + + return self.ca == other.ca and self.path_length == other.path_length + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.ca, self.path_length)) + + +@utils.register_interface(ExtensionType) +class DeltaCRLIndicator(object): + oid = ExtensionOID.DELTA_CRL_INDICATOR + + def __init__(self, crl_number): + if not isinstance(crl_number, six.integer_types): + raise TypeError("crl_number must be an integer") + + self._crl_number = crl_number + + crl_number = utils.read_only_property("_crl_number") + + def __eq__(self, other): + if not isinstance(other, DeltaCRLIndicator): + return NotImplemented + + return self.crl_number == other.crl_number + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.crl_number) + + def __repr__(self): + return "<DeltaCRLIndicator(crl_number={0.crl_number})>".format(self) + + +@utils.register_interface(ExtensionType) +class CRLDistributionPoints(object): + oid = ExtensionOID.CRL_DISTRIBUTION_POINTS + + def __init__(self, distribution_points): + distribution_points = list(distribution_points) + if not all( + isinstance(x, DistributionPoint) for x in distribution_points + ): + raise TypeError( + "distribution_points must be a list of DistributionPoint " + "objects" + ) + + self._distribution_points = distribution_points + + __len__, __iter__, __getitem__ = _make_sequence_methods( + "_distribution_points" + ) + + def __repr__(self): + return "<CRLDistributionPoints({})>".format(self._distribution_points) + + def __eq__(self, other): + if not isinstance(other, CRLDistributionPoints): + return NotImplemented + + return self._distribution_points == other._distribution_points + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(tuple(self._distribution_points)) + + +@utils.register_interface(ExtensionType) +class FreshestCRL(object): + oid = ExtensionOID.FRESHEST_CRL + + def __init__(self, distribution_points): + distribution_points = list(distribution_points) + if not all( + isinstance(x, DistributionPoint) for x in distribution_points + ): + raise TypeError( + "distribution_points must be a list of DistributionPoint " + "objects" + ) + + self._distribution_points = distribution_points + + __len__, __iter__, __getitem__ = _make_sequence_methods( + "_distribution_points" + ) + + def __repr__(self): + return "<FreshestCRL({})>".format(self._distribution_points) + + def __eq__(self, other): + if not isinstance(other, FreshestCRL): + return NotImplemented + + return self._distribution_points == other._distribution_points + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(tuple(self._distribution_points)) + + +class DistributionPoint(object): + def __init__(self, full_name, relative_name, reasons, crl_issuer): + if full_name and relative_name: + raise ValueError( + "You cannot provide both full_name and relative_name, at " + "least one must be None." + ) + + if full_name: + full_name = list(full_name) + if not all(isinstance(x, GeneralName) for x in full_name): + raise TypeError( + "full_name must be a list of GeneralName objects" + ) + + if relative_name: + if not isinstance(relative_name, RelativeDistinguishedName): + raise TypeError( + "relative_name must be a RelativeDistinguishedName" + ) + + if crl_issuer: + crl_issuer = list(crl_issuer) + if not all(isinstance(x, GeneralName) for x in crl_issuer): + raise TypeError( + "crl_issuer must be None or a list of general names" + ) + + if reasons and ( + not isinstance(reasons, frozenset) + or not all(isinstance(x, ReasonFlags) for x in reasons) + ): + raise TypeError("reasons must be None or frozenset of ReasonFlags") + + if reasons and ( + ReasonFlags.unspecified in reasons + or ReasonFlags.remove_from_crl in reasons + ): + raise ValueError( + "unspecified and remove_from_crl are not valid reasons in a " + "DistributionPoint" + ) + + if reasons and not crl_issuer and not (full_name or relative_name): + raise ValueError( + "You must supply crl_issuer, full_name, or relative_name when " + "reasons is not None" + ) + + self._full_name = full_name + self._relative_name = relative_name + self._reasons = reasons + self._crl_issuer = crl_issuer + + def __repr__(self): + return ( + "<DistributionPoint(full_name={0.full_name}, relative_name={0.rela" + "tive_name}, reasons={0.reasons}, " + "crl_issuer={0.crl_issuer})>".format(self) + ) + + def __eq__(self, other): + if not isinstance(other, DistributionPoint): + return NotImplemented + + return ( + self.full_name == other.full_name + and self.relative_name == other.relative_name + and self.reasons == other.reasons + and self.crl_issuer == other.crl_issuer + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + if self.full_name is not None: + fn = tuple(self.full_name) + else: + fn = None + + if self.crl_issuer is not None: + crl_issuer = tuple(self.crl_issuer) + else: + crl_issuer = None + + return hash((fn, self.relative_name, self.reasons, crl_issuer)) + + full_name = utils.read_only_property("_full_name") + relative_name = utils.read_only_property("_relative_name") + reasons = utils.read_only_property("_reasons") + crl_issuer = utils.read_only_property("_crl_issuer") + + +class ReasonFlags(Enum): + unspecified = "unspecified" + key_compromise = "keyCompromise" + ca_compromise = "cACompromise" + affiliation_changed = "affiliationChanged" + superseded = "superseded" + cessation_of_operation = "cessationOfOperation" + certificate_hold = "certificateHold" + privilege_withdrawn = "privilegeWithdrawn" + aa_compromise = "aACompromise" + remove_from_crl = "removeFromCRL" + + +@utils.register_interface(ExtensionType) +class PolicyConstraints(object): + oid = ExtensionOID.POLICY_CONSTRAINTS + + def __init__(self, require_explicit_policy, inhibit_policy_mapping): + if require_explicit_policy is not None and not isinstance( + require_explicit_policy, six.integer_types + ): + raise TypeError( + "require_explicit_policy must be a non-negative integer or " + "None" + ) + + if inhibit_policy_mapping is not None and not isinstance( + inhibit_policy_mapping, six.integer_types + ): + raise TypeError( + "inhibit_policy_mapping must be a non-negative integer or None" + ) + + if inhibit_policy_mapping is None and require_explicit_policy is None: + raise ValueError( + "At least one of require_explicit_policy and " + "inhibit_policy_mapping must not be None" + ) + + self._require_explicit_policy = require_explicit_policy + self._inhibit_policy_mapping = inhibit_policy_mapping + + def __repr__(self): + return ( + u"<PolicyConstraints(require_explicit_policy={0.require_explicit" + u"_policy}, inhibit_policy_mapping={0.inhibit_policy_" + u"mapping})>".format(self) + ) + + def __eq__(self, other): + if not isinstance(other, PolicyConstraints): + return NotImplemented + + return ( + self.require_explicit_policy == other.require_explicit_policy + and self.inhibit_policy_mapping == other.inhibit_policy_mapping + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash( + (self.require_explicit_policy, self.inhibit_policy_mapping) + ) + + require_explicit_policy = utils.read_only_property( + "_require_explicit_policy" + ) + inhibit_policy_mapping = utils.read_only_property( + "_inhibit_policy_mapping" + ) + + +@utils.register_interface(ExtensionType) +class CertificatePolicies(object): + oid = ExtensionOID.CERTIFICATE_POLICIES + + def __init__(self, policies): + policies = list(policies) + if not all(isinstance(x, PolicyInformation) for x in policies): + raise TypeError( + "Every item in the policies list must be a " + "PolicyInformation" + ) + + self._policies = policies + + __len__, __iter__, __getitem__ = _make_sequence_methods("_policies") + + def __repr__(self): + return "<CertificatePolicies({})>".format(self._policies) + + def __eq__(self, other): + if not isinstance(other, CertificatePolicies): + return NotImplemented + + return self._policies == other._policies + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(tuple(self._policies)) + + +class PolicyInformation(object): + def __init__(self, policy_identifier, policy_qualifiers): + if not isinstance(policy_identifier, ObjectIdentifier): + raise TypeError("policy_identifier must be an ObjectIdentifier") + + self._policy_identifier = policy_identifier + + if policy_qualifiers: + policy_qualifiers = list(policy_qualifiers) + if not all( + isinstance(x, (six.text_type, UserNotice)) + for x in policy_qualifiers + ): + raise TypeError( + "policy_qualifiers must be a list of strings and/or " + "UserNotice objects or None" + ) + + self._policy_qualifiers = policy_qualifiers + + def __repr__(self): + return ( + "<PolicyInformation(policy_identifier={0.policy_identifier}, polic" + "y_qualifiers={0.policy_qualifiers})>".format(self) + ) + + def __eq__(self, other): + if not isinstance(other, PolicyInformation): + return NotImplemented + + return ( + self.policy_identifier == other.policy_identifier + and self.policy_qualifiers == other.policy_qualifiers + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + if self.policy_qualifiers is not None: + pq = tuple(self.policy_qualifiers) + else: + pq = None + + return hash((self.policy_identifier, pq)) + + policy_identifier = utils.read_only_property("_policy_identifier") + policy_qualifiers = utils.read_only_property("_policy_qualifiers") + + +class UserNotice(object): + def __init__(self, notice_reference, explicit_text): + if notice_reference and not isinstance( + notice_reference, NoticeReference + ): + raise TypeError( + "notice_reference must be None or a NoticeReference" + ) + + self._notice_reference = notice_reference + self._explicit_text = explicit_text + + def __repr__(self): + return ( + "<UserNotice(notice_reference={0.notice_reference}, explicit_text=" + "{0.explicit_text!r})>".format(self) + ) + + def __eq__(self, other): + if not isinstance(other, UserNotice): + return NotImplemented + + return ( + self.notice_reference == other.notice_reference + and self.explicit_text == other.explicit_text + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.notice_reference, self.explicit_text)) + + notice_reference = utils.read_only_property("_notice_reference") + explicit_text = utils.read_only_property("_explicit_text") + + +class NoticeReference(object): + def __init__(self, organization, notice_numbers): + self._organization = organization + notice_numbers = list(notice_numbers) + if not all(isinstance(x, int) for x in notice_numbers): + raise TypeError("notice_numbers must be a list of integers") + + self._notice_numbers = notice_numbers + + def __repr__(self): + return ( + "<NoticeReference(organization={0.organization!r}, notice_numbers=" + "{0.notice_numbers})>".format(self) + ) + + def __eq__(self, other): + if not isinstance(other, NoticeReference): + return NotImplemented + + return ( + self.organization == other.organization + and self.notice_numbers == other.notice_numbers + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.organization, tuple(self.notice_numbers))) + + organization = utils.read_only_property("_organization") + notice_numbers = utils.read_only_property("_notice_numbers") + + +@utils.register_interface(ExtensionType) +class ExtendedKeyUsage(object): + oid = ExtensionOID.EXTENDED_KEY_USAGE + + def __init__(self, usages): + usages = list(usages) + if not all(isinstance(x, ObjectIdentifier) for x in usages): + raise TypeError( + "Every item in the usages list must be an ObjectIdentifier" + ) + + self._usages = usages + + __len__, __iter__, __getitem__ = _make_sequence_methods("_usages") + + def __repr__(self): + return "<ExtendedKeyUsage({})>".format(self._usages) + + def __eq__(self, other): + if not isinstance(other, ExtendedKeyUsage): + return NotImplemented + + return self._usages == other._usages + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(tuple(self._usages)) + + +@utils.register_interface(ExtensionType) +class OCSPNoCheck(object): + oid = ExtensionOID.OCSP_NO_CHECK + + def __eq__(self, other): + if not isinstance(other, OCSPNoCheck): + return NotImplemented + + return True + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(OCSPNoCheck) + + def __repr__(self): + return "<OCSPNoCheck()>" + + +@utils.register_interface(ExtensionType) +class PrecertPoison(object): + oid = ExtensionOID.PRECERT_POISON + + def __eq__(self, other): + if not isinstance(other, PrecertPoison): + return NotImplemented + + return True + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(PrecertPoison) + + def __repr__(self): + return "<PrecertPoison()>" + + +@utils.register_interface(ExtensionType) +class TLSFeature(object): + oid = ExtensionOID.TLS_FEATURE + + def __init__(self, features): + features = list(features) + if ( + not all(isinstance(x, TLSFeatureType) for x in features) + or len(features) == 0 + ): + raise TypeError( + "features must be a list of elements from the TLSFeatureType " + "enum" + ) + + self._features = features + + __len__, __iter__, __getitem__ = _make_sequence_methods("_features") + + def __repr__(self): + return "<TLSFeature(features={0._features})>".format(self) + + def __eq__(self, other): + if not isinstance(other, TLSFeature): + return NotImplemented + + return self._features == other._features + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(tuple(self._features)) + + +class TLSFeatureType(Enum): + # status_request is defined in RFC 6066 and is used for what is commonly + # called OCSP Must-Staple when present in the TLS Feature extension in an + # X.509 certificate. + status_request = 5 + # status_request_v2 is defined in RFC 6961 and allows multiple OCSP + # responses to be provided. It is not currently in use by clients or + # servers. + status_request_v2 = 17 + + +_TLS_FEATURE_TYPE_TO_ENUM = {x.value: x for x in TLSFeatureType} + + +@utils.register_interface(ExtensionType) +class InhibitAnyPolicy(object): + oid = ExtensionOID.INHIBIT_ANY_POLICY + + def __init__(self, skip_certs): + if not isinstance(skip_certs, six.integer_types): + raise TypeError("skip_certs must be an integer") + + if skip_certs < 0: + raise ValueError("skip_certs must be a non-negative integer") + + self._skip_certs = skip_certs + + def __repr__(self): + return "<InhibitAnyPolicy(skip_certs={0.skip_certs})>".format(self) + + def __eq__(self, other): + if not isinstance(other, InhibitAnyPolicy): + return NotImplemented + + return self.skip_certs == other.skip_certs + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.skip_certs) + + skip_certs = utils.read_only_property("_skip_certs") + + +@utils.register_interface(ExtensionType) +class KeyUsage(object): + oid = ExtensionOID.KEY_USAGE + + def __init__( + self, + digital_signature, + content_commitment, + key_encipherment, + data_encipherment, + key_agreement, + key_cert_sign, + crl_sign, + encipher_only, + decipher_only, + ): + if not key_agreement and (encipher_only or decipher_only): + raise ValueError( + "encipher_only and decipher_only can only be true when " + "key_agreement is true" + ) + + self._digital_signature = digital_signature + self._content_commitment = content_commitment + self._key_encipherment = key_encipherment + self._data_encipherment = data_encipherment + self._key_agreement = key_agreement + self._key_cert_sign = key_cert_sign + self._crl_sign = crl_sign + self._encipher_only = encipher_only + self._decipher_only = decipher_only + + digital_signature = utils.read_only_property("_digital_signature") + content_commitment = utils.read_only_property("_content_commitment") + key_encipherment = utils.read_only_property("_key_encipherment") + data_encipherment = utils.read_only_property("_data_encipherment") + key_agreement = utils.read_only_property("_key_agreement") + key_cert_sign = utils.read_only_property("_key_cert_sign") + crl_sign = utils.read_only_property("_crl_sign") + + @property + def encipher_only(self): + if not self.key_agreement: + raise ValueError( + "encipher_only is undefined unless key_agreement is true" + ) + else: + return self._encipher_only + + @property + def decipher_only(self): + if not self.key_agreement: + raise ValueError( + "decipher_only is undefined unless key_agreement is true" + ) + else: + return self._decipher_only + + def __repr__(self): + try: + encipher_only = self.encipher_only + decipher_only = self.decipher_only + except ValueError: + # Users found None confusing because even though encipher/decipher + # have no meaning unless key_agreement is true, to construct an + # instance of the class you still need to pass False. + encipher_only = False + decipher_only = False + + return ( + "<KeyUsage(digital_signature={0.digital_signature}, " + "content_commitment={0.content_commitment}, " + "key_encipherment={0.key_encipherment}, " + "data_encipherment={0.data_encipherment}, " + "key_agreement={0.key_agreement}, " + "key_cert_sign={0.key_cert_sign}, crl_sign={0.crl_sign}, " + "encipher_only={1}, decipher_only={2})>" + ).format(self, encipher_only, decipher_only) + + def __eq__(self, other): + if not isinstance(other, KeyUsage): + return NotImplemented + + return ( + self.digital_signature == other.digital_signature + and self.content_commitment == other.content_commitment + and self.key_encipherment == other.key_encipherment + and self.data_encipherment == other.data_encipherment + and self.key_agreement == other.key_agreement + and self.key_cert_sign == other.key_cert_sign + and self.crl_sign == other.crl_sign + and self._encipher_only == other._encipher_only + and self._decipher_only == other._decipher_only + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash( + ( + self.digital_signature, + self.content_commitment, + self.key_encipherment, + self.data_encipherment, + self.key_agreement, + self.key_cert_sign, + self.crl_sign, + self._encipher_only, + self._decipher_only, + ) + ) + + +@utils.register_interface(ExtensionType) +class NameConstraints(object): + oid = ExtensionOID.NAME_CONSTRAINTS + + def __init__(self, permitted_subtrees, excluded_subtrees): + if permitted_subtrees is not None: + permitted_subtrees = list(permitted_subtrees) + if not all(isinstance(x, GeneralName) for x in permitted_subtrees): + raise TypeError( + "permitted_subtrees must be a list of GeneralName objects " + "or None" + ) + + self._validate_ip_name(permitted_subtrees) + + if excluded_subtrees is not None: + excluded_subtrees = list(excluded_subtrees) + if not all(isinstance(x, GeneralName) for x in excluded_subtrees): + raise TypeError( + "excluded_subtrees must be a list of GeneralName objects " + "or None" + ) + + self._validate_ip_name(excluded_subtrees) + + if permitted_subtrees is None and excluded_subtrees is None: + raise ValueError( + "At least one of permitted_subtrees and excluded_subtrees " + "must not be None" + ) + + self._permitted_subtrees = permitted_subtrees + self._excluded_subtrees = excluded_subtrees + + def __eq__(self, other): + if not isinstance(other, NameConstraints): + return NotImplemented + + return ( + self.excluded_subtrees == other.excluded_subtrees + and self.permitted_subtrees == other.permitted_subtrees + ) + + def __ne__(self, other): + return not self == other + + def _validate_ip_name(self, tree): + if any( + isinstance(name, IPAddress) + and not isinstance( + name.value, (ipaddress.IPv4Network, ipaddress.IPv6Network) + ) + for name in tree + ): + raise TypeError( + "IPAddress name constraints must be an IPv4Network or" + " IPv6Network object" + ) + + def __repr__(self): + return ( + u"<NameConstraints(permitted_subtrees={0.permitted_subtrees}, " + u"excluded_subtrees={0.excluded_subtrees})>".format(self) + ) + + def __hash__(self): + if self.permitted_subtrees is not None: + ps = tuple(self.permitted_subtrees) + else: + ps = None + + if self.excluded_subtrees is not None: + es = tuple(self.excluded_subtrees) + else: + es = None + + return hash((ps, es)) + + permitted_subtrees = utils.read_only_property("_permitted_subtrees") + excluded_subtrees = utils.read_only_property("_excluded_subtrees") + + +class Extension(object): + def __init__(self, oid, critical, value): + if not isinstance(oid, ObjectIdentifier): + raise TypeError( + "oid argument must be an ObjectIdentifier instance." + ) + + if not isinstance(critical, bool): + raise TypeError("critical must be a boolean value") + + self._oid = oid + self._critical = critical + self._value = value + + oid = utils.read_only_property("_oid") + critical = utils.read_only_property("_critical") + value = utils.read_only_property("_value") + + def __repr__(self): + return ( + "<Extension(oid={0.oid}, critical={0.critical}, " + "value={0.value})>" + ).format(self) + + def __eq__(self, other): + if not isinstance(other, Extension): + return NotImplemented + + return ( + self.oid == other.oid + and self.critical == other.critical + and self.value == other.value + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.oid, self.critical, self.value)) + + +class GeneralNames(object): + def __init__(self, general_names): + general_names = list(general_names) + if not all(isinstance(x, GeneralName) for x in general_names): + raise TypeError( + "Every item in the general_names list must be an " + "object conforming to the GeneralName interface" + ) + + self._general_names = general_names + + __len__, __iter__, __getitem__ = _make_sequence_methods("_general_names") + + def get_values_for_type(self, type): + # Return the value of each GeneralName, except for OtherName instances + # which we return directly because it has two important properties not + # just one value. + objs = (i for i in self if isinstance(i, type)) + if type != OtherName: + objs = (i.value for i in objs) + return list(objs) + + def __repr__(self): + return "<GeneralNames({})>".format(self._general_names) + + def __eq__(self, other): + if not isinstance(other, GeneralNames): + return NotImplemented + + return self._general_names == other._general_names + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(tuple(self._general_names)) + + +@utils.register_interface(ExtensionType) +class SubjectAlternativeName(object): + oid = ExtensionOID.SUBJECT_ALTERNATIVE_NAME + + def __init__(self, general_names): + self._general_names = GeneralNames(general_names) + + __len__, __iter__, __getitem__ = _make_sequence_methods("_general_names") + + def get_values_for_type(self, type): + return self._general_names.get_values_for_type(type) + + def __repr__(self): + return "<SubjectAlternativeName({})>".format(self._general_names) + + def __eq__(self, other): + if not isinstance(other, SubjectAlternativeName): + return NotImplemented + + return self._general_names == other._general_names + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self._general_names) + + +@utils.register_interface(ExtensionType) +class IssuerAlternativeName(object): + oid = ExtensionOID.ISSUER_ALTERNATIVE_NAME + + def __init__(self, general_names): + self._general_names = GeneralNames(general_names) + + __len__, __iter__, __getitem__ = _make_sequence_methods("_general_names") + + def get_values_for_type(self, type): + return self._general_names.get_values_for_type(type) + + def __repr__(self): + return "<IssuerAlternativeName({})>".format(self._general_names) + + def __eq__(self, other): + if not isinstance(other, IssuerAlternativeName): + return NotImplemented + + return self._general_names == other._general_names + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self._general_names) + + +@utils.register_interface(ExtensionType) +class CertificateIssuer(object): + oid = CRLEntryExtensionOID.CERTIFICATE_ISSUER + + def __init__(self, general_names): + self._general_names = GeneralNames(general_names) + + __len__, __iter__, __getitem__ = _make_sequence_methods("_general_names") + + def get_values_for_type(self, type): + return self._general_names.get_values_for_type(type) + + def __repr__(self): + return "<CertificateIssuer({})>".format(self._general_names) + + def __eq__(self, other): + if not isinstance(other, CertificateIssuer): + return NotImplemented + + return self._general_names == other._general_names + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self._general_names) + + +@utils.register_interface(ExtensionType) +class CRLReason(object): + oid = CRLEntryExtensionOID.CRL_REASON + + def __init__(self, reason): + if not isinstance(reason, ReasonFlags): + raise TypeError("reason must be an element from ReasonFlags") + + self._reason = reason + + def __repr__(self): + return "<CRLReason(reason={})>".format(self._reason) + + def __eq__(self, other): + if not isinstance(other, CRLReason): + return NotImplemented + + return self.reason == other.reason + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.reason) + + reason = utils.read_only_property("_reason") + + +@utils.register_interface(ExtensionType) +class InvalidityDate(object): + oid = CRLEntryExtensionOID.INVALIDITY_DATE + + def __init__(self, invalidity_date): + if not isinstance(invalidity_date, datetime.datetime): + raise TypeError("invalidity_date must be a datetime.datetime") + + self._invalidity_date = invalidity_date + + def __repr__(self): + return "<InvalidityDate(invalidity_date={})>".format( + self._invalidity_date + ) + + def __eq__(self, other): + if not isinstance(other, InvalidityDate): + return NotImplemented + + return self.invalidity_date == other.invalidity_date + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.invalidity_date) + + invalidity_date = utils.read_only_property("_invalidity_date") + + +@utils.register_interface(ExtensionType) +class PrecertificateSignedCertificateTimestamps(object): + oid = ExtensionOID.PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS + + def __init__(self, signed_certificate_timestamps): + signed_certificate_timestamps = list(signed_certificate_timestamps) + if not all( + isinstance(sct, SignedCertificateTimestamp) + for sct in signed_certificate_timestamps + ): + raise TypeError( + "Every item in the signed_certificate_timestamps list must be " + "a SignedCertificateTimestamp" + ) + self._signed_certificate_timestamps = signed_certificate_timestamps + + __len__, __iter__, __getitem__ = _make_sequence_methods( + "_signed_certificate_timestamps" + ) + + def __repr__(self): + return "<PrecertificateSignedCertificateTimestamps({})>".format( + list(self) + ) + + def __hash__(self): + return hash(tuple(self._signed_certificate_timestamps)) + + def __eq__(self, other): + if not isinstance(other, PrecertificateSignedCertificateTimestamps): + return NotImplemented + + return ( + self._signed_certificate_timestamps + == other._signed_certificate_timestamps + ) + + def __ne__(self, other): + return not self == other + + +@utils.register_interface(ExtensionType) +class SignedCertificateTimestamps(object): + oid = ExtensionOID.SIGNED_CERTIFICATE_TIMESTAMPS + + def __init__(self, signed_certificate_timestamps): + signed_certificate_timestamps = list(signed_certificate_timestamps) + if not all( + isinstance(sct, SignedCertificateTimestamp) + for sct in signed_certificate_timestamps + ): + raise TypeError( + "Every item in the signed_certificate_timestamps list must be " + "a SignedCertificateTimestamp" + ) + self._signed_certificate_timestamps = signed_certificate_timestamps + + __len__, __iter__, __getitem__ = _make_sequence_methods( + "_signed_certificate_timestamps" + ) + + def __repr__(self): + return "<SignedCertificateTimestamps({})>".format(list(self)) + + def __hash__(self): + return hash(tuple(self._signed_certificate_timestamps)) + + def __eq__(self, other): + if not isinstance(other, SignedCertificateTimestamps): + return NotImplemented + + return ( + self._signed_certificate_timestamps + == other._signed_certificate_timestamps + ) + + def __ne__(self, other): + return not self == other + + +@utils.register_interface(ExtensionType) +class OCSPNonce(object): + oid = OCSPExtensionOID.NONCE + + def __init__(self, nonce): + if not isinstance(nonce, bytes): + raise TypeError("nonce must be bytes") + + self._nonce = nonce + + def __eq__(self, other): + if not isinstance(other, OCSPNonce): + return NotImplemented + + return self.nonce == other.nonce + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.nonce) + + def __repr__(self): + return "<OCSPNonce(nonce={0.nonce!r})>".format(self) + + nonce = utils.read_only_property("_nonce") + + +@utils.register_interface(ExtensionType) +class IssuingDistributionPoint(object): + oid = ExtensionOID.ISSUING_DISTRIBUTION_POINT + + def __init__( + self, + full_name, + relative_name, + only_contains_user_certs, + only_contains_ca_certs, + only_some_reasons, + indirect_crl, + only_contains_attribute_certs, + ): + if only_some_reasons and ( + not isinstance(only_some_reasons, frozenset) + or not all(isinstance(x, ReasonFlags) for x in only_some_reasons) + ): + raise TypeError( + "only_some_reasons must be None or frozenset of ReasonFlags" + ) + + if only_some_reasons and ( + ReasonFlags.unspecified in only_some_reasons + or ReasonFlags.remove_from_crl in only_some_reasons + ): + raise ValueError( + "unspecified and remove_from_crl are not valid reasons in an " + "IssuingDistributionPoint" + ) + + if not ( + isinstance(only_contains_user_certs, bool) + and isinstance(only_contains_ca_certs, bool) + and isinstance(indirect_crl, bool) + and isinstance(only_contains_attribute_certs, bool) + ): + raise TypeError( + "only_contains_user_certs, only_contains_ca_certs, " + "indirect_crl and only_contains_attribute_certs " + "must all be boolean." + ) + + crl_constraints = [ + only_contains_user_certs, + only_contains_ca_certs, + indirect_crl, + only_contains_attribute_certs, + ] + + if len([x for x in crl_constraints if x]) > 1: + raise ValueError( + "Only one of the following can be set to True: " + "only_contains_user_certs, only_contains_ca_certs, " + "indirect_crl, only_contains_attribute_certs" + ) + + if not any( + [ + only_contains_user_certs, + only_contains_ca_certs, + indirect_crl, + only_contains_attribute_certs, + full_name, + relative_name, + only_some_reasons, + ] + ): + raise ValueError( + "Cannot create empty extension: " + "if only_contains_user_certs, only_contains_ca_certs, " + "indirect_crl, and only_contains_attribute_certs are all False" + ", then either full_name, relative_name, or only_some_reasons " + "must have a value." + ) + + self._only_contains_user_certs = only_contains_user_certs + self._only_contains_ca_certs = only_contains_ca_certs + self._indirect_crl = indirect_crl + self._only_contains_attribute_certs = only_contains_attribute_certs + self._only_some_reasons = only_some_reasons + self._full_name = full_name + self._relative_name = relative_name + + def __repr__(self): + return ( + "<IssuingDistributionPoint(full_name={0.full_name}, " + "relative_name={0.relative_name}, " + "only_contains_user_certs={0.only_contains_user_certs}, " + "only_contains_ca_certs={0.only_contains_ca_certs}, " + "only_some_reasons={0.only_some_reasons}, " + "indirect_crl={0.indirect_crl}, " + "only_contains_attribute_certs=" + "{0.only_contains_attribute_certs})>".format(self) + ) + + def __eq__(self, other): + if not isinstance(other, IssuingDistributionPoint): + return NotImplemented + + return ( + self.full_name == other.full_name + and self.relative_name == other.relative_name + and self.only_contains_user_certs == other.only_contains_user_certs + and self.only_contains_ca_certs == other.only_contains_ca_certs + and self.only_some_reasons == other.only_some_reasons + and self.indirect_crl == other.indirect_crl + and self.only_contains_attribute_certs + == other.only_contains_attribute_certs + ) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash( + ( + self.full_name, + self.relative_name, + self.only_contains_user_certs, + self.only_contains_ca_certs, + self.only_some_reasons, + self.indirect_crl, + self.only_contains_attribute_certs, + ) + ) + + full_name = utils.read_only_property("_full_name") + relative_name = utils.read_only_property("_relative_name") + only_contains_user_certs = utils.read_only_property( + "_only_contains_user_certs" + ) + only_contains_ca_certs = utils.read_only_property( + "_only_contains_ca_certs" + ) + only_some_reasons = utils.read_only_property("_only_some_reasons") + indirect_crl = utils.read_only_property("_indirect_crl") + only_contains_attribute_certs = utils.read_only_property( + "_only_contains_attribute_certs" + ) + + +@utils.register_interface(ExtensionType) +class UnrecognizedExtension(object): + def __init__(self, oid, value): + if not isinstance(oid, ObjectIdentifier): + raise TypeError("oid must be an ObjectIdentifier") + self._oid = oid + self._value = value + + oid = utils.read_only_property("_oid") + value = utils.read_only_property("_value") + + def __repr__(self): + return ( + "<UnrecognizedExtension(oid={0.oid}, " + "value={0.value!r})>".format(self) + ) + + def __eq__(self, other): + if not isinstance(other, UnrecognizedExtension): + return NotImplemented + + return self.oid == other.oid and self.value == other.value + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.oid, self.value)) diff --git a/contrib/python/cryptography/py3/cryptography/x509/general_name.py b/contrib/python/cryptography/py3/cryptography/x509/general_name.py new file mode 100644 index 0000000000..9be9d8c991 --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/x509/general_name.py @@ -0,0 +1,294 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc +import ipaddress +from email.utils import parseaddr + +import six + +from cryptography import utils +from cryptography.x509.name import Name +from cryptography.x509.oid import ObjectIdentifier + + +_GENERAL_NAMES = { + 0: "otherName", + 1: "rfc822Name", + 2: "dNSName", + 3: "x400Address", + 4: "directoryName", + 5: "ediPartyName", + 6: "uniformResourceIdentifier", + 7: "iPAddress", + 8: "registeredID", +} + + +class UnsupportedGeneralNameType(Exception): + def __init__(self, msg, type): + super(UnsupportedGeneralNameType, self).__init__(msg) + self.type = type + + +@six.add_metaclass(abc.ABCMeta) +class GeneralName(object): + @abc.abstractproperty + def value(self): + """ + Return the value of the object + """ + + +@utils.register_interface(GeneralName) +class RFC822Name(object): + def __init__(self, value): + if isinstance(value, six.text_type): + try: + value.encode("ascii") + except UnicodeEncodeError: + raise ValueError( + "RFC822Name values should be passed as an A-label string. " + "This means unicode characters should be encoded via " + "a library like idna." + ) + else: + raise TypeError("value must be string") + + name, address = parseaddr(value) + if name or not address: + # parseaddr has found a name (e.g. Name <email>) or the entire + # value is an empty string. + raise ValueError("Invalid rfc822name value") + + self._value = value + + value = utils.read_only_property("_value") + + @classmethod + def _init_without_validation(cls, value): + instance = cls.__new__(cls) + instance._value = value + return instance + + def __repr__(self): + return "<RFC822Name(value={0!r})>".format(self.value) + + def __eq__(self, other): + if not isinstance(other, RFC822Name): + return NotImplemented + + return self.value == other.value + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.value) + + +@utils.register_interface(GeneralName) +class DNSName(object): + def __init__(self, value): + if isinstance(value, six.text_type): + try: + value.encode("ascii") + except UnicodeEncodeError: + raise ValueError( + "DNSName values should be passed as an A-label string. " + "This means unicode characters should be encoded via " + "a library like idna." + ) + else: + raise TypeError("value must be string") + + self._value = value + + value = utils.read_only_property("_value") + + @classmethod + def _init_without_validation(cls, value): + instance = cls.__new__(cls) + instance._value = value + return instance + + def __repr__(self): + return "<DNSName(value={0!r})>".format(self.value) + + def __eq__(self, other): + if not isinstance(other, DNSName): + return NotImplemented + + return self.value == other.value + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.value) + + +@utils.register_interface(GeneralName) +class UniformResourceIdentifier(object): + def __init__(self, value): + if isinstance(value, six.text_type): + try: + value.encode("ascii") + except UnicodeEncodeError: + raise ValueError( + "URI values should be passed as an A-label string. " + "This means unicode characters should be encoded via " + "a library like idna." + ) + else: + raise TypeError("value must be string") + + self._value = value + + value = utils.read_only_property("_value") + + @classmethod + def _init_without_validation(cls, value): + instance = cls.__new__(cls) + instance._value = value + return instance + + def __repr__(self): + return "<UniformResourceIdentifier(value={0!r})>".format(self.value) + + def __eq__(self, other): + if not isinstance(other, UniformResourceIdentifier): + return NotImplemented + + return self.value == other.value + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.value) + + +@utils.register_interface(GeneralName) +class DirectoryName(object): + def __init__(self, value): + if not isinstance(value, Name): + raise TypeError("value must be a Name") + + self._value = value + + value = utils.read_only_property("_value") + + def __repr__(self): + return "<DirectoryName(value={})>".format(self.value) + + def __eq__(self, other): + if not isinstance(other, DirectoryName): + return NotImplemented + + return self.value == other.value + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.value) + + +@utils.register_interface(GeneralName) +class RegisteredID(object): + def __init__(self, value): + if not isinstance(value, ObjectIdentifier): + raise TypeError("value must be an ObjectIdentifier") + + self._value = value + + value = utils.read_only_property("_value") + + def __repr__(self): + return "<RegisteredID(value={})>".format(self.value) + + def __eq__(self, other): + if not isinstance(other, RegisteredID): + return NotImplemented + + return self.value == other.value + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.value) + + +@utils.register_interface(GeneralName) +class IPAddress(object): + def __init__(self, value): + if not isinstance( + value, + ( + ipaddress.IPv4Address, + ipaddress.IPv6Address, + ipaddress.IPv4Network, + ipaddress.IPv6Network, + ), + ): + raise TypeError( + "value must be an instance of ipaddress.IPv4Address, " + "ipaddress.IPv6Address, ipaddress.IPv4Network, or " + "ipaddress.IPv6Network" + ) + + self._value = value + + value = utils.read_only_property("_value") + + def __repr__(self): + return "<IPAddress(value={})>".format(self.value) + + def __eq__(self, other): + if not isinstance(other, IPAddress): + return NotImplemented + + return self.value == other.value + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self.value) + + +@utils.register_interface(GeneralName) +class OtherName(object): + def __init__(self, type_id, value): + if not isinstance(type_id, ObjectIdentifier): + raise TypeError("type_id must be an ObjectIdentifier") + if not isinstance(value, bytes): + raise TypeError("value must be a binary string") + + self._type_id = type_id + self._value = value + + type_id = utils.read_only_property("_type_id") + value = utils.read_only_property("_value") + + def __repr__(self): + return "<OtherName(type_id={}, value={!r})>".format( + self.type_id, self.value + ) + + def __eq__(self, other): + if not isinstance(other, OtherName): + return NotImplemented + + return self.type_id == other.type_id and self.value == other.value + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.type_id, self.value)) diff --git a/contrib/python/cryptography/py3/cryptography/x509/name.py b/contrib/python/cryptography/py3/cryptography/x509/name.py new file mode 100644 index 0000000000..0be876a0ed --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/x509/name.py @@ -0,0 +1,261 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from enum import Enum + +import six + +from cryptography import utils +from cryptography.hazmat.backends import _get_backend +from cryptography.x509.oid import NameOID, ObjectIdentifier + + +class _ASN1Type(Enum): + UTF8String = 12 + NumericString = 18 + PrintableString = 19 + T61String = 20 + IA5String = 22 + UTCTime = 23 + GeneralizedTime = 24 + VisibleString = 26 + UniversalString = 28 + BMPString = 30 + + +_ASN1_TYPE_TO_ENUM = {i.value: i for i in _ASN1Type} +_SENTINEL = object() +_NAMEOID_DEFAULT_TYPE = { + NameOID.COUNTRY_NAME: _ASN1Type.PrintableString, + NameOID.JURISDICTION_COUNTRY_NAME: _ASN1Type.PrintableString, + NameOID.SERIAL_NUMBER: _ASN1Type.PrintableString, + NameOID.DN_QUALIFIER: _ASN1Type.PrintableString, + NameOID.EMAIL_ADDRESS: _ASN1Type.IA5String, + NameOID.DOMAIN_COMPONENT: _ASN1Type.IA5String, +} + +#: Short attribute names from RFC 4514: +#: https://tools.ietf.org/html/rfc4514#page-7 +_NAMEOID_TO_NAME = { + NameOID.COMMON_NAME: "CN", + NameOID.LOCALITY_NAME: "L", + NameOID.STATE_OR_PROVINCE_NAME: "ST", + NameOID.ORGANIZATION_NAME: "O", + NameOID.ORGANIZATIONAL_UNIT_NAME: "OU", + NameOID.COUNTRY_NAME: "C", + NameOID.STREET_ADDRESS: "STREET", + NameOID.DOMAIN_COMPONENT: "DC", + NameOID.USER_ID: "UID", +} + + +def _escape_dn_value(val): + """Escape special characters in RFC4514 Distinguished Name value.""" + + if not val: + return "" + + # See https://tools.ietf.org/html/rfc4514#section-2.4 + val = val.replace("\\", "\\\\") + val = val.replace('"', '\\"') + val = val.replace("+", "\\+") + val = val.replace(",", "\\,") + val = val.replace(";", "\\;") + val = val.replace("<", "\\<") + val = val.replace(">", "\\>") + val = val.replace("\0", "\\00") + + if val[0] in ("#", " "): + val = "\\" + val + if val[-1] == " ": + val = val[:-1] + "\\ " + + return val + + +class NameAttribute(object): + def __init__(self, oid, value, _type=_SENTINEL): + if not isinstance(oid, ObjectIdentifier): + raise TypeError( + "oid argument must be an ObjectIdentifier instance." + ) + + if not isinstance(value, six.text_type): + raise TypeError("value argument must be a text type.") + + if ( + oid == NameOID.COUNTRY_NAME + or oid == NameOID.JURISDICTION_COUNTRY_NAME + ): + if len(value.encode("utf8")) != 2: + raise ValueError( + "Country name must be a 2 character country code" + ) + + # The appropriate ASN1 string type varies by OID and is defined across + # multiple RFCs including 2459, 3280, and 5280. In general UTF8String + # is preferred (2459), but 3280 and 5280 specify several OIDs with + # alternate types. This means when we see the sentinel value we need + # to look up whether the OID has a non-UTF8 type. If it does, set it + # to that. Otherwise, UTF8! + if _type == _SENTINEL: + _type = _NAMEOID_DEFAULT_TYPE.get(oid, _ASN1Type.UTF8String) + + if not isinstance(_type, _ASN1Type): + raise TypeError("_type must be from the _ASN1Type enum") + + self._oid = oid + self._value = value + self._type = _type + + oid = utils.read_only_property("_oid") + value = utils.read_only_property("_value") + + def rfc4514_string(self): + """ + Format as RFC4514 Distinguished Name string. + + Use short attribute name if available, otherwise fall back to OID + dotted string. + """ + key = _NAMEOID_TO_NAME.get(self.oid, self.oid.dotted_string) + return "%s=%s" % (key, _escape_dn_value(self.value)) + + def __eq__(self, other): + if not isinstance(other, NameAttribute): + return NotImplemented + + return self.oid == other.oid and self.value == other.value + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.oid, self.value)) + + def __repr__(self): + return "<NameAttribute(oid={0.oid}, value={0.value!r})>".format(self) + + +class RelativeDistinguishedName(object): + def __init__(self, attributes): + attributes = list(attributes) + if not attributes: + raise ValueError("a relative distinguished name cannot be empty") + if not all(isinstance(x, NameAttribute) for x in attributes): + raise TypeError("attributes must be an iterable of NameAttribute") + + # Keep list and frozenset to preserve attribute order where it matters + self._attributes = attributes + self._attribute_set = frozenset(attributes) + + if len(self._attribute_set) != len(attributes): + raise ValueError("duplicate attributes are not allowed") + + def get_attributes_for_oid(self, oid): + return [i for i in self if i.oid == oid] + + def rfc4514_string(self): + """ + Format as RFC4514 Distinguished Name string. + + Within each RDN, attributes are joined by '+', although that is rarely + used in certificates. + """ + return "+".join(attr.rfc4514_string() for attr in self._attributes) + + def __eq__(self, other): + if not isinstance(other, RelativeDistinguishedName): + return NotImplemented + + return self._attribute_set == other._attribute_set + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash(self._attribute_set) + + def __iter__(self): + return iter(self._attributes) + + def __len__(self): + return len(self._attributes) + + def __repr__(self): + return "<RelativeDistinguishedName({})>".format(self.rfc4514_string()) + + +class Name(object): + def __init__(self, attributes): + attributes = list(attributes) + if all(isinstance(x, NameAttribute) for x in attributes): + self._attributes = [ + RelativeDistinguishedName([x]) for x in attributes + ] + elif all(isinstance(x, RelativeDistinguishedName) for x in attributes): + self._attributes = attributes + else: + raise TypeError( + "attributes must be a list of NameAttribute" + " or a list RelativeDistinguishedName" + ) + + def rfc4514_string(self): + """ + Format as RFC4514 Distinguished Name string. + For example 'CN=foobar.com,O=Foo Corp,C=US' + + An X.509 name is a two-level structure: a list of sets of attributes. + Each list element is separated by ',' and within each list element, set + elements are separated by '+'. The latter is almost never used in + real world certificates. According to RFC4514 section 2.1 the + RDNSequence must be reversed when converting to string representation. + """ + return ",".join( + attr.rfc4514_string() for attr in reversed(self._attributes) + ) + + def get_attributes_for_oid(self, oid): + return [i for i in self if i.oid == oid] + + @property + def rdns(self): + return self._attributes + + def public_bytes(self, backend=None): + backend = _get_backend(backend) + return backend.x509_name_bytes(self) + + def __eq__(self, other): + if not isinstance(other, Name): + return NotImplemented + + return self._attributes == other._attributes + + def __ne__(self, other): + return not self == other + + def __hash__(self): + # TODO: this is relatively expensive, if this looks like a bottleneck + # for you, consider optimizing! + return hash(tuple(self._attributes)) + + def __iter__(self): + for rdn in self._attributes: + for ava in rdn: + yield ava + + def __len__(self): + return sum(len(rdn) for rdn in self._attributes) + + def __repr__(self): + rdns = ",".join(attr.rfc4514_string() for attr in self._attributes) + + if six.PY2: + return "<Name({})>".format(rdns.encode("utf8")) + else: + return "<Name({})>".format(rdns) diff --git a/contrib/python/cryptography/py3/cryptography/x509/ocsp.py b/contrib/python/cryptography/py3/cryptography/x509/ocsp.py new file mode 100644 index 0000000000..f8e27224ec --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/x509/ocsp.py @@ -0,0 +1,467 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +import abc +import datetime +from enum import Enum + +import six + +from cryptography import x509 +from cryptography.hazmat.primitives import hashes +from cryptography.x509.base import ( + _EARLIEST_UTC_TIME, + _convert_to_naive_utc_time, + _reject_duplicate_extension, +) + + +_OIDS_TO_HASH = { + "1.3.14.3.2.26": hashes.SHA1(), + "2.16.840.1.101.3.4.2.4": hashes.SHA224(), + "2.16.840.1.101.3.4.2.1": hashes.SHA256(), + "2.16.840.1.101.3.4.2.2": hashes.SHA384(), + "2.16.840.1.101.3.4.2.3": hashes.SHA512(), +} + + +class OCSPResponderEncoding(Enum): + HASH = "By Hash" + NAME = "By Name" + + +class OCSPResponseStatus(Enum): + SUCCESSFUL = 0 + MALFORMED_REQUEST = 1 + INTERNAL_ERROR = 2 + TRY_LATER = 3 + SIG_REQUIRED = 5 + UNAUTHORIZED = 6 + + +_RESPONSE_STATUS_TO_ENUM = {x.value: x for x in OCSPResponseStatus} +_ALLOWED_HASHES = ( + hashes.SHA1, + hashes.SHA224, + hashes.SHA256, + hashes.SHA384, + hashes.SHA512, +) + + +def _verify_algorithm(algorithm): + if not isinstance(algorithm, _ALLOWED_HASHES): + raise ValueError( + "Algorithm must be SHA1, SHA224, SHA256, SHA384, or SHA512" + ) + + +class OCSPCertStatus(Enum): + GOOD = 0 + REVOKED = 1 + UNKNOWN = 2 + + +_CERT_STATUS_TO_ENUM = {x.value: x for x in OCSPCertStatus} + + +def load_der_ocsp_request(data): + from cryptography.hazmat.backends.openssl.backend import backend + + return backend.load_der_ocsp_request(data) + + +def load_der_ocsp_response(data): + from cryptography.hazmat.backends.openssl.backend import backend + + return backend.load_der_ocsp_response(data) + + +class OCSPRequestBuilder(object): + def __init__(self, request=None, extensions=[]): + self._request = request + self._extensions = extensions + + def add_certificate(self, cert, issuer, algorithm): + if self._request is not None: + raise ValueError("Only one certificate can be added to a request") + + _verify_algorithm(algorithm) + if not isinstance(cert, x509.Certificate) or not isinstance( + issuer, x509.Certificate + ): + raise TypeError("cert and issuer must be a Certificate") + + return OCSPRequestBuilder((cert, issuer, algorithm), self._extensions) + + def add_extension(self, extension, critical): + if not isinstance(extension, x509.ExtensionType): + raise TypeError("extension must be an ExtensionType") + + extension = x509.Extension(extension.oid, critical, extension) + _reject_duplicate_extension(extension, self._extensions) + + return OCSPRequestBuilder( + self._request, self._extensions + [extension] + ) + + def build(self): + from cryptography.hazmat.backends.openssl.backend import backend + + if self._request is None: + raise ValueError("You must add a certificate before building") + + return backend.create_ocsp_request(self) + + +class _SingleResponse(object): + def __init__( + self, + cert, + issuer, + algorithm, + cert_status, + this_update, + next_update, + revocation_time, + revocation_reason, + ): + if not isinstance(cert, x509.Certificate) or not isinstance( + issuer, x509.Certificate + ): + raise TypeError("cert and issuer must be a Certificate") + + _verify_algorithm(algorithm) + if not isinstance(this_update, datetime.datetime): + raise TypeError("this_update must be a datetime object") + if next_update is not None and not isinstance( + next_update, datetime.datetime + ): + raise TypeError("next_update must be a datetime object or None") + + self._cert = cert + self._issuer = issuer + self._algorithm = algorithm + self._this_update = this_update + self._next_update = next_update + + if not isinstance(cert_status, OCSPCertStatus): + raise TypeError( + "cert_status must be an item from the OCSPCertStatus enum" + ) + if cert_status is not OCSPCertStatus.REVOKED: + if revocation_time is not None: + raise ValueError( + "revocation_time can only be provided if the certificate " + "is revoked" + ) + if revocation_reason is not None: + raise ValueError( + "revocation_reason can only be provided if the certificate" + " is revoked" + ) + else: + if not isinstance(revocation_time, datetime.datetime): + raise TypeError("revocation_time must be a datetime object") + + revocation_time = _convert_to_naive_utc_time(revocation_time) + if revocation_time < _EARLIEST_UTC_TIME: + raise ValueError( + "The revocation_time must be on or after" + " 1950 January 1." + ) + + if revocation_reason is not None and not isinstance( + revocation_reason, x509.ReasonFlags + ): + raise TypeError( + "revocation_reason must be an item from the ReasonFlags " + "enum or None" + ) + + self._cert_status = cert_status + self._revocation_time = revocation_time + self._revocation_reason = revocation_reason + + +class OCSPResponseBuilder(object): + def __init__( + self, response=None, responder_id=None, certs=None, extensions=[] + ): + self._response = response + self._responder_id = responder_id + self._certs = certs + self._extensions = extensions + + def add_response( + self, + cert, + issuer, + algorithm, + cert_status, + this_update, + next_update, + revocation_time, + revocation_reason, + ): + if self._response is not None: + raise ValueError("Only one response per OCSPResponse.") + + singleresp = _SingleResponse( + cert, + issuer, + algorithm, + cert_status, + this_update, + next_update, + revocation_time, + revocation_reason, + ) + return OCSPResponseBuilder( + singleresp, + self._responder_id, + self._certs, + self._extensions, + ) + + def responder_id(self, encoding, responder_cert): + if self._responder_id is not None: + raise ValueError("responder_id can only be set once") + if not isinstance(responder_cert, x509.Certificate): + raise TypeError("responder_cert must be a Certificate") + if not isinstance(encoding, OCSPResponderEncoding): + raise TypeError( + "encoding must be an element from OCSPResponderEncoding" + ) + + return OCSPResponseBuilder( + self._response, + (responder_cert, encoding), + self._certs, + self._extensions, + ) + + def certificates(self, certs): + if self._certs is not None: + raise ValueError("certificates may only be set once") + certs = list(certs) + if len(certs) == 0: + raise ValueError("certs must not be an empty list") + if not all(isinstance(x, x509.Certificate) for x in certs): + raise TypeError("certs must be a list of Certificates") + return OCSPResponseBuilder( + self._response, + self._responder_id, + certs, + self._extensions, + ) + + def add_extension(self, extension, critical): + if not isinstance(extension, x509.ExtensionType): + raise TypeError("extension must be an ExtensionType") + + extension = x509.Extension(extension.oid, critical, extension) + _reject_duplicate_extension(extension, self._extensions) + + return OCSPResponseBuilder( + self._response, + self._responder_id, + self._certs, + self._extensions + [extension], + ) + + def sign(self, private_key, algorithm): + from cryptography.hazmat.backends.openssl.backend import backend + + if self._response is None: + raise ValueError("You must add a response before signing") + if self._responder_id is None: + raise ValueError("You must add a responder_id before signing") + + return backend.create_ocsp_response( + OCSPResponseStatus.SUCCESSFUL, self, private_key, algorithm + ) + + @classmethod + def build_unsuccessful(cls, response_status): + from cryptography.hazmat.backends.openssl.backend import backend + + if not isinstance(response_status, OCSPResponseStatus): + raise TypeError( + "response_status must be an item from OCSPResponseStatus" + ) + if response_status is OCSPResponseStatus.SUCCESSFUL: + raise ValueError("response_status cannot be SUCCESSFUL") + + return backend.create_ocsp_response(response_status, None, None, None) + + +@six.add_metaclass(abc.ABCMeta) +class OCSPRequest(object): + @abc.abstractproperty + def issuer_key_hash(self): + """ + The hash of the issuer public key + """ + + @abc.abstractproperty + def issuer_name_hash(self): + """ + The hash of the issuer name + """ + + @abc.abstractproperty + def hash_algorithm(self): + """ + The hash algorithm used in the issuer name and key hashes + """ + + @abc.abstractproperty + def serial_number(self): + """ + The serial number of the cert whose status is being checked + """ + + @abc.abstractmethod + def public_bytes(self, encoding): + """ + Serializes the request to DER + """ + + @abc.abstractproperty + def extensions(self): + """ + The list of request extensions. Not single request extensions. + """ + + +@six.add_metaclass(abc.ABCMeta) +class OCSPResponse(object): + @abc.abstractproperty + def response_status(self): + """ + The status of the response. This is a value from the OCSPResponseStatus + enumeration + """ + + @abc.abstractproperty + def signature_algorithm_oid(self): + """ + The ObjectIdentifier of the signature algorithm + """ + + @abc.abstractproperty + def signature_hash_algorithm(self): + """ + Returns a HashAlgorithm corresponding to the type of the digest signed + """ + + @abc.abstractproperty + def signature(self): + """ + The signature bytes + """ + + @abc.abstractproperty + def tbs_response_bytes(self): + """ + The tbsResponseData bytes + """ + + @abc.abstractproperty + def certificates(self): + """ + A list of certificates used to help build a chain to verify the OCSP + response. This situation occurs when the OCSP responder uses a delegate + certificate. + """ + + @abc.abstractproperty + def responder_key_hash(self): + """ + The responder's key hash or None + """ + + @abc.abstractproperty + def responder_name(self): + """ + The responder's Name or None + """ + + @abc.abstractproperty + def produced_at(self): + """ + The time the response was produced + """ + + @abc.abstractproperty + def certificate_status(self): + """ + The status of the certificate (an element from the OCSPCertStatus enum) + """ + + @abc.abstractproperty + def revocation_time(self): + """ + The date of when the certificate was revoked or None if not + revoked. + """ + + @abc.abstractproperty + def revocation_reason(self): + """ + The reason the certificate was revoked or None if not specified or + not revoked. + """ + + @abc.abstractproperty + def this_update(self): + """ + The most recent time at which the status being indicated is known by + the responder to have been correct + """ + + @abc.abstractproperty + def next_update(self): + """ + The time when newer information will be available + """ + + @abc.abstractproperty + def issuer_key_hash(self): + """ + The hash of the issuer public key + """ + + @abc.abstractproperty + def issuer_name_hash(self): + """ + The hash of the issuer name + """ + + @abc.abstractproperty + def hash_algorithm(self): + """ + The hash algorithm used in the issuer name and key hashes + """ + + @abc.abstractproperty + def serial_number(self): + """ + The serial number of the cert whose status is being checked + """ + + @abc.abstractproperty + def extensions(self): + """ + The list of response extensions. Not single response extensions. + """ + + @abc.abstractproperty + def single_extensions(self): + """ + The list of single response extensions. Not response extensions. + """ diff --git a/contrib/python/cryptography/py3/cryptography/x509/oid.py b/contrib/python/cryptography/py3/cryptography/x509/oid.py new file mode 100644 index 0000000000..2bf606e50d --- /dev/null +++ b/contrib/python/cryptography/py3/cryptography/x509/oid.py @@ -0,0 +1,265 @@ +# This file is dual licensed under the terms of the Apache License, Version +# 2.0, and the BSD License. See the LICENSE file in the root of this repository +# for complete details. + +from __future__ import absolute_import, division, print_function + +from cryptography.hazmat._oid import ObjectIdentifier +from cryptography.hazmat.primitives import hashes + + +class ExtensionOID(object): + SUBJECT_DIRECTORY_ATTRIBUTES = ObjectIdentifier("2.5.29.9") + SUBJECT_KEY_IDENTIFIER = ObjectIdentifier("2.5.29.14") + KEY_USAGE = ObjectIdentifier("2.5.29.15") + SUBJECT_ALTERNATIVE_NAME = ObjectIdentifier("2.5.29.17") + ISSUER_ALTERNATIVE_NAME = ObjectIdentifier("2.5.29.18") + BASIC_CONSTRAINTS = ObjectIdentifier("2.5.29.19") + NAME_CONSTRAINTS = ObjectIdentifier("2.5.29.30") + CRL_DISTRIBUTION_POINTS = ObjectIdentifier("2.5.29.31") + CERTIFICATE_POLICIES = ObjectIdentifier("2.5.29.32") + POLICY_MAPPINGS = ObjectIdentifier("2.5.29.33") + AUTHORITY_KEY_IDENTIFIER = ObjectIdentifier("2.5.29.35") + POLICY_CONSTRAINTS = ObjectIdentifier("2.5.29.36") + EXTENDED_KEY_USAGE = ObjectIdentifier("2.5.29.37") + FRESHEST_CRL = ObjectIdentifier("2.5.29.46") + INHIBIT_ANY_POLICY = ObjectIdentifier("2.5.29.54") + ISSUING_DISTRIBUTION_POINT = ObjectIdentifier("2.5.29.28") + AUTHORITY_INFORMATION_ACCESS = ObjectIdentifier("1.3.6.1.5.5.7.1.1") + SUBJECT_INFORMATION_ACCESS = ObjectIdentifier("1.3.6.1.5.5.7.1.11") + OCSP_NO_CHECK = ObjectIdentifier("1.3.6.1.5.5.7.48.1.5") + TLS_FEATURE = ObjectIdentifier("1.3.6.1.5.5.7.1.24") + CRL_NUMBER = ObjectIdentifier("2.5.29.20") + DELTA_CRL_INDICATOR = ObjectIdentifier("2.5.29.27") + PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS = ObjectIdentifier( + "1.3.6.1.4.1.11129.2.4.2" + ) + PRECERT_POISON = ObjectIdentifier("1.3.6.1.4.1.11129.2.4.3") + SIGNED_CERTIFICATE_TIMESTAMPS = ObjectIdentifier("1.3.6.1.4.1.11129.2.4.5") + + +class OCSPExtensionOID(object): + NONCE = ObjectIdentifier("1.3.6.1.5.5.7.48.1.2") + + +class CRLEntryExtensionOID(object): + CERTIFICATE_ISSUER = ObjectIdentifier("2.5.29.29") + CRL_REASON = ObjectIdentifier("2.5.29.21") + INVALIDITY_DATE = ObjectIdentifier("2.5.29.24") + + +class NameOID(object): + COMMON_NAME = ObjectIdentifier("2.5.4.3") + COUNTRY_NAME = ObjectIdentifier("2.5.4.6") + LOCALITY_NAME = ObjectIdentifier("2.5.4.7") + STATE_OR_PROVINCE_NAME = ObjectIdentifier("2.5.4.8") + STREET_ADDRESS = ObjectIdentifier("2.5.4.9") + ORGANIZATION_NAME = ObjectIdentifier("2.5.4.10") + ORGANIZATIONAL_UNIT_NAME = ObjectIdentifier("2.5.4.11") + SERIAL_NUMBER = ObjectIdentifier("2.5.4.5") + SURNAME = ObjectIdentifier("2.5.4.4") + GIVEN_NAME = ObjectIdentifier("2.5.4.42") + TITLE = ObjectIdentifier("2.5.4.12") + GENERATION_QUALIFIER = ObjectIdentifier("2.5.4.44") + X500_UNIQUE_IDENTIFIER = ObjectIdentifier("2.5.4.45") + DN_QUALIFIER = ObjectIdentifier("2.5.4.46") + PSEUDONYM = ObjectIdentifier("2.5.4.65") + USER_ID = ObjectIdentifier("0.9.2342.19200300.100.1.1") + DOMAIN_COMPONENT = ObjectIdentifier("0.9.2342.19200300.100.1.25") + EMAIL_ADDRESS = ObjectIdentifier("1.2.840.113549.1.9.1") + JURISDICTION_COUNTRY_NAME = ObjectIdentifier("1.3.6.1.4.1.311.60.2.1.3") + JURISDICTION_LOCALITY_NAME = ObjectIdentifier("1.3.6.1.4.1.311.60.2.1.1") + JURISDICTION_STATE_OR_PROVINCE_NAME = ObjectIdentifier( + "1.3.6.1.4.1.311.60.2.1.2" + ) + BUSINESS_CATEGORY = ObjectIdentifier("2.5.4.15") + POSTAL_ADDRESS = ObjectIdentifier("2.5.4.16") + POSTAL_CODE = ObjectIdentifier("2.5.4.17") + INN = ObjectIdentifier("1.2.643.3.131.1.1") + OGRN = ObjectIdentifier("1.2.643.100.1") + SNILS = ObjectIdentifier("1.2.643.100.3") + UNSTRUCTURED_NAME = ObjectIdentifier("1.2.840.113549.1.9.2") + + +class SignatureAlgorithmOID(object): + RSA_WITH_MD5 = ObjectIdentifier("1.2.840.113549.1.1.4") + RSA_WITH_SHA1 = ObjectIdentifier("1.2.840.113549.1.1.5") + # This is an alternate OID for RSA with SHA1 that is occasionally seen + _RSA_WITH_SHA1 = ObjectIdentifier("1.3.14.3.2.29") + RSA_WITH_SHA224 = ObjectIdentifier("1.2.840.113549.1.1.14") + RSA_WITH_SHA256 = ObjectIdentifier("1.2.840.113549.1.1.11") + RSA_WITH_SHA384 = ObjectIdentifier("1.2.840.113549.1.1.12") + RSA_WITH_SHA512 = ObjectIdentifier("1.2.840.113549.1.1.13") + RSASSA_PSS = ObjectIdentifier("1.2.840.113549.1.1.10") + ECDSA_WITH_SHA1 = ObjectIdentifier("1.2.840.10045.4.1") + ECDSA_WITH_SHA224 = ObjectIdentifier("1.2.840.10045.4.3.1") + ECDSA_WITH_SHA256 = ObjectIdentifier("1.2.840.10045.4.3.2") + ECDSA_WITH_SHA384 = ObjectIdentifier("1.2.840.10045.4.3.3") + ECDSA_WITH_SHA512 = ObjectIdentifier("1.2.840.10045.4.3.4") + DSA_WITH_SHA1 = ObjectIdentifier("1.2.840.10040.4.3") + DSA_WITH_SHA224 = ObjectIdentifier("2.16.840.1.101.3.4.3.1") + DSA_WITH_SHA256 = ObjectIdentifier("2.16.840.1.101.3.4.3.2") + ED25519 = ObjectIdentifier("1.3.101.112") + ED448 = ObjectIdentifier("1.3.101.113") + GOSTR3411_94_WITH_3410_2001 = ObjectIdentifier("1.2.643.2.2.3") + GOSTR3410_2012_WITH_3411_2012_256 = ObjectIdentifier("1.2.643.7.1.1.3.2") + GOSTR3410_2012_WITH_3411_2012_512 = ObjectIdentifier("1.2.643.7.1.1.3.3") + + +_SIG_OIDS_TO_HASH = { + SignatureAlgorithmOID.RSA_WITH_MD5: hashes.MD5(), + SignatureAlgorithmOID.RSA_WITH_SHA1: hashes.SHA1(), + SignatureAlgorithmOID._RSA_WITH_SHA1: hashes.SHA1(), + SignatureAlgorithmOID.RSA_WITH_SHA224: hashes.SHA224(), + SignatureAlgorithmOID.RSA_WITH_SHA256: hashes.SHA256(), + SignatureAlgorithmOID.RSA_WITH_SHA384: hashes.SHA384(), + SignatureAlgorithmOID.RSA_WITH_SHA512: hashes.SHA512(), + SignatureAlgorithmOID.ECDSA_WITH_SHA1: hashes.SHA1(), + SignatureAlgorithmOID.ECDSA_WITH_SHA224: hashes.SHA224(), + SignatureAlgorithmOID.ECDSA_WITH_SHA256: hashes.SHA256(), + SignatureAlgorithmOID.ECDSA_WITH_SHA384: hashes.SHA384(), + SignatureAlgorithmOID.ECDSA_WITH_SHA512: hashes.SHA512(), + SignatureAlgorithmOID.DSA_WITH_SHA1: hashes.SHA1(), + SignatureAlgorithmOID.DSA_WITH_SHA224: hashes.SHA224(), + SignatureAlgorithmOID.DSA_WITH_SHA256: hashes.SHA256(), + SignatureAlgorithmOID.ED25519: None, + SignatureAlgorithmOID.ED448: None, + SignatureAlgorithmOID.GOSTR3411_94_WITH_3410_2001: None, + SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_256: None, + SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_512: None, +} + + +class ExtendedKeyUsageOID(object): + SERVER_AUTH = ObjectIdentifier("1.3.6.1.5.5.7.3.1") + CLIENT_AUTH = ObjectIdentifier("1.3.6.1.5.5.7.3.2") + CODE_SIGNING = ObjectIdentifier("1.3.6.1.5.5.7.3.3") + EMAIL_PROTECTION = ObjectIdentifier("1.3.6.1.5.5.7.3.4") + TIME_STAMPING = ObjectIdentifier("1.3.6.1.5.5.7.3.8") + OCSP_SIGNING = ObjectIdentifier("1.3.6.1.5.5.7.3.9") + ANY_EXTENDED_KEY_USAGE = ObjectIdentifier("2.5.29.37.0") + + +class AuthorityInformationAccessOID(object): + CA_ISSUERS = ObjectIdentifier("1.3.6.1.5.5.7.48.2") + OCSP = ObjectIdentifier("1.3.6.1.5.5.7.48.1") + + +class SubjectInformationAccessOID(object): + CA_REPOSITORY = ObjectIdentifier("1.3.6.1.5.5.7.48.5") + + +class CertificatePoliciesOID(object): + CPS_QUALIFIER = ObjectIdentifier("1.3.6.1.5.5.7.2.1") + CPS_USER_NOTICE = ObjectIdentifier("1.3.6.1.5.5.7.2.2") + ANY_POLICY = ObjectIdentifier("2.5.29.32.0") + + +class AttributeOID(object): + CHALLENGE_PASSWORD = ObjectIdentifier("1.2.840.113549.1.9.7") + UNSTRUCTURED_NAME = ObjectIdentifier("1.2.840.113549.1.9.2") + + +_OID_NAMES = { + NameOID.COMMON_NAME: "commonName", + NameOID.COUNTRY_NAME: "countryName", + NameOID.LOCALITY_NAME: "localityName", + NameOID.STATE_OR_PROVINCE_NAME: "stateOrProvinceName", + NameOID.STREET_ADDRESS: "streetAddress", + NameOID.ORGANIZATION_NAME: "organizationName", + NameOID.ORGANIZATIONAL_UNIT_NAME: "organizationalUnitName", + NameOID.SERIAL_NUMBER: "serialNumber", + NameOID.SURNAME: "surname", + NameOID.GIVEN_NAME: "givenName", + NameOID.TITLE: "title", + NameOID.GENERATION_QUALIFIER: "generationQualifier", + NameOID.X500_UNIQUE_IDENTIFIER: "x500UniqueIdentifier", + NameOID.DN_QUALIFIER: "dnQualifier", + NameOID.PSEUDONYM: "pseudonym", + NameOID.USER_ID: "userID", + NameOID.DOMAIN_COMPONENT: "domainComponent", + NameOID.EMAIL_ADDRESS: "emailAddress", + NameOID.JURISDICTION_COUNTRY_NAME: "jurisdictionCountryName", + NameOID.JURISDICTION_LOCALITY_NAME: "jurisdictionLocalityName", + NameOID.JURISDICTION_STATE_OR_PROVINCE_NAME: ( + "jurisdictionStateOrProvinceName" + ), + NameOID.BUSINESS_CATEGORY: "businessCategory", + NameOID.POSTAL_ADDRESS: "postalAddress", + NameOID.POSTAL_CODE: "postalCode", + NameOID.INN: "INN", + NameOID.OGRN: "OGRN", + NameOID.SNILS: "SNILS", + NameOID.UNSTRUCTURED_NAME: "unstructuredName", + SignatureAlgorithmOID.RSA_WITH_MD5: "md5WithRSAEncryption", + SignatureAlgorithmOID.RSA_WITH_SHA1: "sha1WithRSAEncryption", + SignatureAlgorithmOID.RSA_WITH_SHA224: "sha224WithRSAEncryption", + SignatureAlgorithmOID.RSA_WITH_SHA256: "sha256WithRSAEncryption", + SignatureAlgorithmOID.RSA_WITH_SHA384: "sha384WithRSAEncryption", + SignatureAlgorithmOID.RSA_WITH_SHA512: "sha512WithRSAEncryption", + SignatureAlgorithmOID.RSASSA_PSS: "RSASSA-PSS", + SignatureAlgorithmOID.ECDSA_WITH_SHA1: "ecdsa-with-SHA1", + SignatureAlgorithmOID.ECDSA_WITH_SHA224: "ecdsa-with-SHA224", + SignatureAlgorithmOID.ECDSA_WITH_SHA256: "ecdsa-with-SHA256", + SignatureAlgorithmOID.ECDSA_WITH_SHA384: "ecdsa-with-SHA384", + SignatureAlgorithmOID.ECDSA_WITH_SHA512: "ecdsa-with-SHA512", + SignatureAlgorithmOID.DSA_WITH_SHA1: "dsa-with-sha1", + SignatureAlgorithmOID.DSA_WITH_SHA224: "dsa-with-sha224", + SignatureAlgorithmOID.DSA_WITH_SHA256: "dsa-with-sha256", + SignatureAlgorithmOID.ED25519: "ed25519", + SignatureAlgorithmOID.ED448: "ed448", + SignatureAlgorithmOID.GOSTR3411_94_WITH_3410_2001: ( + "GOST R 34.11-94 with GOST R 34.10-2001" + ), + SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_256: ( + "GOST R 34.10-2012 with GOST R 34.11-2012 (256 bit)" + ), + SignatureAlgorithmOID.GOSTR3410_2012_WITH_3411_2012_512: ( + "GOST R 34.10-2012 with GOST R 34.11-2012 (512 bit)" + ), + ExtendedKeyUsageOID.SERVER_AUTH: "serverAuth", + ExtendedKeyUsageOID.CLIENT_AUTH: "clientAuth", + ExtendedKeyUsageOID.CODE_SIGNING: "codeSigning", + ExtendedKeyUsageOID.EMAIL_PROTECTION: "emailProtection", + ExtendedKeyUsageOID.TIME_STAMPING: "timeStamping", + ExtendedKeyUsageOID.OCSP_SIGNING: "OCSPSigning", + ExtensionOID.SUBJECT_DIRECTORY_ATTRIBUTES: "subjectDirectoryAttributes", + ExtensionOID.SUBJECT_KEY_IDENTIFIER: "subjectKeyIdentifier", + ExtensionOID.KEY_USAGE: "keyUsage", + ExtensionOID.SUBJECT_ALTERNATIVE_NAME: "subjectAltName", + ExtensionOID.ISSUER_ALTERNATIVE_NAME: "issuerAltName", + ExtensionOID.BASIC_CONSTRAINTS: "basicConstraints", + ExtensionOID.PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS: ( + "signedCertificateTimestampList" + ), + ExtensionOID.SIGNED_CERTIFICATE_TIMESTAMPS: ( + "signedCertificateTimestampList" + ), + ExtensionOID.PRECERT_POISON: "ctPoison", + CRLEntryExtensionOID.CRL_REASON: "cRLReason", + CRLEntryExtensionOID.INVALIDITY_DATE: "invalidityDate", + CRLEntryExtensionOID.CERTIFICATE_ISSUER: "certificateIssuer", + ExtensionOID.NAME_CONSTRAINTS: "nameConstraints", + ExtensionOID.CRL_DISTRIBUTION_POINTS: "cRLDistributionPoints", + ExtensionOID.CERTIFICATE_POLICIES: "certificatePolicies", + ExtensionOID.POLICY_MAPPINGS: "policyMappings", + ExtensionOID.AUTHORITY_KEY_IDENTIFIER: "authorityKeyIdentifier", + ExtensionOID.POLICY_CONSTRAINTS: "policyConstraints", + ExtensionOID.EXTENDED_KEY_USAGE: "extendedKeyUsage", + ExtensionOID.FRESHEST_CRL: "freshestCRL", + ExtensionOID.INHIBIT_ANY_POLICY: "inhibitAnyPolicy", + ExtensionOID.ISSUING_DISTRIBUTION_POINT: ("issuingDistributionPoint"), + ExtensionOID.AUTHORITY_INFORMATION_ACCESS: "authorityInfoAccess", + ExtensionOID.SUBJECT_INFORMATION_ACCESS: "subjectInfoAccess", + ExtensionOID.OCSP_NO_CHECK: "OCSPNoCheck", + ExtensionOID.CRL_NUMBER: "cRLNumber", + ExtensionOID.DELTA_CRL_INDICATOR: "deltaCRLIndicator", + ExtensionOID.TLS_FEATURE: "TLSFeature", + AuthorityInformationAccessOID.OCSP: "OCSP", + AuthorityInformationAccessOID.CA_ISSUERS: "caIssuers", + SubjectInformationAccessOID.CA_REPOSITORY: "caRepository", + CertificatePoliciesOID.CPS_QUALIFIER: "id-qt-cps", + CertificatePoliciesOID.CPS_USER_NOTICE: "id-qt-unotice", + OCSPExtensionOID.NONCE: "OCSPNonce", + AttributeOID.CHALLENGE_PASSWORD: "challengePassword", +} diff --git a/contrib/python/cryptography/py3/ya.make b/contrib/python/cryptography/py3/ya.make new file mode 100644 index 0000000000..c7524bf4e4 --- /dev/null +++ b/contrib/python/cryptography/py3/ya.make @@ -0,0 +1,129 @@ +PY3_LIBRARY() + +LICENSE(BSD-3-Clause) + +VERSION(3.3.2) + +IF (PYTHON2) + PEERDIR( + contrib/deprecated/python/enum34 + contrib/deprecated/python/ipaddress + ) +ENDIF() + +PEERDIR( + contrib/libs/openssl + contrib/python/cffi + # contrib/python/idna + # contrib/python/asn1crypto + contrib/python/setuptools + contrib/python/six +) + +NO_COMPILER_WARNINGS() +NO_LINT() + +RESOURCE_FILES( + PREFIX contrib/python/cryptography/py3/ + .dist-info/METADATA + .dist-info/top_level.txt +) + +SRCS( + build/temp.linux-x86_64-2.7/_openssl.c + build/temp.linux-x86_64-2.7/_padding.c +) + +PY_REGISTER( + cryptography.hazmat.bindings._openssl + cryptography.hazmat.bindings._padding +) + +PY_SRCS( + TOP_LEVEL + cryptography/__about__.py + cryptography/__init__.py + cryptography/exceptions.py + cryptography/fernet.py + cryptography/hazmat/__init__.py + cryptography/hazmat/_der.py + cryptography/hazmat/_oid.py + cryptography/hazmat/backends/__init__.py + cryptography/hazmat/backends/interfaces.py + cryptography/hazmat/backends/openssl/__init__.py + cryptography/hazmat/backends/openssl/aead.py + cryptography/hazmat/backends/openssl/backend.py + cryptography/hazmat/backends/openssl/ciphers.py + cryptography/hazmat/backends/openssl/cmac.py + cryptography/hazmat/backends/openssl/decode_asn1.py + cryptography/hazmat/backends/openssl/dh.py + cryptography/hazmat/backends/openssl/dsa.py + cryptography/hazmat/backends/openssl/ec.py + cryptography/hazmat/backends/openssl/ed25519.py + cryptography/hazmat/backends/openssl/ed448.py + cryptography/hazmat/backends/openssl/encode_asn1.py + cryptography/hazmat/backends/openssl/hashes.py + cryptography/hazmat/backends/openssl/hmac.py + cryptography/hazmat/backends/openssl/ocsp.py + cryptography/hazmat/backends/openssl/poly1305.py + cryptography/hazmat/backends/openssl/rsa.py + cryptography/hazmat/backends/openssl/utils.py + cryptography/hazmat/backends/openssl/x25519.py + cryptography/hazmat/backends/openssl/x448.py + cryptography/hazmat/backends/openssl/x509.py + cryptography/hazmat/bindings/__init__.py + cryptography/hazmat/bindings/openssl/__init__.py + cryptography/hazmat/bindings/openssl/_conditional.py + cryptography/hazmat/bindings/openssl/binding.py + cryptography/hazmat/primitives/__init__.py + cryptography/hazmat/primitives/asymmetric/__init__.py + cryptography/hazmat/primitives/asymmetric/dh.py + cryptography/hazmat/primitives/asymmetric/dsa.py + cryptography/hazmat/primitives/asymmetric/ec.py + cryptography/hazmat/primitives/asymmetric/ed25519.py + cryptography/hazmat/primitives/asymmetric/ed448.py + cryptography/hazmat/primitives/asymmetric/padding.py + cryptography/hazmat/primitives/asymmetric/rsa.py + cryptography/hazmat/primitives/asymmetric/utils.py + cryptography/hazmat/primitives/asymmetric/x25519.py + cryptography/hazmat/primitives/asymmetric/x448.py + cryptography/hazmat/primitives/ciphers/__init__.py + cryptography/hazmat/primitives/ciphers/aead.py + cryptography/hazmat/primitives/ciphers/algorithms.py + cryptography/hazmat/primitives/ciphers/base.py + cryptography/hazmat/primitives/ciphers/modes.py + cryptography/hazmat/primitives/cmac.py + cryptography/hazmat/primitives/constant_time.py + cryptography/hazmat/primitives/hashes.py + cryptography/hazmat/primitives/hmac.py + cryptography/hazmat/primitives/kdf/__init__.py + cryptography/hazmat/primitives/kdf/concatkdf.py + cryptography/hazmat/primitives/kdf/hkdf.py + cryptography/hazmat/primitives/kdf/kbkdf.py + cryptography/hazmat/primitives/kdf/pbkdf2.py + cryptography/hazmat/primitives/kdf/scrypt.py + cryptography/hazmat/primitives/kdf/x963kdf.py + cryptography/hazmat/primitives/keywrap.py + cryptography/hazmat/primitives/padding.py + cryptography/hazmat/primitives/poly1305.py + cryptography/hazmat/primitives/serialization/__init__.py + cryptography/hazmat/primitives/serialization/base.py + cryptography/hazmat/primitives/serialization/pkcs12.py + cryptography/hazmat/primitives/serialization/pkcs7.py + cryptography/hazmat/primitives/serialization/ssh.py + cryptography/hazmat/primitives/twofactor/__init__.py + cryptography/hazmat/primitives/twofactor/hotp.py + cryptography/hazmat/primitives/twofactor/totp.py + cryptography/hazmat/primitives/twofactor/utils.py + cryptography/utils.py + cryptography/x509/__init__.py + cryptography/x509/base.py + cryptography/x509/certificate_transparency.py + cryptography/x509/extensions.py + cryptography/x509/general_name.py + cryptography/x509/name.py + cryptography/x509/ocsp.py + cryptography/x509/oid.py +) + +END() diff --git a/contrib/python/cryptography/ya.make b/contrib/python/cryptography/ya.make index 7e550209ca..4965fdc720 100644 --- a/contrib/python/cryptography/ya.make +++ b/contrib/python/cryptography/ya.make @@ -1,129 +1,18 @@ PY23_LIBRARY() -LICENSE(BSD-3-Clause) - -VERSION(3.3.2) +LICENSE(Service-Py23-Proxy) IF (PYTHON2) - PEERDIR( - contrib/deprecated/python/enum34 - contrib/deprecated/python/ipaddress - ) + PEERDIR(contrib/python/cryptography/py2) +ELSE() + PEERDIR(contrib/python/cryptography/py3) ENDIF() -PEERDIR( - contrib/libs/openssl - contrib/python/cffi - # contrib/python/idna - # contrib/python/asn1crypto - contrib/python/setuptools - contrib/python/six -) - -NO_COMPILER_WARNINGS() NO_LINT() -RESOURCE_FILES( - PREFIX contrib/python/cryptography/ - .dist-info/METADATA - .dist-info/top_level.txt -) - -SRCS( - build/temp.linux-x86_64-2.7/_openssl.c - build/temp.linux-x86_64-2.7/_padding.c -) - -PY_REGISTER( - cryptography.hazmat.bindings._openssl - cryptography.hazmat.bindings._padding -) +END() -PY_SRCS( - TOP_LEVEL - cryptography/__about__.py - cryptography/__init__.py - cryptography/exceptions.py - cryptography/fernet.py - cryptography/hazmat/__init__.py - cryptography/hazmat/_der.py - cryptography/hazmat/_oid.py - cryptography/hazmat/backends/__init__.py - cryptography/hazmat/backends/interfaces.py - cryptography/hazmat/backends/openssl/__init__.py - cryptography/hazmat/backends/openssl/aead.py - cryptography/hazmat/backends/openssl/backend.py - cryptography/hazmat/backends/openssl/ciphers.py - cryptography/hazmat/backends/openssl/cmac.py - cryptography/hazmat/backends/openssl/decode_asn1.py - cryptography/hazmat/backends/openssl/dh.py - cryptography/hazmat/backends/openssl/dsa.py - cryptography/hazmat/backends/openssl/ec.py - cryptography/hazmat/backends/openssl/ed25519.py - cryptography/hazmat/backends/openssl/ed448.py - cryptography/hazmat/backends/openssl/encode_asn1.py - cryptography/hazmat/backends/openssl/hashes.py - cryptography/hazmat/backends/openssl/hmac.py - cryptography/hazmat/backends/openssl/ocsp.py - cryptography/hazmat/backends/openssl/poly1305.py - cryptography/hazmat/backends/openssl/rsa.py - cryptography/hazmat/backends/openssl/utils.py - cryptography/hazmat/backends/openssl/x25519.py - cryptography/hazmat/backends/openssl/x448.py - cryptography/hazmat/backends/openssl/x509.py - cryptography/hazmat/bindings/__init__.py - cryptography/hazmat/bindings/openssl/__init__.py - cryptography/hazmat/bindings/openssl/_conditional.py - cryptography/hazmat/bindings/openssl/binding.py - cryptography/hazmat/primitives/__init__.py - cryptography/hazmat/primitives/asymmetric/__init__.py - cryptography/hazmat/primitives/asymmetric/dh.py - cryptography/hazmat/primitives/asymmetric/dsa.py - cryptography/hazmat/primitives/asymmetric/ec.py - cryptography/hazmat/primitives/asymmetric/ed25519.py - cryptography/hazmat/primitives/asymmetric/ed448.py - cryptography/hazmat/primitives/asymmetric/padding.py - cryptography/hazmat/primitives/asymmetric/rsa.py - cryptography/hazmat/primitives/asymmetric/utils.py - cryptography/hazmat/primitives/asymmetric/x25519.py - cryptography/hazmat/primitives/asymmetric/x448.py - cryptography/hazmat/primitives/ciphers/__init__.py - cryptography/hazmat/primitives/ciphers/aead.py - cryptography/hazmat/primitives/ciphers/algorithms.py - cryptography/hazmat/primitives/ciphers/base.py - cryptography/hazmat/primitives/ciphers/modes.py - cryptography/hazmat/primitives/cmac.py - cryptography/hazmat/primitives/constant_time.py - cryptography/hazmat/primitives/hashes.py - cryptography/hazmat/primitives/hmac.py - cryptography/hazmat/primitives/kdf/__init__.py - cryptography/hazmat/primitives/kdf/concatkdf.py - cryptography/hazmat/primitives/kdf/hkdf.py - cryptography/hazmat/primitives/kdf/kbkdf.py - cryptography/hazmat/primitives/kdf/pbkdf2.py - cryptography/hazmat/primitives/kdf/scrypt.py - cryptography/hazmat/primitives/kdf/x963kdf.py - cryptography/hazmat/primitives/keywrap.py - cryptography/hazmat/primitives/padding.py - cryptography/hazmat/primitives/poly1305.py - cryptography/hazmat/primitives/serialization/__init__.py - cryptography/hazmat/primitives/serialization/base.py - cryptography/hazmat/primitives/serialization/pkcs12.py - cryptography/hazmat/primitives/serialization/pkcs7.py - cryptography/hazmat/primitives/serialization/ssh.py - cryptography/hazmat/primitives/twofactor/__init__.py - cryptography/hazmat/primitives/twofactor/hotp.py - cryptography/hazmat/primitives/twofactor/totp.py - cryptography/hazmat/primitives/twofactor/utils.py - cryptography/utils.py - cryptography/x509/__init__.py - cryptography/x509/base.py - cryptography/x509/certificate_transparency.py - cryptography/x509/extensions.py - cryptography/x509/general_name.py - cryptography/x509/name.py - cryptography/x509/ocsp.py - cryptography/x509/oid.py +RECURSE( + py2 + py3 ) - -END() |