From ae162109397dc68bbc68fa0c22331427628f6942 Mon Sep 17 00:00:00 2001 From: Larry Bugbee Date: Thu, 17 Aug 2017 21:06:50 -0700 Subject: [PATCH] Delete demo_dynamic.py --- demos/demo_dynamic.py | 281 ------------------------------------------ 1 file changed, 281 deletions(-) delete mode 100644 demos/demo_dynamic.py diff --git a/demos/demo_dynamic.py b/demos/demo_dynamic.py deleted file mode 100644 index 51aaf33..0000000 --- a/demos/demo_dynamic.py +++ /dev/null @@ -1,281 +0,0 @@ - - -""" - demo_dynamic.py v2b - - 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 a math library. 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 tight coupling between otherwise independent libraries.) - - My .dylib was created on OSX/macOS with the following: - sudo make -j5 -f makefile.shared \ - CFLAGS="-DUSE_TFM -DTFM_DESC -I/usr/local/include" \ - EXTRALIBS=/usr/local/lib/libtfm.a install - - For python 2.7.12 on Ubuntu Xenial the following worked for - me (without MPI support): - sudo make -f makefile.shared install PREFIX="/usr" - - Reminder: you don't need to bind in a math library unless - you are going to use LTC functions that need a - mathlib. For example, public key crypto requires - a mathlib; hashing and symmetric encryption do not. - - This code was written for Python 2.7 with the ctypes standard - library. - - Larry Bugbee - March 2014 v1 - August 2017 v2b - -""" - - -from ctypes import * -from ctypes.util import find_library - -# switches to enable/disable selected output -SHOW_ALL_CONSTANTS = True -SHOW_ALL_SIZES = True -SHOW_SELECTED_CONSTANTS = True -SHOW_SELECTED_SIZES = True -SHOW_BUILD_OPTIONS_ALGS = True -SHOW_SHA256_EXAMPLE = True -SHOW_CHACHA_EXAMPLE = True - -print -print(' demo_dynamic.py') - - -#------------------------------------------------------------------------------- -# load the .dylib - -libname = 'tomcrypt' -libpath = find_library(libname) -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 SHOW_ALL_CONSTANTS: - print '-'*60 - 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 to build list \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 SHOW_ALL_SIZES: - print '-'*60 - 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 to build list \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 - -if SHOW_SELECTED_CONSTANTS: - print '-'*60 - print '\n selected constants:' - - names = [ - 'ENDIAN_LITTLE', - 'ENDIAN_64BITWORD', - '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 - -if SHOW_SELECTED_SIZES: - print '-'*60 - print '\n selected sizes:' - - names = [ - 'rijndael_key', - 'rsa_key', - 'symmetric_CTR', - 'twofish_key', - 'ecc_point', - 'gcm_state', - 'sha512_state', - ] - 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) - print - - -#------------------------------------------------------------------------------- -#------------------------------------------------------------------------------- -# LibTomCrypt exposes one interesting string that can be accessed -# via Python's ctypes module, "crypt_build_settings", which -# provides a list of this build's compiler switches and supported -# algorithms. If someday LTC exposes other interesting strings, -# they can be found with: -# nm /usr/local/lib/libtomcrypt.dylib | grep " D " - -def get_named_string(lib, name): - return c_char_p.in_dll(lib, name).value - -if SHOW_BUILD_OPTIONS_ALGS: - print '-'*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') - - -#------------------------------------------------------------------------------- -#------------------------------------------------------------------------------- -# here is an example of how Python code can be written to access -# LTC's implementation of SHA256 and ChaCha, - -# - - - - - - - - - - - - - -# definitions - -def _get_size(name): - size = c_int(0) - rc = LTC.crypt_get_size(name, byref(size)) - if rc != 0: - raise Exception('LTC.crypt_get_size(%s) rc = %d' % (name, rc)) - return size.value - -def _get_constant(name): - constant = c_int(0) - rc = LTC.crypt_get_constant(name, byref(constant)) - if rc != 0: - raise Exception('LTC.crypt_get_constant(%s) rc = %d' % (name, rc)) - return constant.value - -def _err2str(err): - # define return type - errstr = LTC.error_to_string - errstr.restype = c_char_p - # get and return err string - return errstr(err) - -CRYPT_OK = _get_constant('CRYPT_OK') - -class SHA256(object): - def __init__(self): - self.state = c_buffer(_get_size('sha256_state')) - 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 - -class ChaCha(object): - def __init__(self, key, rounds): - self.state = c_buffer(_get_size('chacha_state')) - self.counter = c_int(1) - err = LTC.chacha_setup(byref(self.state), key, len(key), rounds) - if err != CRYPT_OK: - raise Exception('LTC.chacha_setup(), err = %d, "%s"' % (err, _err2str(err))) - def set_iv32(self, iv): - err = LTC.chacha_ivctr32(byref(self.state), iv, len(iv), byref(self.counter)) - if err != CRYPT_OK: - raise Exception('LTC.chacha_ivctr32(), err = %d, "%s"' % (err, _err2str(err))) - def crypt(self, datain): - dataout = c_buffer(len(datain)) - err = LTC.chacha_crypt(byref(self.state), datain, len(datain), byref(dataout)) - if err != CRYPT_OK: - raise Exception('LTC.chacha_crypt(), err = %d, "%s"' % (err, _err2str(err))) - return dataout.raw - -# - - - - - - - - - - - - - -# a SHA256 app fragment - -# from wrapper import * # uncomment in real life - -if SHOW_SHA256_EXAMPLE: - print '-'*60 - data = 'hello world' - - sha256 = SHA256() - sha256.update(data) - md = sha256.digest() - - template = '\n the SHA256 digest for "%s" is %s \n' - print template % (data, md.encode('hex')) - -# - - - - - - - - - - - - - -# a ChaCha app fragment - -if SHOW_CHACHA_EXAMPLE: - print '-'*60 - key = 'hownowbrowncow\x00\x00' # exactly 16 or 32 bytes - rounds = 12 # common values: 8, 12, 20 - iv = '123456789012' # exactly 12 bytes - plain = 'Kilroy was here, there, and everywhere!' - - cha = ChaCha(key, rounds) - cha.set_iv32(iv) - cipher = cha.crypt(plain) - - template = '\n ChaCha%d ciphertext for "%s" is "%s"' - print template % (rounds, plain, cipher.encode('hex')) - - # reset to decrypt - cha.set_iv32(iv) - decrypted = cha.crypt(cipher) - - template = ' ChaCha%d decoded text for "%s" is "%s" \n' - print template % (rounds, plain, decrypted) - -# Footnote: Keys should be erased fm memory as soon as possible after use, -# and that includes Python. For a tip on how to do that in Python, see -# http://buggywhip.blogspot.com/2010/12/erase-keys-and-credit-card-numbers-in.html - -#------------------------------------------------------------------------------- -#------------------------------------------------------------------------------- -#-------------------------------------------------------------------------------