From 5cde8edd3ff9f79a9f568a803a5d5189e6993813 Mon Sep 17 00:00:00 2001 From: Jack Lloyd Date: Sat, 11 Aug 2018 15:31:37 -0400 Subject: Better error checking in Python wrapper Adopt APIs added in 2.8 Expose botan_error_description which was added in 2.5 but not exported! --- src/python/botan2.py | 590 +++++++++++++++++++++++++++++++++------------------ 1 file changed, 378 insertions(+), 212 deletions(-) (limited to 'src/python/botan2.py') diff --git a/src/python/botan2.py b/src/python/botan2.py index 18125a4b6..5b7c84847 100755 --- a/src/python/botan2.py +++ b/src/python/botan2.py @@ -1,10 +1,10 @@ -#!/usr/bin/env python +#!/usr/bin/python """ Python wrapper of the botan crypto library https://botan.randombit.net -(C) 2015,2017 Jack Lloyd +(C) 2015,2017,2018 Jack Lloyd (C) 2015 Uri Blumenthal (extensions and patches) Botan is released under the Simplified BSD License (see license.txt) @@ -12,23 +12,35 @@ Botan is released under the Simplified BSD License (see license.txt) This module uses the ctypes module and is usable by programs running under at least CPython 2.7, CPython 3.4 and 3.5, or PyPy. -It uses botan's ffi module, which exposes a C API. It suppports all -versions of Botan >= 2.0 +It uses botan's ffi module, which exposes a C API. + +This version of the module requires FFI API version 20180713, which was +introduced in Botan 2.8 + """ -import sys from ctypes import CDLL, POINTER, byref, c_void_p, c_size_t, c_uint32, c_int, c_char, c_char_p, create_string_buffer + +from sys import version_info +from time import strptime, mktime from binascii import hexlify from datetime import datetime -import time +BOTAN_FFI_VERSION = 20180713 # # Base exception for all exceptions raised from this module # class BotanException(Exception): - pass + def __init__(self, message, rc=0): + + if rc == 0: + super(BotanException, self).__init__(message) + else: + descr = botan.botan_error_description(rc).decode('ascii') + super(BotanException, self).__init__("%s: %d (%s)" % (message, rc, descr)) + self.rc = rc # # Module initialization @@ -37,7 +49,7 @@ class BotanException(Exception): def load_botan_dll(expected_version): possible_dll_names = ['libbotan-2.dylib', 'libbotan-2.so'] + \ - ['libbotan-2.so.%d' % (v) for v in reversed(range(0, 16))] + ['libbotan-2.so.%d' % (v) for v in reversed(range(8, 16))] for dll_name in possible_dll_names: try: @@ -51,11 +63,293 @@ def load_botan_dll(expected_version): return None -botan = load_botan_dll(20150515) # pylint: disable=invalid-name +botan = load_botan_dll(BOTAN_FFI_VERSION) # pylint: disable=invalid-name if botan is None: raise BotanException("Could not find a usable Botan shared object library") +# +# ctypes function prototypes +# +def errcheck_for(fn_name): + def errcheck(rc, _func, _args): + # No idea what to do if return value isn't an int, just return it + if not isinstance(rc, int): + return rc + + if rc >= 0: + return rc + if rc == -10: # insufficient buffer space, pass up to caller + return rc + raise BotanException('%s failed' % (fn_name), rc) + return errcheck + +botan.botan_version_string.argtypes = [] +botan.botan_version_string.restype = c_char_p + +botan.botan_error_description.argtypes = [c_int] +botan.botan_error_description.restype = c_char_p + +# RNG +botan.botan_rng_init.argtypes = [c_void_p, c_char_p] +botan.botan_rng_init.errcheck = errcheck_for('botan_rng_init') + +botan.botan_rng_destroy.argtypes = [c_void_p] +botan.botan_rng_destroy.errcheck = errcheck_for('botan_rng_destroy') + +botan.botan_rng_reseed.argtypes = [c_void_p, c_size_t] +botan.botan_rng_reseed.errcheck = errcheck_for('botan_rng_reseed') + +botan.botan_rng_get.argtypes = [c_void_p, POINTER(c_char), c_size_t] +botan.botan_rng_get.errcheck = errcheck_for('botan_rng_get') + +# Hash function +botan.botan_hash_init.argtypes = [c_void_p, c_char_p, c_uint32] +botan.botan_hash_init.errcheck = errcheck_for('botan_hash_init') + +botan.botan_hash_destroy.argtypes = [c_void_p] +botan.botan_hash_destroy.errcheck = errcheck_for('botan_hash_destroy') + +botan.botan_hash_clear.argtypes = [c_void_p] +botan.botan_hash_clear.errcheck = errcheck_for('botan_hash_clear') + +botan.botan_hash_output_length.argtypes = [c_void_p, POINTER(c_size_t)] +botan.botan_hash_output_length.errcheck = errcheck_for('botan_hash_output_length') + +botan.botan_hash_update.argtypes = [c_void_p, POINTER(c_char), c_size_t] +botan.botan_hash_update.errcheck = errcheck_for('botan_hash_update') + +botan.botan_hash_final.argtypes = [c_void_p, POINTER(c_char)] +botan.botan_hash_final.errcheck = errcheck_for('botan_hash_final') + +# MAC +botan.botan_mac_init.argtypes = [c_void_p, c_char_p, c_uint32] +botan.botan_mac_init.errcheck = errcheck_for('botan_mac_init') + +botan.botan_mac_destroy.argtypes = [c_void_p] +botan.botan_mac_destroy.errcheck = errcheck_for('botan_mac_destroy') + +botan.botan_mac_clear.argtypes = [c_void_p] +botan.botan_mac_clear.errcheck = errcheck_for('botan_mac_clear') + +botan.botan_mac_output_length.argtypes = [c_void_p, POINTER(c_size_t)] +botan.botan_mac_output_length.errcheck = errcheck_for('botan_mac_output_length') + +botan.botan_mac_set_key.argtypes = [c_void_p, POINTER(c_char), c_size_t] +botan.botan_mac_set_key.errcheck = errcheck_for('botan_mac_set_key') + +botan.botan_mac_update.argtypes = [c_void_p, POINTER(c_char), c_size_t] +botan.botan_mac_update.errcheck = errcheck_for('botan_mac_update') + +botan.botan_mac_final.argtypes = [c_void_p, POINTER(c_char)] +botan.botan_mac_final.errcheck = errcheck_for('botan_mac_final') + +# Cipher +botan.botan_cipher_init.argtypes = [c_void_p, c_char_p, c_uint32] +botan.botan_cipher_init.errcheck = errcheck_for('botan_cipher_init') + +botan.botan_cipher_destroy.argtypes = [c_void_p] +botan.botan_cipher_destroy.errcheck = errcheck_for('botan_cipher_destroy') + +botan.botan_cipher_get_default_nonce_length.argtypes = [c_void_p, POINTER(c_size_t)] +botan.botan_cipher_get_default_nonce_length.errcheck = errcheck_for('botan_cipher_get_default_nonce_length') + +botan.botan_cipher_get_update_granularity.argtypes = [c_void_p, POINTER(c_size_t)] +botan.botan_cipher_get_update_granularity.errcheck = errcheck_for('botan_cipher_get_update_granularity') + +botan.botan_cipher_get_tag_length.argtypes = [c_void_p, POINTER(c_size_t)] +botan.botan_cipher_get_tag_length.errcheck = errcheck_for('botan_cipher_get_tag_length') + +botan.botan_cipher_valid_nonce_length.argtypes = [c_void_p, c_size_t] +botan.botan_cipher_valid_nonce_length.errcheck = errcheck_for('botan_cipher_valid_nonce_length') + +botan.botan_cipher_clear.argtypes = [c_void_p] +botan.botan_cipher_clear.errcheck = errcheck_for('botan_cipher_clear') + +botan.botan_cipher_set_key.argtypes = [c_void_p, POINTER(c_char), c_size_t] +botan.botan_cipher_set_key.errcheck = errcheck_for('botan_cipher_set_key') + +botan.botan_cipher_set_associated_data.argtypes = [c_void_p, POINTER(c_char), c_size_t] +botan.botan_cipher_set_associated_data.errcheck = errcheck_for('botan_cipher_set_associated_data') + +botan.botan_cipher_start.argtypes = [c_void_p, POINTER(c_char), c_size_t] +botan.botan_cipher_start.errcheck = errcheck_for('botan_cipher_start') + +botan.botan_cipher_update.argtypes = [c_void_p, c_uint32, + POINTER(c_char), c_size_t, POINTER(c_size_t), + POINTER(c_char), c_size_t, POINTER(c_size_t)] +botan.botan_cipher_update.errcheck = errcheck_for('botan_cipher_update') + +# Bcrypt +botan.botan_bcrypt_generate.argtypes = [POINTER(c_char), POINTER(c_size_t), + c_char_p, c_void_p, c_size_t, c_uint32] +botan.botan_bcrypt_generate.errcheck = errcheck_for('botan_bcrypt_generate') + +botan.botan_bcrypt_is_valid.argtypes = [c_char_p, c_char_p] +botan.botan_bcrypt_is_valid.errcheck = errcheck_for('botan_bcrypt_is_valid') + +# PBKDF +botan.botan_pbkdf.argtypes = [c_char_p, POINTER(c_char), c_size_t, c_char_p, c_void_p, c_size_t, c_size_t] +botan.botan_pbkdf.errcheck = errcheck_for('botan_pbkdf') + +botan.botan_pbkdf_timed.argtypes = [c_char_p, POINTER(c_char), c_size_t, c_char_p, + c_void_p, c_size_t, c_size_t, POINTER(c_size_t)] +botan.botan_pbkdf_timed.errcheck = errcheck_for('botan_pbkdf_timed') + +# KDF +botan.botan_kdf.argtypes = [c_char_p, POINTER(c_char), c_size_t, POINTER(c_char), c_size_t, + POINTER(c_char), c_size_t, POINTER(c_char), c_size_t] +botan.botan_kdf.errcheck = errcheck_for('botan_kdf') + +# Public key +botan.botan_pubkey_destroy.argtypes = [c_void_p] +botan.botan_pubkey_destroy.errcheck = errcheck_for('botan_pubkey_destroy') + +botan.botan_pubkey_estimated_strength.argtypes = [c_void_p, POINTER(c_size_t)] +botan.botan_pubkey_estimated_strength.errcheck = errcheck_for('botan_pubkey_estimated_strength') + +botan.botan_pubkey_algo_name.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] +botan.botan_pubkey_algo_name.errcheck = errcheck_for('botan_pubkey_algo_name') + +botan.botan_pubkey_export.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t), c_uint32] +botan.botan_pubkey_export.errcheck = errcheck_for('botan_pubkey_export') + +botan.botan_pubkey_fingerprint.argtypes = [c_void_p, c_char_p, + POINTER(c_char), POINTER(c_size_t)] +botan.botan_pubkey_fingerprint.errcheck = errcheck_for('botan_pubkey_fingerprint') + +botan.botan_privkey_create.argtypes = [c_void_p, c_char_p, c_char_p, c_void_p] +botan.botan_privkey_create.errcheck = errcheck_for('botan_privkey_create') + +botan.botan_privkey_export_pubkey.argtypes = [c_void_p, c_void_p] +botan.botan_privkey_export_pubkey.errcheck = errcheck_for('botan_privkey_export_pubkey') + +botan.botan_privkey_destroy.argtypes = [c_void_p] +botan.botan_privkey_destroy.errcheck = errcheck_for('botan_privkey_destroy') + +botan.botan_privkey_export.argtypes = [c_void_p, POINTER(c_char), c_void_p] +botan.botan_privkey_export.errcheck = errcheck_for('botan_privkey_export') + +# PK Encryption +botan.botan_pk_op_encrypt_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32] +botan.botan_pk_op_encrypt_create.errcheck = errcheck_for('botan_pk_op_encrypt_create') + +botan.botan_pk_op_encrypt_output_length.argtypes = [c_void_p, c_size_t, POINTER(c_size_t)] +botan.botan_pk_op_encrypt_output_length.errcheck = errcheck_for('botan_pk_op_encrypt_output_length') + +botan.botan_pk_op_encrypt_destroy.argtypes = [c_void_p] +botan.botan_pk_op_encrypt_destroy.errcheck = errcheck_for('botan_pk_op_encrypt_destroy') + +botan.botan_pk_op_encrypt.argtypes = [c_void_p, c_void_p, + POINTER(c_char), POINTER(c_size_t), + POINTER(c_char), c_size_t] +botan.botan_pk_op_encrypt.errcheck = errcheck_for('botan_pk_op_encrypt') + +# PK Decryption +botan.botan_pk_op_decrypt_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32] +botan.botan_pk_op_decrypt_create.errcheck = errcheck_for('botan_pk_op_decrypt_create') + +botan.botan_pk_op_decrypt_output_length.argtypes = [c_void_p, c_size_t, POINTER(c_size_t)] +botan.botan_pk_op_decrypt_output_length.errcheck = errcheck_for('botan_pk_op_decrypt_output_length') + +botan.botan_pk_op_decrypt_destroy.argtypes = [c_void_p] +botan.botan_pk_op_decrypt_destroy.errcheck = errcheck_for('botan_pk_op_decrypt_destroy') + +botan.botan_pk_op_decrypt.argtypes = [c_void_p, + POINTER(c_char), POINTER(c_size_t), + POINTER(c_char), c_size_t] +botan.botan_pk_op_decrypt.errcheck = errcheck_for('botan_pk_op_encrypt') + +# PK Signatures +botan.botan_pk_op_sign_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32] +botan.botan_pk_op_sign_create.errcheck = errcheck_for('botan_pk_op_sign_create') + +botan.botan_pk_op_sign_destroy.argtypes = [c_void_p] +botan.botan_pk_op_sign_destroy.errcheck = errcheck_for('botan_pk_op_sign_destroy') + +botan.botan_pk_op_sign_update.argtypes = [c_void_p, POINTER(c_char), c_size_t] +botan.botan_pk_op_sign_update.errcheck = errcheck_for('botan_pk_op_sign_update') + +botan.botan_pk_op_sign_finish.argtypes = [c_void_p, c_void_p, POINTER(c_char), POINTER(c_size_t)] +botan.botan_pk_op_sign_finish.errcheck = errcheck_for('botan_pk_op_sign_finish') + +# PK Verification +botan.botan_pk_op_verify_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32] +botan.botan_pk_op_verify_create.errcheck = errcheck_for('botan_pk_op_verify_create') + +botan.botan_pk_op_verify_destroy.argtypes = [c_void_p] +botan.botan_pk_op_verify_destroy.errcheck = errcheck_for('botan_pk_op_verify_destroy') + +botan.botan_pk_op_verify_update.argtypes = [c_void_p, POINTER(c_char), c_size_t] +botan.botan_pk_op_verify_update.errcheck = errcheck_for('botan_pk_op_verify_update') + +botan.botan_pk_op_verify_finish.argtypes = [c_void_p, POINTER(c_char), c_size_t] +botan.botan_pk_op_verify_finish.errcheck = errcheck_for('botan_pk_op_verify_finish') + +# MCEIES +botan.botan_mceies_encrypt.argtypes = [c_void_p, c_void_p, c_char_p, POINTER(c_char), c_size_t, + POINTER(c_char), c_size_t, POINTER(c_char), POINTER(c_size_t)] +botan.botan_mceies_encrypt.errcheck = errcheck_for('botan_mceies_encrypt') + +botan.botan_mceies_decrypt.argtypes = [c_void_p, c_char_p, POINTER(c_char), c_size_t, + POINTER(c_char), c_size_t, POINTER(c_char), POINTER(c_size_t)] +botan.botan_mceies_decrypt.errcheck = errcheck_for('botan_mceies_decrypt') + +# Key Agreement +botan.botan_pk_op_key_agreement_export_public.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] +botan.botan_pk_op_key_agreement_export_public.errcheck = errcheck_for('botan_pk_op_key_agreement_export_public') + +botan.botan_pk_op_key_agreement_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32] +botan.botan_pk_op_key_agreement_create.errcheck = errcheck_for('botan_pk_op_key_agreement_create') + +botan.botan_pk_op_key_agreement_destroy.argtypes = [c_void_p] +botan.botan_pk_op_key_agreement_destroy.errcheck = errcheck_for('botan_pk_op_key_agreement_destroy') + +botan.botan_pk_op_key_agreement.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t), + POINTER(c_char), c_size_t, POINTER(c_char), c_size_t] +botan.botan_pk_op_key_agreement.errcheck = errcheck_for('botan_pk_op_key_agreement') + +# X509 certs +botan.botan_x509_cert_load_file.argtypes = [POINTER(c_void_p), c_char_p] +botan.botan_x509_cert_load_file.errcheck = errcheck_for('botan_x509_cert_load_file') + +botan.botan_x509_cert_load.argtypes = [POINTER(c_void_p), POINTER(c_char), c_size_t] +botan.botan_x509_cert_load.errcheck = errcheck_for('botan_x509_cert_load') + +botan.botan_x509_cert_destroy.argtypes = [c_void_p] +botan.botan_x509_cert_destroy.errcheck = errcheck_for('botan_x509_cert_destroy') + +botan.botan_x509_cert_get_time_starts.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] +botan.botan_x509_cert_get_time_starts.errcheck = errcheck_for('botan_x509_cert_get_time_starts') + +botan.botan_x509_cert_get_time_expires.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] +botan.botan_x509_cert_get_time_expires.errcheck = errcheck_for('botan_x509_cert_get_time_expires') + +botan.botan_x509_cert_to_string.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] +botan.botan_x509_cert_to_string.errcheck = errcheck_for('botan_x509_cert_to_string') + +botan.botan_x509_cert_get_fingerprint.argtypes = [c_void_p, c_char_p, + POINTER(c_char), POINTER(c_size_t)] +botan.botan_x509_cert_get_fingerprint.errcheck = errcheck_for('botan_x509_cert_get_fingerprint') + +botan.botan_x509_cert_get_serial_number.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] +botan.botan_x509_cert_get_serial_number.errcheck = errcheck_for('botan_x509_cert_get_serial_number') + +botan.botan_x509_cert_get_authority_key_id.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] +botan.botan_x509_cert_get_authority_key_id.errcheck = errcheck_for('botan_x509_cert_get_authority_key_id') + +botan.botan_x509_cert_get_subject_key_id.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] +botan.botan_x509_cert_get_subject_key_id.errcheck = errcheck_for('botan_x509_cert_get_subject_key_id') + +botan.botan_x509_cert_get_public_key_bits.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] +botan.botan_x509_cert_get_public_key_bits.errcheck = errcheck_for('botan_x509_cert_get_public_key_bits') + +botan.botan_x509_cert_get_public_key.argtypes = [c_void_p, c_void_p] +botan.botan_x509_cert_get_public_key.errcheck = errcheck_for('botan_x509_cert_get_public_key') + +botan.botan_x509_cert_get_subject_dn.argtypes = [c_void_p, c_char_p, c_size_t, POINTER(c_char), POINTER(c_size_t)] +botan.botan_x509_cert_get_subject_dn.errcheck = errcheck_for('botan_x509_cert_get_subject_dn') + # # Internal utilities # @@ -65,12 +359,8 @@ def _call_fn_returning_vec(guess, fn): buf_len = c_size_t(len(buf)) rc = fn(buf, byref(buf_len)) - if rc < 0: - if buf_len.value > len(buf): - #print("Calling again with %d" % (buf_len.value)) - return _call_fn_returning_vec(buf_len.value, fn) - else: - raise BotanException("Call failed: %d" % (rc)) + if rc == -10 and buf_len.value > len(buf): + return _call_fn_returning_vec(buf_len.value, fn) assert buf_len.value <= len(buf) return buf.raw[0:int(buf_len.value)] @@ -83,13 +373,13 @@ def _call_fn_returning_string(guess, fn): def _ctype_str(s): assert isinstance(s, str) - if sys.version_info[0] < 3: + if version_info[0] < 3: return s else: return s.encode('utf-8') def _ctype_bits(s): - if sys.version_info[0] < 3: + if version_info[0] < 3: if isinstance(s, str): return s else: @@ -103,7 +393,7 @@ def _ctype_bits(s): raise Exception("Internal error - unexpected type provided to _ctype_bits") def _ctype_bufout(buf): - if sys.version_info[0] < 3: + if version_info[0] < 3: return str(buf.raw) else: return buf.raw @@ -124,7 +414,6 @@ def version_patch(): return botan.botan_version_patch() def version_string(): - botan.botan_version_string.restype = c_char_p return botan.botan_version_string().decode('ascii') # @@ -133,64 +422,45 @@ def version_string(): class rng(object): # pylint: disable=invalid-name # Can also use type "system" def __init__(self, rng_type='system'): - botan.botan_rng_init.argtypes = [c_void_p, c_char_p] self.rng = c_void_p(0) - rc = botan.botan_rng_init(byref(self.rng), _ctype_str(rng_type)) - if rc != 0 or self.rng is None: - raise BotanException("No rng " + rng_type + " available") + botan.botan_rng_init(byref(self.rng), _ctype_str(rng_type)) def __del__(self): - botan.botan_rng_destroy.argtypes = [c_void_p] botan.botan_rng_destroy(self.rng) def reseed(self, bits=256): - botan.botan_rng_reseed.argtypes = [c_void_p, c_size_t] botan.botan_rng_reseed(self.rng, bits) def get(self, length): - botan.botan_rng_get.argtypes = [c_void_p, POINTER(c_char), c_size_t] out = create_string_buffer(length) l = c_size_t(length) - rc = botan.botan_rng_get(self.rng, out, l) - if rc == 0: - return _ctype_bufout(out) - else: - return None + botan.botan_rng_get(self.rng, out, l) + return _ctype_bufout(out) # # Hash function # class hash_function(object): # pylint: disable=invalid-name def __init__(self, algo): - botan.botan_hash_init.argtypes = [c_void_p, c_char_p, c_uint32] flags = c_uint32(0) # always zero in this API version self.hash = c_void_p(0) - rc = botan.botan_hash_init(byref(self.hash), _ctype_str(algo), flags) - if rc != 0 or self.hash is None: - raise BotanException("No hash " + algo + " for you!") + botan.botan_hash_init(byref(self.hash), _ctype_str(algo), flags) def __del__(self): - botan.botan_hash_destroy.argtypes = [c_void_p] botan.botan_hash_destroy(self.hash) def clear(self): - botan.botan_hash_clear.argtypes = [c_void_p] - return botan.botan_hash_clear(self.hash) + botan.botan_hash_clear(self.hash) def output_length(self): - botan.botan_hash_output_length.argtypes = [c_void_p, POINTER(c_size_t)] l = c_size_t(0) - rc = botan.botan_hash_output_length(self.hash, byref(l)) - if rc == 0: - return l.value - raise BotanException("botan_hash_output_length failed") + botan.botan_hash_output_length(self.hash, byref(l)) + return l.value def update(self, x): - botan.botan_hash_update.argtypes = [c_void_p, POINTER(c_char), c_size_t] botan.botan_hash_update(self.hash, _ctype_bits(x), len(x)) def final(self): - botan.botan_hash_final.argtypes = [c_void_p, POINTER(c_char)] out = create_string_buffer(self.output_length()) botan.botan_hash_final(self.hash, out) return _ctype_bufout(out) @@ -200,64 +470,47 @@ class hash_function(object): # pylint: disable=invalid-name # class message_authentication_code(object): # pylint: disable=invalid-name def __init__(self, algo): - botan.botan_mac_init.argtypes = [c_void_p, c_char_p, c_uint32] flags = c_uint32(0) # always zero in this API version self.mac = c_void_p(0) - rc = botan.botan_mac_init(byref(self.mac), _ctype_str(algo), flags) - if rc != 0 or self.mac is None: - raise BotanException("No mac " + algo + " for you!") + botan.botan_mac_init(byref(self.mac), _ctype_str(algo), flags) def __del__(self): - botan.botan_mac_destroy.argtypes = [c_void_p] botan.botan_mac_destroy(self.mac) def clear(self): - botan.botan_mac_clear.argtypes = [c_void_p] - return botan.botan_mac_clear(self.mac) + botan.botan_mac_clear(self.mac) def output_length(self): - botan.botan_mac_output_length.argtypes = [c_void_p, POINTER(c_size_t)] l = c_size_t(0) - rc = botan.botan_mac_output_length(self.mac, byref(l)) - if rc == 0: - return l.value - raise BotanException("botan_mac_output_length failed") + botan.botan_mac_output_length(self.mac, byref(l)) + return l.value def set_key(self, key): - botan.botan_mac_set_key.argtypes = [c_void_p, POINTER(c_char), c_size_t] - return botan.botan_mac_set_key(self.mac, key, len(key)) + botan.botan_mac_set_key(self.mac, key, len(key)) def update(self, x): - botan.botan_mac_update.argtypes = [c_void_p, POINTER(c_char), c_size_t] botan.botan_mac_update(self.mac, x, len(x)) def final(self): - botan.botan_mac_final.argtypes = [c_void_p, POINTER(c_char)] out = create_string_buffer(self.output_length()) botan.botan_mac_final(self.mac, out) return _ctype_bufout(out) class cipher(object): # pylint: disable=invalid-name def __init__(self, algo, encrypt=True): - botan.botan_cipher_init.argtypes = [c_void_p, c_char_p, c_uint32] flags = 0 if encrypt else 1 self.cipher = c_void_p(0) - rc = botan.botan_cipher_init(byref(self.cipher), _ctype_str(algo), flags) - if rc != 0 or self.cipher is None: - raise BotanException("No cipher " + algo + " for you!") + botan.botan_cipher_init(byref(self.cipher), _ctype_str(algo), flags) def __del__(self): - botan.botan_cipher_destroy.argtypes = [c_void_p] botan.botan_cipher_destroy(self.cipher) def default_nonce_length(self): - botan.botan_cipher_get_default_nonce_length.argtypes = [c_void_p, POINTER(c_size_t)] l = c_size_t(0) botan.botan_cipher_get_default_nonce_length(self.cipher, byref(l)) return l.value def update_granularity(self): - botan.botan_cipher_get_update_granularity.argtypes = [c_void_p, POINTER(c_size_t)] l = c_size_t(0) botan.botan_cipher_get_update_granularity(self.cipher, byref(l)) return l.value @@ -269,7 +522,6 @@ class cipher(object): # pylint: disable=invalid-name return kmin.value, kmax.value def tag_length(self): - botan.botan_cipher_get_tag_length.argtypes = [c_void_p, POINTER(c_size_t)] l = c_size_t(0) botan.botan_cipher_get_tag_length(self.cipher, byref(l)) return l.value @@ -278,32 +530,22 @@ class cipher(object): # pylint: disable=invalid-name return self.tag_length() > 0 def valid_nonce_length(self, nonce_len): - botan.botan_cipher_valid_nonce_length.argtypes = [c_void_p, c_size_t] rc = botan.botan_cipher_valid_nonce_length(self.cipher, nonce_len) - if rc < 0: - raise BotanException('Error calling valid_nonce_length') return True if rc == 1 else False def clear(self): - botan.botan_cipher_clear.argtypes = [c_void_p] botan.botan_cipher_clear(self.cipher) def set_key(self, key): - botan.botan_cipher_set_key.argtypes = [c_void_p, POINTER(c_char), c_size_t] botan.botan_cipher_set_key(self.cipher, key, len(key)) def set_assoc_data(self, ad): - botan.botan_cipher_set_associated_data.argtypes = [c_void_p, POINTER(c_char), c_size_t] botan.botan_cipher_set_associated_data(self.cipher, ad, len(ad)) def start(self, nonce): - botan.botan_cipher_start.argtypes = [c_void_p, POINTER(c_char), c_size_t] botan.botan_cipher_start(self.cipher, nonce, len(nonce)) def _update(self, txt, final): - botan.botan_cipher_update.argtypes = [c_void_p, c_uint32, - POINTER(c_char), c_size_t, POINTER(c_size_t), - POINTER(c_char), c_size_t, POINTER(c_size_t)] inp = txt if txt else '' inp_sz = c_size_t(len(inp)) @@ -332,15 +574,11 @@ def bcrypt(passwd, rng_instance, work_factor=10): """ Bcrypt password hashing """ - botan.botan_bcrypt_generate.argtypes = [POINTER(c_char), POINTER(c_size_t), - c_char_p, c_void_p, c_size_t, c_uint32] out_len = c_size_t(64) out = create_string_buffer(out_len.value) flags = c_uint32(0) - rc = botan.botan_bcrypt_generate(out, byref(out_len), _ctype_str(passwd), - rng_instance.rng, c_size_t(work_factor), flags) - if rc != 0: - raise BotanException('botan bcrypt failed, error %s' % (rc)) + botan.botan_bcrypt_generate(out, byref(out_len), _ctype_str(passwd), + rng_instance.rng, c_size_t(work_factor), flags) b = out.raw[0:int(out_len.value)-1] if b[-1] == '\x00': b = b[:-1] @@ -354,31 +592,28 @@ def check_bcrypt(passwd, passwd_hash): # PBKDF # def pbkdf(algo, password, out_len, iterations=10000, salt=rng().get(12)): - botan.botan_pbkdf.argtypes = [c_char_p, POINTER(c_char), c_size_t, c_char_p, c_void_p, c_size_t, c_size_t] out_buf = create_string_buffer(out_len) - botan.botan_pbkdf(_ctype_str(algo), out_buf, out_len, _ctype_str(password), salt, len(salt), iterations) + botan.botan_pbkdf(_ctype_str(algo), out_buf, out_len, + _ctype_str(password), salt, len(salt), iterations) return (salt, iterations, out_buf.raw) def pbkdf_timed(algo, password, out_len, ms_to_run=300, salt=rng().get(12)): - botan.botan_pbkdf_timed.argtypes = [c_char_p, POINTER(c_char), c_size_t, c_char_p, - c_void_p, c_size_t, c_size_t, POINTER(c_size_t)] out_buf = create_string_buffer(out_len) iterations = c_size_t(0) - botan.botan_pbkdf_timed( - _ctype_str(algo), out_buf, out_len, _ctype_str(password), - salt, len(salt), ms_to_run, byref(iterations)) + botan.botan_pbkdf_timed(_ctype_str(algo), out_buf, out_len, _ctype_str(password), + salt, len(salt), ms_to_run, byref(iterations)) return (salt, iterations.value, out_buf.raw) # # KDF # def kdf(algo, secret, out_len, salt, label): - botan.botan_kdf.argtypes = [c_char_p, POINTER(c_char), c_size_t, POINTER(c_char), c_size_t, - POINTER(c_char), c_size_t, POINTER(c_char), c_size_t] out_buf = create_string_buffer(out_len) out_sz = c_size_t(out_len) - botan.botan_kdf(_ctype_str(algo), out_buf, out_sz, secret, len(secret), - salt, len(salt), label, len(label)) + botan.botan_kdf(_ctype_str(algo), out_buf, out_sz, + secret, len(secret), + salt, len(salt), + label, len(label)) return out_buf.raw[0:int(out_sz.value)] # @@ -389,27 +624,21 @@ class public_key(object): # pylint: disable=invalid-name self.pubkey = obj def __del__(self): - botan.botan_pubkey_destroy.argtypes = [c_void_p] botan.botan_pubkey_destroy(self.pubkey) def estimated_strength(self): - botan.botan_pubkey_estimated_strength.argtypes = [c_void_p, POINTER(c_size_t)] r = c_size_t(0) botan.botan_pubkey_estimated_strength(self.pubkey, byref(r)) return r.value def algo_name(self): - botan.botan_pubkey_algo_name.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] return _call_fn_returning_string(32, lambda b, bl: botan.botan_pubkey_algo_name(self.pubkey, b, bl)) def encoding(self, pem=False): - botan.botan_pubkey_export.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t), c_uint32] flag = 1 if pem else 0 - return _call_fn_returning_vec(0, lambda b, bl: botan.botan_pubkey_export(self.pubkey, b, bl, flag)) + return _call_fn_returning_vec(4096, lambda b, bl: botan.botan_pubkey_export(self.pubkey, b, bl, flag)) def fingerprint(self, hash_algorithm='SHA-256'): - botan.botan_pubkey_fingerprint.argtypes = [c_void_p, c_char_p, - POINTER(c_char), POINTER(c_size_t)] n = hash_function(hash_algorithm).output_length() buf = create_string_buffer(n) @@ -419,41 +648,40 @@ class public_key(object): # pylint: disable=invalid-name return _hex_encode(buf[0:int(buf_len.value)]) class private_key(object): # pylint: disable=invalid-name - def __init__(self, alg, param, rng_instance): - botan.botan_privkey_create_rsa.argtypes = [c_void_p, c_void_p, c_size_t] - botan.botan_privkey_create_ecdsa.argtypes = [c_void_p, c_void_p, c_char_p] - botan.botan_privkey_create_ecdh.argtypes = [c_void_p, c_void_p, c_char_p] - botan.botan_privkey_create_mceliece.argtypes = [c_void_p, c_void_p, c_size_t, c_size_t] + def __init__(self, algo, params, rng_instance): self.privkey = c_void_p(0) - if alg == 'rsa': - botan.botan_privkey_create_rsa(byref(self.privkey), rng_instance.rng, param) - elif alg == 'ecdsa': - botan.botan_privkey_create_ecdsa(byref(self.privkey), rng_instance.rng, _ctype_str(param)) - elif alg == 'ecdh': - botan.botan_privkey_create_ecdh(byref(self.privkey), rng_instance.rng, _ctype_str(param)) - elif alg in ['mce', 'mceliece']: - botan.botan_privkey_create_mceliece(byref(self.privkey), rng_instance.rng, param[0], param[1]) - else: - raise BotanException('Unknown public key algo ' + alg) + if algo == 'rsa': + algo = 'RSA' + params = "%d" % (params) + elif algo == 'ecdsa': + algo = 'ECDSA' + elif algo == 'ecdh': + + if params == 'curve25519': + algo = 'Curve25519' + params = '' + else: + algo = 'ECDH' - if self.privkey is None: - raise BotanException('Error creating ' + alg + ' key') + elif algo in ['mce', 'mceliece']: + algo = 'McEliece' + params = "%d,%d" % (params[0], params[1]) + + botan.botan_privkey_create(byref(self.privkey), + _ctype_str(algo), _ctype_str(params), rng_instance.rng) def __del__(self): - botan.botan_privkey_destroy.argtypes = [c_void_p] botan.botan_privkey_destroy(self.privkey) def get_public_key(self): - botan.botan_privkey_export_pubkey.argtypes = [c_void_p, c_void_p] pub = c_void_p(0) botan.botan_privkey_export_pubkey(byref(pub), self.privkey) return public_key(pub) def export(self): - botan.botan_privkey_export.argtypes = [c_void_p, POINTER(c_char), c_void_p] n = 4096 buf = create_string_buffer(n) @@ -467,102 +695,69 @@ class private_key(object): # pylint: disable=invalid-name class pk_op_encrypt(object): # pylint: disable=invalid-name def __init__(self, key, padding): - botan.botan_pk_op_encrypt_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32] self.op = c_void_p(0) flags = c_uint32(0) # always zero in this ABI - print("Padding is ", padding) botan.botan_pk_op_encrypt_create(byref(self.op), key.pubkey, _ctype_str(padding), flags) - if not self.op: - raise BotanException("No pk op for you") def __del__(self): - botan.botan_pk_op_encrypt_destroy.argtypes = [c_void_p] botan.botan_pk_op_encrypt_destroy(self.op) def encrypt(self, msg, rng_instance): - botan.botan_pk_op_encrypt.argtypes = [c_void_p, c_void_p, - POINTER(c_char), POINTER(c_size_t), - POINTER(c_char), c_size_t] - - outbuf_sz = c_size_t(4096) #?!?! + outbuf_sz = c_size_t(0) + botan.botan_pk_op_encrypt_output_length(self.op, len(msg), byref(outbuf_sz)) outbuf = create_string_buffer(outbuf_sz.value) - ll = len(msg) - #print("encrypt: len=%d" % ll) - #if sys.version_info[0] > 2: - # msg = cast(msg, c_char_p) - # ll = c_size_t(ll) - botan.botan_pk_op_encrypt(self.op, rng_instance.rng, outbuf, byref(outbuf_sz), msg, ll) - #print("encrypt: outbuf_sz.value=%d" % outbuf_sz.value) + botan.botan_pk_op_encrypt(self.op, rng_instance.rng, outbuf, byref(outbuf_sz), msg, len(msg)) return outbuf.raw[0:int(outbuf_sz.value)] class pk_op_decrypt(object): # pylint: disable=invalid-name def __init__(self, key, padding): - botan.botan_pk_op_decrypt_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32] self.op = c_void_p(0) flags = c_uint32(0) # always zero in this ABI botan.botan_pk_op_decrypt_create(byref(self.op), key.privkey, _ctype_str(padding), flags) - if not self.op: - raise BotanException("No pk op for you") def __del__(self): - botan.botan_pk_op_decrypt_destroy.argtypes = [c_void_p] botan.botan_pk_op_decrypt_destroy(self.op) def decrypt(self, msg): - botan.botan_pk_op_decrypt.argtypes = [c_void_p, - POINTER(c_char), POINTER(c_size_t), - POINTER(c_char), c_size_t] - - outbuf_sz = c_size_t(4096) #?!?! + outbuf_sz = c_size_t(0) + botan.botan_pk_op_decrypt_output_length(self.op, len(msg), byref(outbuf_sz)) outbuf = create_string_buffer(outbuf_sz.value) - ll = len(msg) - botan.botan_pk_op_decrypt(self.op, outbuf, byref(outbuf_sz), _ctype_bits(msg), ll) + botan.botan_pk_op_decrypt(self.op, outbuf, byref(outbuf_sz), _ctype_bits(msg), len(msg)) return outbuf.raw[0:int(outbuf_sz.value)] class pk_op_sign(object): # pylint: disable=invalid-name def __init__(self, key, padding): - botan.botan_pk_op_sign_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32] self.op = c_void_p(0) flags = c_uint32(0) # always zero in this ABI botan.botan_pk_op_sign_create(byref(self.op), key.privkey, _ctype_str(padding), flags) - if not self.op: - raise BotanException("No pk op for you") def __del__(self): - botan.botan_pk_op_sign_destroy.argtypes = [c_void_p] botan.botan_pk_op_sign_destroy(self.op) def update(self, msg): - botan.botan_pk_op_sign_update.argtypes = [c_void_p, POINTER(c_char), c_size_t] botan.botan_pk_op_sign_update(self.op, _ctype_str(msg), len(msg)) def finish(self, rng_instance): - botan.botan_pk_op_sign_finish.argtypes = [c_void_p, c_void_p, POINTER(c_char), POINTER(c_size_t)] - outbuf_sz = c_size_t(4096) #?!?! + outbuf_sz = c_size_t(0) + botan.botan_pk_op_sign_output_length(self.op, byref(outbuf_sz)) outbuf = create_string_buffer(outbuf_sz.value) botan.botan_pk_op_sign_finish(self.op, rng_instance.rng, outbuf, byref(outbuf_sz)) return outbuf.raw[0:int(outbuf_sz.value)] class pk_op_verify(object): # pylint: disable=invalid-name def __init__(self, key, padding): - botan.botan_pk_op_verify_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32] self.op = c_void_p(0) flags = c_uint32(0) # always zero in this ABI botan.botan_pk_op_verify_create(byref(self.op), key.pubkey, _ctype_str(padding), flags) - if not self.op: - raise BotanException("No pk op for you") def __del__(self): - botan.botan_pk_op_verify_destroy.argtypes = [c_void_p] botan.botan_pk_op_verify_destroy(self.op) def update(self, msg): - botan.botan_pk_op_verify_update.argtypes = [c_void_p, POINTER(c_char), c_size_t] botan.botan_pk_op_verify_update(self.op, _ctype_bits(msg), len(msg)) def check_signature(self, signature): - botan.botan_pk_op_verify_finish.argtypes = [c_void_p, POINTER(c_char), c_size_t] rc = botan.botan_pk_op_verify_finish(self.op, _ctype_bits(signature), len(signature)) if rc == 0: return True @@ -574,10 +769,7 @@ class pk_op_verify(object): # pylint: disable=invalid-name # Must be used with McEliece keys # def mceies_encrypt(mce, rng_instance, aead, pt, ad): - botan.botan_mceies_encrypt.argtypes = [c_void_p, c_void_p, c_char_p, POINTER(c_char), c_size_t, - POINTER(c_char), c_size_t, POINTER(c_char), POINTER(c_size_t)] - - return _call_fn_returning_vec(0, lambda b, bl: + return _call_fn_returning_vec(len(pt) + 1024, lambda b, bl: botan.botan_mceies_encrypt(mce.pubkey, rng_instance.rng, _ctype_str(aead), @@ -587,46 +779,36 @@ def mceies_encrypt(mce, rng_instance, aead, pt, ad): len(ad), b, bl)) -def mceies_decrypt(mce, aead, pt, ad): - botan.botan_mceies_decrypt.argtypes = [c_void_p, c_char_p, POINTER(c_char), c_size_t, - POINTER(c_char), c_size_t, POINTER(c_char), POINTER(c_size_t)] +def mceies_decrypt(mce, aead, ct, ad): #msg = cast(msg, c_char_p) #ll = c_size_t(ll) - return _call_fn_returning_vec(0, lambda b, bl: + return _call_fn_returning_vec(len(ct), lambda b, bl: botan.botan_mceies_decrypt(mce.privkey, _ctype_str(aead), - _ctype_bits(pt), - len(pt), + _ctype_bits(ct), + len(ct), _ctype_bits(ad), len(ad), b, bl)) class pk_op_key_agreement(object): # pylint: disable=invalid-name def __init__(self, key, kdf_name): - botan.botan_pk_op_key_agreement_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32] - botan.botan_pk_op_key_agreement_export_public.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] self.op = c_void_p(0) flags = c_uint32(0) # always zero in this ABI botan.botan_pk_op_key_agreement_create(byref(self.op), key.privkey, kdf_name, flags) - if not self.op: - raise BotanException("No key agreement for you") self.m_public_value = _call_fn_returning_vec( 0, lambda b, bl: botan.botan_pk_op_key_agreement_export_public(key.privkey, b, bl)) def __del__(self): - botan.botan_pk_op_key_agreement_destroy.argtypes = [c_void_p] botan.botan_pk_op_key_agreement_destroy(self.op) def public_value(self): return self.m_public_value def agree(self, other, key_len, salt): - botan.botan_pk_op_key_agreement.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t), - POINTER(c_char), c_size_t, POINTER(c_char), c_size_t] - return _call_fn_returning_vec(key_len, lambda b, bl: botan.botan_pk_op_key_agreement(self.op, b, bl, other, len(other), @@ -642,89 +824,73 @@ class x509_cert(object): # pylint: disable=invalid-name if filename is not None and buf is not None: raise BotanException("Both filename and buf given") elif filename is not None: - botan.botan_x509_cert_load_file.argtypes = [POINTER(c_void_p), c_char_p] self.x509_cert = c_void_p(0) botan.botan_x509_cert_load_file(byref(self.x509_cert), _ctype_str(filename)) elif buf is not None: - botan.botan_x509_cert_load.argtypes = [POINTER(c_void_p), POINTER(c_char), c_size_t] self.x509_cert = c_void_p(0) botan.botan_x509_cert_load(byref(self.x509_cert), _ctype_bits(buf), len(buf)) def __del__(self): - botan.botan_x509_cert_destroy.argtypes = [c_void_p] botan.botan_x509_cert_destroy(self.x509_cert) def time_starts(self): - botan.botan_x509_cert_get_time_starts.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] starts = _call_fn_returning_string( 16, lambda b, bl: botan.botan_x509_cert_get_time_starts(self.x509_cert, b, bl)) if len(starts) == 13: # UTC time - struct_time = time.strptime(starts, "%y%m%d%H%M%SZ") + struct_time = strptime(starts, "%y%m%d%H%M%SZ") elif len(starts) == 15: # Generalized time - struct_time = time.strptime(starts, "%Y%m%d%H%M%SZ") + struct_time = strptime(starts, "%Y%m%d%H%M%SZ") else: - raise BotanException("Wrong date/time format") + raise BotanException("Unexpected date/time format for x509 start time") - return datetime.fromtimestamp(time.mktime(struct_time)) + return datetime.fromtimestamp(mktime(struct_time)) def time_expires(self): - botan.botan_x509_cert_get_time_expires.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] expires = _call_fn_returning_string( 16, lambda b, bl: botan.botan_x509_cert_get_time_expires(self.x509_cert, b, bl)) if len(expires) == 13: # UTC time - struct_time = time.strptime(expires, "%y%m%d%H%M%SZ") + struct_time = strptime(expires, "%y%m%d%H%M%SZ") elif len(expires) == 15: # Generalized time - struct_time = time.strptime(expires, "%Y%m%d%H%M%SZ") + struct_time = strptime(expires, "%Y%m%d%H%M%SZ") else: - raise BotanException("Wrong date/time format") - return datetime.fromtimestamp(time.mktime(struct_time)) + raise BotanException("Unexpected date/time format for x509 expire time") + + return datetime.fromtimestamp(mktime(struct_time)) def to_string(self): - botan.botan_x509_cert_to_string.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] return _call_fn_returning_string( - 0, lambda b, bl: botan.botan_x509_cert_to_string(self.x509_cert, b, bl)) + 4096, lambda b, bl: botan.botan_x509_cert_to_string(self.x509_cert, b, bl)) def fingerprint(self, hash_algo='SHA-256'): - botan.botan_x509_cert_get_fingerprint.argtypes = [c_void_p, c_char_p, - POINTER(c_char), POINTER(c_size_t)] - n = hash_function(hash_algo).output_length() * 3 return _call_fn_returning_string( n, lambda b, bl: botan.botan_x509_cert_get_fingerprint(self.x509_cert, _ctype_str(hash_algo), b, bl)) def serial_number(self): - botan.botan_x509_cert_get_serial_number.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] return _call_fn_returning_vec( - 0, lambda b, bl: botan.botan_x509_cert_get_serial_number(self.x509_cert, b, bl)) + 32, lambda b, bl: botan.botan_x509_cert_get_serial_number(self.x509_cert, b, bl)) def authority_key_id(self): - botan.botan_x509_cert_get_authority_key_id.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] return _call_fn_returning_vec( - 0, lambda b, bl: botan.botan_x509_cert_get_authority_key_id(self.x509_cert, b, bl)) + 32, lambda b, bl: botan.botan_x509_cert_get_authority_key_id(self.x509_cert, b, bl)) def subject_key_id(self): - botan.botan_x509_cert_get_subject_key_id.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] return _call_fn_returning_vec( - 0, lambda b, bl: botan.botan_x509_cert_get_subject_key_id(self.x509_cert, b, bl)) + 32, lambda b, bl: botan.botan_x509_cert_get_subject_key_id(self.x509_cert, b, bl)) def subject_public_key_bits(self): - botan.botan_x509_cert_get_public_key_bits.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)] return _call_fn_returning_vec( - 0, lambda b, bl: botan.botan_x509_cert_get_public_key_bits(self.x509_cert, b, bl)) + 512, lambda b, bl: botan.botan_x509_cert_get_public_key_bits(self.x509_cert, b, bl)) def subject_public_key(self): - botan.botan_x509_cert_get_public_key.argtypes = [c_void_p, c_void_p] pub = c_void_p(0) botan.botan_x509_cert_get_public_key(self.x509_cert, byref(pub)) - return public_key(pub) def subject_dn(self, key, index): - botan.botan_x509_cert_get_subject_dn.argtypes = [ - c_void_p, c_char_p, c_size_t, POINTER(c_char), POINTER(c_size_t)] return _call_fn_returning_string( 0, lambda b, bl: botan.botan_x509_cert_get_subject_dn(self.x509_cert, _ctype_str(key), index, b, bl)) -- cgit v1.2.3