libtom.libtomcrypt/demos/demo_dynamic.py

""" 
    demo_dynamic.py                                     v1
    
    This program demonstrates Python's use of the dynamic 
    language support additions to LTC, namely access to LTC 
    constants, struct and union sizes, and the binding of a 
    math package to LTC.  Also provided are simple code 
    fragments to illustrate how one might write a Python 
    wrapper for LTC and how an app might call the wrapper. 
    This or a similar model should work for Ruby and other 
    dynamic languages.
    
    This instance uses Python's ctypes and requires a single 
    .dylib linking together LTC and one or more math libraries.  
    Building a single .dylib is needed because LTC wants a 
    fairly tight relationship between itself and the mathlib. 
    (ctypes can load multiple .dylibs, but it does not support 
    this level of coupling between those independent libraries.)
    
    My .dylib was created on OSX with the following steps:
      
      1- compile LTC to a .a static lib:
           CFLAGS="-DLTM_DESC -DUSE_LTM -DTFM_DESC -DUSE_TFM \
                   -I/usr/local/include" make
      
      2- link LTC, LTM and TFM into a single .dylib:
           ar2dylib_with_and  tomcrypt  tommath  tfm
         where ar2dylib_with_and is a shell script that combines 
         the .a with .dylibs for LTM and TFM
    
    Reminder: you don't need to bind in a math library unless
              you are going to use LTC functions that depend 
              on a mathlib.  For example, public key crypto 
              needs a mathlib; hashing and symmetric encryption 
              does not.
    
    Larry Bugbee
    March 2014

"""


from ctypes import *
from ctypes.util import find_library


#---------------------------------------------------------------
# load the .dylib

libname = 'tomcrypt'
libpath = find_library(libname)

print
print('  demo_dynamic.py')
print
print('  path to library %s: %s' % (libname, libpath))

LTC = cdll.LoadLibrary(libpath)
print('  loaded: %s' % LTC)
print



#---------------------------------------------------------------
# get list of all supported constants followed by a list of all 
# supported sizes.  One alternative: these lists may be parsed 
# and used as needed.

if 1:
    print '  all supported constants and their values:'
    
    # get size to allocate for constants output list
    str_len = c_int(0)
    ret = LTC.crypt_list_all_constants(None, byref(str_len))
    print '    need to allocate %d bytes \n' % str_len.value
    
    # allocate that size and get (name, size) pairs, each pair
    # separated by a newline char.
    names_sizes = c_buffer(str_len.value)
    ret = LTC.crypt_list_all_constants(names_sizes, byref(str_len))
    print names_sizes.value
    print
    
    
if 1:
    print '  all supported sizes:'
    
    # get size to allocate for sizes output list
    str_len = c_int(0)
    ret = LTC.crypt_list_all_sizes(None, byref(str_len))
    print '    need to allocate %d bytes \n' % str_len.value
    
    # allocate that size and get (name, size) pairs, each pair
    # separated by a newline char.
    names_sizes = c_buffer(str_len.value)
    ret = LTC.crypt_list_all_sizes(names_sizes, byref(str_len))
    print names_sizes.value
    print


#---------------------------------------------------------------
# get individually named constants and sizes

# print selected constants
if 1:
    print '\n  selected constants:'
    
    names = [
        'PK_PUBLIC',
        'MAX_RSA_SIZE',
        'CTR_COUNTER_BIG_ENDIAN',
    ]
    for name in names:
        const_value = c_int(0)
        rc = LTC.crypt_get_constant(name, byref(const_value))
        value = const_value.value
        print '    %-25s  %d' % (name, value)

# print selected sizes
if 1:
    print '\n  selected sizes:'
    
    names = [
        'rijndael_key_struct_size',
        'rsa_key_struct_size',
        'symmetric_CTR_struct_size',
        'twofish_key_struct_size',
        'ecc_point_struct_size',
        'gcm_state_struct_size',
        'sha512_state_struct_size',
    ]
    for name in names:
        size_value = c_int(0)
        rc = LTC.crypt_get_size(name, byref(size_value))
        value = size_value.value
        print '    %-25s  %d' % (name, value)


#---------------------------------------------------------------
# init the selected math package, change to another mathlib, 
# and change back to the first mathlib

if 1:
    print '\n  init the selected math package, change, and change again'
    
    # show ltm_desc
    ptr = c_int.in_dll(LTC, 'ltm_desc')
    print '    ltm_desc:   ', hex(ptr.value)
    # show tfm_desc
    ptr = c_int.in_dll(LTC, 'tfm_desc')
    print '    tfm_desc:   ', hex(ptr.value)
    # let's see the initial value of ltc_mp
    ptr = c_int.in_dll(LTC, 'ltc_mp')
    print '    initial ptr:', hex(ptr.value)
    
    # init LTM and show ltc_mp
    LTC.init_LTM()
    ptr = c_int.in_dll(LTC, 'ltc_mp')
    print '    ptr to LTM: ', hex(ptr.value)
    
    # init TFM and show ltc_mp
    LTC.init_TFM()
    ptr = c_int.in_dll(LTC, 'ltc_mp')
    print '    ptr to TFM: ', hex(ptr.value)
    
    # now change back to LTM
    LTC.init_LTM()
    ptr = c_int.in_dll(LTC, 'ltc_mp')
    print '    ptr to LTM: ', hex(ptr.value)



#---------------------------------------------------------------
#---------------------------------------------------------------
# ctypes getting a list of this build's supported algorithms 
# and compiler switches

def get_named_string(lib, name):
    return c_char_p.in_dll(lib, name).value

if 0:
    print '\n%s' % ('-'*60)
    print 'This is a string compiled into LTC showing compile '
    print 'options and algorithms supported by this build \n'
    print get_named_string(LTC, 'crypt_build_settings')
    print



#---------------------------------------------------------------
#---------------------------------------------------------------
# here is an example of how a wrapper can make Python access 
# more Pythonic

# - - - - - - - - - - - - -
# a wrapper fragment...

def _get_size(name):
    size = c_int(0)
    rc = LTC.crypt_get_size(name, byref(size))
    return size.value

sha256_state_struct_size = _get_size('sha256_state_struct_size')
sha512_state_struct_size = _get_size('sha512_state_struct_size')

class SHA256(object):
    def __init__(self):
        self.state = c_buffer(sha256_state_struct_size)
        LTC.sha256_init(byref(self.state))
    def update(self, data):
        LTC.sha256_process(byref(self.state), data, len(data))
    def digest(self):
        md = c_buffer(32)
        LTC.sha256_done(byref(self.state), byref(md))
        return md.raw

# - - - - - - - - - - - - -
# an app fragment...

# from wrapper import *         # uncomment in real life

data = 'hello world'

sha256 = SHA256()
sha256.update(data)
md = sha256.digest()

template = '\n\n  the SHA256 digest for "%s" is %s \n'
print template % (data, md.encode('hex'))



#---------------------------------------------------------------
#---------------------------------------------------------------
#---------------------------------------------------------------