aboutsummaryrefslogtreecommitdiffstats
path: root/src/python/botan.py
diff options
context:
space:
mode:
Diffstat (limited to 'src/python/botan.py')
-rwxr-xr-xsrc/python/botan.py246
1 files changed, 185 insertions, 61 deletions
diff --git a/src/python/botan.py b/src/python/botan.py
index a28f3ddb0..04e574746 100755
--- a/src/python/botan.py
+++ b/src/python/botan.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python2
"""
Python wrapper of the botan crypto library
@@ -29,6 +29,40 @@ botan_api_rev = botan.botan_ffi_api_version()
if botan_api_rev != expected_api_rev:
raise Exception("Bad botan API rev got %d expected %d" % (botan_api_rev, expected_api_rev))
+# Internal utilities
+def _call_fn_returning_string(guess, fn):
+
+ buf = create_string_buffer(guess)
+ 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_string(buf_len.value, fn)
+ else:
+ raise Exception("Call failed: %d" % (rc))
+
+ assert buf_len.value <= len(buf)
+ return str(buf.raw[0:buf_len.value])
+
+def _call_fn_returning_vec(guess, fn):
+
+ buf = create_string_buffer(guess)
+ 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 Exception("Call failed: %d" % (rc))
+
+ assert buf_len.value <= len(buf)
+ return buf.raw[0:buf_len.value]
+
+
"""
Versions
"""
@@ -57,7 +91,7 @@ class rng(object):
rc = botan.botan_rng_init(byref(self.rng), rng_type)
else:
rc = botan.botan_rng_init(byref(self.rng), rng_type.encode('ascii'))
-
+
if rc != 0 or self.rng is None:
raise Exception("No rng " + algo + " for you!")
@@ -256,7 +290,6 @@ class cipher(object):
"""
Bcrypt
-TODO: might not be enabled - handle that gracefully!
"""
def bcrypt(passwd, rng, work_factor = 10):
botan.botan_bcrypt_generate.argtypes = [POINTER(c_char), POINTER(c_size_t),
@@ -322,12 +355,17 @@ class public_key(object):
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))
- buf = create_string_buffer(64)
- buf_len = c_size_t(len(buf))
- botan.botan_pubkey_algo_name(self.pubkey, buf, byref(buf_len))
- assert buf_len.value <= len(buf)
- return buf.raw[0:buf_len.value]
+ 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
+
+ if pem:
+ return _call_fn_returning_string(0, lambda b,bl: botan.botan_pubkey_export(self.pubkey, b, bl, 1))
+ else:
+ return _call_fn_returning_string(0, lambda b,bl: botan.botan_pubkey_export(self.pubkey, b, bl, 0))
def fingerprint(self, hash = 'SHA-256'):
botan.botan_pubkey_fingerprint.argtypes = [c_void_p, c_char_p,
@@ -338,7 +376,7 @@ class public_key(object):
buf_len = c_size_t(n)
if sys.version_info[0] > 2:
hash = hash.encode('utf-8')
-
+
botan.botan_pubkey_fingerprint(self.pubkey, hash, buf, byref(buf_len))
return hexlify(buf[0:buf_len.value])
@@ -347,6 +385,7 @@ class private_key(object):
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]
self.privkey = c_void_p(0)
if alg == 'rsa':
@@ -355,6 +394,8 @@ class private_key(object):
botan.botan_privkey_create_ecdsa(byref(self.privkey), rng.rng, param)
elif alg == 'ecdh':
botan.botan_privkey_create_ecdh(byref(self.privkey), rng.rng, param)
+ elif alg in ['mce', 'mceliece']:
+ botan.botan_privkey_create_mceliece(byref(self.privkey), rng.rng, param[0], param[1])
else:
raise Exception('Unknown public key algo ' + alg)
@@ -385,7 +426,6 @@ class private_key(object):
botan.botan_privkey_export(self.privkey, buf, byref(buf_len))
return buf[0:buf_len.value]
-
class pk_op_encrypt(object):
def __init__(self, key, padding):
botan.botan_pk_op_encrypt_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32]
@@ -417,7 +457,7 @@ class pk_op_encrypt(object):
#print("encrypt: outbuf_sz.value=%d" % outbuf_sz.value)
return outbuf.raw[0:outbuf_sz.value]
-
+
class pk_op_decrypt(object):
def __init__(self, key, padding):
botan.botan_pk_op_decrypt_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32]
@@ -497,6 +537,24 @@ class pk_op_verify(object):
return True
return False
+"""
+MCEIES encryption
+Must be used with McEliece keys
+"""
+def mceies_encrypt(mce, rng, 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_string(0, lambda b,bl:
+ botan.botan_mceies_encrypt(mce.pubkey, rng.rng, aead, pt, len(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)]
+
+ return _call_fn_returning_string(0, lambda b,bl:
+ botan.botan_mceies_decrypt(mce.privkey, aead, pt, len(pt), ad, len(ad), b, bl))
+
class pk_op_key_agreement(object):
def __init__(self, key, kdf):
botan.botan_pk_op_key_agreement_create.argtypes = [c_void_p, c_void_p, c_char_p, c_uint32]
@@ -507,10 +565,7 @@ class pk_op_key_agreement(object):
if not self.op:
raise Exception("No key agreement for you")
- pub = create_string_buffer(4096)
- pub_len = c_size_t(len(pub))
- botan.botan_pk_op_key_agreement_export_public(key.privkey, pub, byref(pub_len))
- self.m_public_value = pub.raw[0:pub_len.value]
+ self.m_public_value = _call_fn_returning_string(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]
@@ -523,28 +578,73 @@ class pk_op_key_agreement(object):
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]
- outbuf_sz = c_size_t(key_len)
- outbuf = create_string_buffer(outbuf_sz.value)
- rc = botan.botan_pk_op_key_agreement(self.op, outbuf, byref(outbuf_sz),
- other, len(other), salt, len(salt))
+ return _call_fn_returning_string(key_len,
+ lambda b,bl: botan.botan_pk_op_key_agreement(self.op, b, bl,
+ other, len(other),
+ salt, len(salt)))
+
+class x509_cert(object):
+ def __init__(self, filename):
+ botan.botan_x509_cert_load_file.argtypes = [POINTER(c_void_p), c_char_p]
+ self.x509_cert = c_void_p(0)
+ if sys.version_info[0] > 2:
+ filename = cast(filename, c_char_p)
+ botan.botan_x509_cert_load_file(byref(self.x509_cert), filename)
+
+ def __del__(self):
+ botan.botan_x509_cert_destroy.argtypes = [c_void_p]
+ botan.botan_x509_cert_destroy(self.x509_cert)
+
+ # TODO: have these convert to a python datetime
+ def time_starts(self):
+ botan.botan_x509_cert_get_time_starts.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)]
+ return _call_fn_returning_string(16, lambda b,bl: botan.botan_x509_cert_get_time_starts(self.x509_cert, b, bl))
+
+ def time_expires(self):
+ botan.botan_x509_cert_get_time_expires.argtypes = [c_void_p, POINTER(c_char), POINTER(c_size_t)]
+ return _call_fn_returning_string(16, lambda b,bl: botan.botan_x509_cert_get_time_expires(self.x509_cert, b, bl))
+
+ 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))
+
+ 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
+ if sys.version_info[0] > 2:
+ hash_algo = hash_algo.encode('utf-8')
+
+ return _call_fn_returning_string(n, lambda b,bl: botan.botan_x509_cert_get_fingerprint(self.x509_cert, 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))
+
+ 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))
+
+ 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))
+
+ 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))
- if rc == -1 and outbuf_sz.value > len(outbuf):
- outbuf = create_string_buffer(outbuf_sz.value)
- botan.botan_pk_op_key_agreement(self.op, outbuf, byref(outbuf_sz),
- other, len(other), salt, len(salt))
- return outbuf.raw[0:outbuf_sz.value]
"""
Tests and examples
"""
def test():
- r = rng("user")
+ r = rng("user")
print("\n%s" % version_string().decode('utf-8'))
print("v%d.%d.%d\n" % (version_major(), version_minor(), version_patch()))
-
print("KDF2(SHA-1) %s" %
hexlify(kdf('KDF2(SHA-1)'.encode('ascii'), unhexlify('701F3480DFE95F57941F804B1B2413EF'), 7,
unhexlify('55A4E9DD5F4CA2EF82'))
@@ -559,18 +659,12 @@ def test():
print("good output %s\n" %
'59B2B1143B4CB1059EC58D9722FB1C72471E0D85C6F7543BA5228526375B0127')
-
-
(salt,iterations,psk) = pbkdf_timed('PBKDF2(SHA-256)'.encode('ascii'),
'xyz'.encode('utf-8'), 32, 200)
- if sys.version_info[0] < 3:
- print("PBKDF2(SHA-256) x=timed, y=iterated; salt = %s (len=%d) #iterations = %d\n" %
- (hexlify(salt), len(salt), iterations) )
- else:
- print("PBKDF2(SHA-256) x=timed, y=iterated; salt = %s (len=%d) #iterations = %d\n" %
- (hexlify(salt).decode('ascii'), len(salt), iterations) )
-
+ print("PBKDF2(SHA-256) x=timed, y=iterated; salt = %s (len=%d) #iterations = %d\n" %
+ (hexlify(salt).decode('ascii'), len(salt), iterations))
+
print('x %s' % hexlify(psk).decode('utf-8'))
print('y %s\n' %
(hexlify(pbkdf('PBKDF2(SHA-256)'.encode('utf-8'),
@@ -579,7 +673,7 @@ def test():
hmac = message_authentication_code('HMAC(SHA-256)'.encode('ascii'))
hmac.set_key(unhexlify('0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20'))
hmac.update(unhexlify('616263'))
-
+
hmac_output = hmac.final()
if hmac_output != unhexlify('A21B1F5D4CF4F73A4DD939750F7A066A7F98CC131CB16A6692759021CFAB8181'):
@@ -587,7 +681,7 @@ def test():
print("vs good: \tA21B1F5D4CF4F73A4DD939750F7A066A7F98CC131CB16A6692759021CFAB8181");
else:
print("HMAC output (good): %s\n" % hexlify(hmac_output).decode('utf-8'))
-
+
print("rng output:\n\t%s\n\t%s\n\t%s\n" %
(hexlify(r.get(42)).decode('utf-8'),
hexlify(r.get(13)).decode('utf-8'),
@@ -642,13 +736,31 @@ def test():
print("OCB pt %s %d" % (hexlify(pt).decode('utf-8'), len(pt)))
print("OCB de %s %d\n" % (hexlify(dec).decode('utf-8'), len(dec)))
+
+ mce_priv = private_key('mce', [2960,57], r)
+ mce_pub = mce_priv.get_public_key()
+
+ mce_plaintext = 'mce plaintext'
+ mce_ad = 'mce AD'
+ mce_ciphertext = mceies_encrypt(mce_pub, r, 'ChaCha20Poly1305', mce_plaintext, mce_ad)
+
+ print "mce", len(mce_plaintext), len(mce_ciphertext)
+
+ mce_decrypt = mceies_decrypt(mce_priv, 'ChaCha20Poly1305', mce_ciphertext, mce_ad)
+
+ print("mce_pub %s/SHA-1 fingerprint: %s (estimated strength %s) (len %d)" %
+ (mce_pub.algo_name().decode('utf-8'), mce_pub.fingerprint("SHA-1").decode('utf-8'),
+ mce_pub.estimated_strength(), len(mce_pub.encoding())
+ )
+ )
+
rsapriv = private_key('rsa', 1536, r)
rsapub = rsapriv.get_public_key()
-
- print("rsapub %s/SHA-1 fingerprint: %s (estimated strength %s)" %
+
+ print("rsapub %s SHA-1 fingerprint: %s estimated strength %d len %d" %
(rsapub.algo_name().decode('utf-8'), rsapub.fingerprint("SHA-1").decode('utf-8'),
- rsapub.estimated_strength()
+ rsapub.estimated_strength(), len(rsapub.encoding())
)
)
@@ -656,7 +768,7 @@ def test():
enc = pk_op_encrypt(rsapub, "EME1(SHA-256)".encode('utf-8'))
ctext = enc.encrypt('foof'.encode('utf-8'), r)
- print("ptext \'%s\'" % 'foof')
+ print("ptext \'%s\'" % 'foof')
print("ctext \'%s\'" % hexlify(ctext).decode('utf-8'))
print("decrypt \'%s\'\n" % dec.decrypt(ctext).decode('utf-8'))
@@ -669,7 +781,7 @@ def test():
r.reseed(200)
print("EMSA4(SHA-384) signature: %s" % hexlify(sig).decode('utf-8'))
-
+
verify = pk_op_verify(rsapub, 'EMSA4(SHA-384)'.encode('utf-8'))
verify.update('mess'.encode('utf-8'))
@@ -683,32 +795,44 @@ def test():
verify.update('message'.encode('utf-8'))
print("good sig accepted? %s\n" % verify.check_signature(sig))
- dh_grp = 'secp256r1'.encode('utf-8')
- #dh_grp = 'curve25519'.encode('utf-8')
- dh_kdf = 'KDF2(SHA-384)'.encode('utf-8')
- a_dh_priv = private_key('ecdh', dh_grp, r)
- a_dh_pub = a_dh_priv.get_public_key()
+ for dh_grps in ['secp256r1', 'curve25519']:
+ dh_grp = dh_grps.encode('utf-8')
+ dh_kdf = 'KDF2(SHA-384)'.encode('utf-8')
+ a_dh_priv = private_key('ecdh', dh_grp, r)
+ a_dh_pub = a_dh_priv.get_public_key()
+
+ b_dh_priv = private_key('ecdh', dh_grp, r)
+ b_dh_pub = b_dh_priv.get_public_key()
+
+ a_dh = pk_op_key_agreement(a_dh_priv, dh_kdf)
+ b_dh = pk_op_key_agreement(b_dh_priv, dh_kdf)
+
+ print("ecdh %s pubs:\n %s\n %s\n" %
+ (dh_grps,
+ hexlify(a_dh.public_value()).decode('utf-8'),
+ hexlify(b_dh.public_value()).decode('utf-8')))
- b_dh_priv = private_key('ecdh', dh_grp, r)
- b_dh_pub = b_dh_priv.get_public_key()
+ a_key = a_dh.agree(b_dh.public_value(), 20, 'salt'.encode('utf-8'))
+ b_key = b_dh.agree(a_dh.public_value(), 20, 'salt'.encode('utf-8'))
- a_dh = pk_op_key_agreement(a_dh_priv, dh_kdf)
- b_dh = pk_op_key_agreement(b_dh_priv, dh_kdf)
+ print("ecdh %s shared:\n %s\n %s\n" %
+ (dh_grps, hexlify(a_key).decode('utf-8'), hexlify(b_key).decode('utf-8')))
- print("ecdh pubs:\n %s\n %s\n" %
- (hexlify(a_dh.public_value()).decode('utf-8'),
- hexlify(b_dh.public_value()).decode('utf-8')))
+ cert = x509_cert("src/tests/data/ecc/CSCA.CSCA.csca-germany.1.crt")
+ print(cert.fingerprint("SHA-1"))
+ print("32:42:1C:C3:EC:54:D7:E9:43:EC:51:F0:19:23:BD:85:1D:F2:1B:B9")
- a_key = a_dh.agree(b_dh.public_value(), 20, 'salt'.encode('utf-8'))
- b_key = b_dh.agree(a_dh.public_value(), 20, 'salt'.encode('utf-8'))
+ print(cert.time_starts())
+ print(cert.time_expires())
- print("ecdh shared:\n %s\n %s\n" %
- (hexlify(a_key).decode('utf-8'), hexlify(b_key).decode('utf-8')))
+ print(hexlify(cert.serial_number()))
+ print(hexlify(cert.authority_key_id()))
+ print(hexlify(cert.subject_key_id()))
+ print(hexlify(cert.subject_public_key_bits()))
+ print(cert.to_string())
- #f = open('key.ber','wb')
- #f.write(blob)
- #f.close()
+ return
def main(args = None):