diff options
Diffstat (limited to 'src/tomcrypt/cipher.nim')
| -rw-r--r-- | src/tomcrypt/cipher.nim | 1113 |
1 files changed, 1113 insertions, 0 deletions
diff --git a/src/tomcrypt/cipher.nim b/src/tomcrypt/cipher.nim new file mode 100644 index 0000000..f798cf6 --- /dev/null +++ b/src/tomcrypt/cipher.nim @@ -0,0 +1,1113 @@ +## LibTomCrypt, modular cryptographic library -- Tom St Denis +## +## LibTomCrypt is a library that provides various cryptographic +## algorithms in a highly modular and flexible manner. +## +## The library is free for all purposes without any express +## guarantee it works. +## +## ---- SYMMETRIC KEY STUFF ----- +## +## We put each of the ciphers scheduled keys in their own structs then we put all of +## the key formats in one union. This makes the function prototypes easier to use. +## + +const LTC_BLOWFISH = 1 +const LTC_RC5 = 1 +const LTC_RC6 = 1 +const LTC_SAFERP = 1 +const LTC_RIJNDAEL = 1 +const LTC_KSEED = 1 +const LTC_KASUMI = 1 +const LTC_XTEA = 1 +const LTC_TWOFISH = 1 +const LTC_SAFER = 1 +const LTC_RC2 = 1 +const LTC_DES = 1 +const LTC_CAST5 = 1 +const LTC_NOEKEON = 1 +const LTC_SKIPJACK = 1 +const LTC_KHAZAD = 1 +const LTC_ANUBIS = 1 +const LTC_MULTI2 = 1 +const LTC_CAMELLIA = 1 +const LTC_ECB_MODE = 1 +const LTC_CFB_MODE = 1 +const LTC_OFB_MODE = 1 +const LTC_CBC_MODE = 1 +const LTC_CTR_MODE = 1 +const LTC_LRW_MODE = 1 +const LTC_F8_MODE = 1 +const LTC_XTS_MODE = 1 +const LTC_CHACHA = 1 +const LTC_RC4_STREAM = 1 +const LTC_SOBER128_STREAM = 1 + +when declared(LTC_BLOWFISH): + type + blowfish_key* {.bycopy.} = object + S*: array[4, array[256, ulong32]] + K*: array[18, ulong32] + +when declared(LTC_RC5): + type + rc5_key* {.bycopy.} = object + rounds*: cint + K*: array[50, ulong32] + +when declared(LTC_RC6): + type + rc6_key* {.bycopy.} = object + K*: array[44, ulong32] + +when declared(LTC_SAFERP): + type + saferp_key* {.bycopy.} = object + K*: array[33, array[16, cuchar]] + rounds*: clong + +when declared(LTC_RIJNDAEL): + type + rijndael_key* {.bycopy.} = object + eK*: array[60, ulong32] + dK*: array[60, ulong32] + Nr*: cint + +when declared(LTC_KSEED): + type + kseed_key* {.bycopy.} = object + K*: array[32, ulong32] + dK*: array[32, ulong32] + +when declared(LTC_KASUMI): + type + kasumi_key* {.bycopy.} = object + KLi1*: array[8, ulong32] + KLi2*: array[8, ulong32] + KOi1*: array[8, ulong32] + KOi2*: array[8, ulong32] + KOi3*: array[8, ulong32] + KIi1*: array[8, ulong32] + KIi2*: array[8, ulong32] + KIi3*: array[8, ulong32] + +when declared(LTC_XTEA): + type + xtea_key* {.bycopy.} = object + A*: array[32, culong] + B*: array[32, culong] + +when declared(LTC_TWOFISH): + when not defined(LTC_TWOFISH_SMALL): + type + twofish_key* {.bycopy.} = object + S*: array[4, array[256, ulong32]] + K*: array[40, ulong32] + + else: + type + twofish_key* {.bycopy.} = object + K*: array[40, ulong32] + S*: array[32, cuchar] + start*: cuchar + +when declared(LTC_SAFER): + const + LTC_SAFER_K64_DEFAULT_NOF_ROUNDS* = 6 + LTC_SAFER_K128_DEFAULT_NOF_ROUNDS* = 10 + LTC_SAFER_SK64_DEFAULT_NOF_ROUNDS* = 8 + LTC_SAFER_SK128_DEFAULT_NOF_ROUNDS* = 10 + LTC_SAFER_MAX_NOF_ROUNDS* = 13 + LTC_SAFER_BLOCK_LEN* = 8 + LTC_SAFER_KEY_LEN* = ( + 1 + LTC_SAFER_BLOCK_LEN * (1 + 2 * LTC_SAFER_MAX_NOF_ROUNDS)) + type + safer_block_t* = array[LTC_SAFER_BLOCK_LEN, cuchar] + safer_key_t* = array[LTC_SAFER_KEY_LEN, cuchar] + type + safer_key* {.bycopy.} = object + key*: safer_key_t + +when declared(LTC_RC2): + type + rc2_key* {.bycopy.} = object + xkey*: array[64, cuint] + +when declared(LTC_DES): + type + des_key* {.bycopy.} = object + ek*: array[32, ulong32] + dk*: array[32, ulong32] + + type + des3_key* {.bycopy.} = object + ek*: array[3, array[32, ulong32]] + dk*: array[3, array[32, ulong32]] + +when declared(LTC_CAST5): + type + cast5_key* {.bycopy.} = object + K*: array[32, ulong32] + keylen*: ulong32 + +when declared(LTC_NOEKEON): + type + noekeon_key* {.bycopy.} = object + K*: array[4, ulong32] + dK*: array[4, ulong32] + +when declared(LTC_SKIPJACK): + type + skipjack_key* {.bycopy.} = object + key*: array[10, cuchar] + +when declared(LTC_KHAZAD): + type + khazad_key* {.bycopy.} = object + roundKeyEnc*: array[8 + 1, ulong64] + roundKeyDec*: array[8 + 1, ulong64] + +when declared(LTC_ANUBIS): + type + anubis_key* {.bycopy.} = object + keyBits*: cint + R*: cint + roundKeyEnc*: array[18 + 1, array[4, ulong32]] + roundKeyDec*: array[18 + 1, array[4, ulong32]] + +when declared(LTC_MULTI2): + type + multi2_key* {.bycopy.} = object + N*: cint + uk*: array[8, ulong32] + +when declared(LTC_CAMELLIA): + type + camellia_key* {.bycopy.} = object + R*: cint + kw*: array[4, ulong64] + k*: array[24, ulong64] + kl*: array[6, ulong64] + +type + symmetric_key* {.bycopy.} = object {.union.} + des*: des_key + des3*: des3_key + rc2*: rc2_key + safer*: safer_key + twofish*: twofish_key + blowfish*: blowfish_key + rc5*: rc5_key + rc6*: rc6_key + saferp*: saferp_key + rijndael*: rijndael_key + xtea*: xtea_key + cast5*: cast5_key + noekeon*: noekeon_key + skipjack*: skipjack_key + khazad*: khazad_key + anubis*: anubis_key + kseed*: kseed_key + kasumi*: kasumi_key + multi2*: multi2_key + camellia*: camellia_key + data*: pointer + + +when declared(LTC_ECB_MODE): + ## * A block cipher ECB structure + type + symmetric_ECB* {.bycopy.} = object + cipher*: cint ## * The index of the cipher chosen + ## * The block size of the given cipher + blocklen*: cint ## * The scheduled key + key*: symmetric_key + +when declared(LTC_CFB_MODE): + ## * A block cipher CFB structure + type + symmetric_CFB* {.bycopy.} = object + cipher*: cint ## * The index of the cipher chosen + ## * The block size of the given cipher + blocklen*: cint ## * The padding offset + padlen*: cint ## * The current IV + IV*: array[MAXBLOCKSIZE, cuchar] ## * The pad used to encrypt/decrypt + pad*: array[MAXBLOCKSIZE, cuchar] ## * The scheduled key + key*: symmetric_key + +when declared(LTC_OFB_MODE): + ## * A block cipher OFB structure + type + symmetric_OFB* {.bycopy.} = object + cipher*: cint ## * The index of the cipher chosen + ## * The block size of the given cipher + blocklen*: cint ## * The padding offset + padlen*: cint ## * The current IV + IV*: array[MAXBLOCKSIZE, cuchar] ## * The scheduled key + key*: symmetric_key + +when declared(LTC_CBC_MODE): + ## * A block cipher CBC structure + type + symmetric_CBC* {.bycopy.} = object + cipher*: cint ## * The index of the cipher chosen + ## * The block size of the given cipher + blocklen*: cint ## * The current IV + IV*: array[MAXBLOCKSIZE, cuchar] ## * The scheduled key + key*: symmetric_key + +when declared(LTC_CTR_MODE): + ## * A block cipher CTR structure + type + symmetric_CTR* {.bycopy.} = object + cipher*: cint ## * The index of the cipher chosen + ## * The block size of the given cipher + blocklen*: cint ## * The padding offset + padlen*: cint ## * The mode (endianess) of the CTR, 0==little, 1==big + mode*: cint ## * counter width + ctrlen*: cint ## * The counter + ctr*: array[MAXBLOCKSIZE, cuchar] ## * The pad used to encrypt/decrypt + pad*: array[MAXBLOCKSIZE, cuchar] ## * The scheduled key + key*: symmetric_key + +when declared(LTC_LRW_MODE): + ## * A LRW structure + type + symmetric_LRW* {.bycopy.} = object + cipher*: cint ## * The index of the cipher chosen (must be a 128-bit block cipher) + ## * The current IV + IV*: array[16, cuchar] ## * the tweak key + tweak*: array[16, cuchar] ## * The current pad, it's the product of the first 15 bytes against the tweak key + pad*: array[16, cuchar] ## * The scheduled symmetric key + key*: symmetric_key ## * The pre-computed multiplication table + PC*: array[16, array[256, array[16, cuchar]]] + +when declared(LTC_F8_MODE): + ## * A block cipher F8 structure + type + symmetric_F8* {.bycopy.} = object + cipher*: cint ## * The index of the cipher chosen + ## * The block size of the given cipher + blocklen*: cint ## * The padding offset + padlen*: cint ## * The current IV + IV*: array[MAXBLOCKSIZE, cuchar] + MIV*: array[MAXBLOCKSIZE, cuchar] ## * Current block count + blockcnt*: ulong32 ## * The scheduled key + key*: symmetric_key + +## * cipher descriptor table, last entry has "name == NULL" to mark the end of table + +type + ltc_cipher_descriptor* {.bycopy.} = object + name*: cstring ## * name of cipher + ## * internal ID + ID*: cuchar ## * min keysize (octets) + min_key_length*: cint ## * max keysize (octets) + max_key_length*: cint ## * block size (octets) + block_length*: cint ## * default number of rounds + default_rounds*: cint ## * Setup the cipher + ## @param key The input symmetric key + ## @param keylen The length of the input key (octets) + ## @param num_rounds The requested number of rounds (0==default) + ## @param skey [out] The destination of the scheduled key + ## @return CRYPT_OK if successful + ## + setup*: proc (key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.cdecl.} ## * Encrypt a block + ## @param pt The plaintext + ## @param ct [out] The ciphertext + ## @param skey The scheduled key + ## @return CRYPT_OK if successful + ## + ecb_encrypt*: proc (pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint ## * + ## Decrypt a block + ## + ## @param ct The + ## ciphertext + ## + ## @param pt [out] The + ## plaintext + ## + ## @param skey The + ## scheduled key + ## + ## @return + ## CRYPT_OK if + ## successful + ## + ecb_decrypt*: proc (ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint ## * Test the block + ## cipher + ## + ## @return + ## CRYPT_OK if + ## successful, + ## CRYPT_NOP if + ## self-testing has been + ## disabled + ## + test*: proc (): cint ## * Terminate the context + ## @param skey The scheduled key + ## + done*: proc (skey: ptr symmetric_key) ## * Determine a key size + ## @param keysize [in/out] The size of the key desired and the suggested size + ## @return CRYPT_OK if successful + ## + keysize*: proc (keysize: ptr cint): cint ## * Accelerators * + ## * Accelerated ECB encryption + ## @param pt Plaintext + ## @param ct Ciphertext + ## @param blocks The number of complete blocks to process + ## @param skey The scheduled key context + ## @return CRYPT_OK if successful + ## + accel_ecb_encrypt*: proc (pt: ptr cuchar; ct: ptr cuchar; blocks: culong; + skey: ptr symmetric_key): cint ## * Accelerated ECB decryption + ## @param pt Plaintext + ## @param ct Ciphertext + ## @param blocks The number of complete blocks to process + ## @param skey The scheduled key context + ## @return CRYPT_OK if successful + ## + accel_ecb_decrypt*: proc (ct: ptr cuchar; pt: ptr cuchar; blocks: culong; + skey: ptr symmetric_key): cint ## * Accelerated CBC encryption + ## @param pt Plaintext + ## @param ct Ciphertext + ## @param blocks The number of complete blocks to process + ## @param IV The initial value (input/output) + ## @param skey The scheduled key context + ## @return CRYPT_OK if successful + ## + accel_cbc_encrypt*: proc (pt: ptr cuchar; ct: ptr cuchar; blocks: culong; + IV: ptr cuchar; skey: ptr symmetric_key): cint ## * Accelerated CBC decryption + ## @param pt Plaintext + ## @param ct Ciphertext + ## @param blocks The number of complete blocks to process + ## @param IV The initial value + ## (input/output) + ## @param skey The scheduled key context + ## @return CRYPT_OK if successful + ## + accel_cbc_decrypt*: proc (ct: ptr cuchar; pt: ptr cuchar; blocks: culong; + IV: ptr cuchar; skey: ptr symmetric_key): cint ## * Accelerated CTR encryption + ## @param pt Plaintext + ## @param ct Ciphertext + ## @param blocks The number of complete blocks to process + ## @param IV The initial value + ## (input/output) + ## @param mode little or big endian counter (mode=0 or mode=1) + ## @param skey The scheduled key context + ## @return CRYPT_OK if successful + ## + accel_ctr_encrypt*: proc (pt: ptr cuchar; ct: ptr cuchar; blocks: culong; + IV: ptr cuchar; mode: cint; skey: ptr symmetric_key): cint ## * + ## Accelerated + ## LRW + ## + ## @param pt + ## Plaintext + ## + ## @param ct + ## Ciphertext + ## + ## @param + ## blocks + ## The + ## number of + ## complete + ## blocks to + ## process + ## + ## @param IV + ## The + ## initial + ## value + ## (input/output) + ## + ## @param + ## tweak + ## The + ## LRW + ## tweak + ## + ## @param + ## skey + ## The + ## scheduled + ## key + ## context + ## + ## @return + ## CRYPT_OK if + ## successful + ## + accel_lrw_encrypt*: proc (pt: ptr cuchar; ct: ptr cuchar; blocks: culong; + IV: ptr cuchar; tweak: ptr cuchar; skey: ptr symmetric_key): cint ## + ## * + ## Accelerated + ## LRW + ## + ## @param + ## ct + ## Ciphertext + ## + ## @param + ## pt + ## Plaintext + ## + ## @param + ## blocks + ## The + ## number + ## of + ## complete + ## blocks + ## to + ## process + ## + ## @param + ## IV + ## The + ## initial + ## value + ## (input/output) + ## + ## @param + ## tweak + ## The + ## LRW + ## tweak + ## + ## @param + ## skey + ## The + ## scheduled + ## key + ## context + ## + ## @return + ## CRYPT_OK + ## if + ## successful + ## + accel_lrw_decrypt*: proc (ct: ptr cuchar; pt: ptr cuchar; blocks: culong; + IV: ptr cuchar; tweak: ptr cuchar; skey: ptr symmetric_key): cint ## + ## * + ## Accelerated + ## CCM + ## packet + ## (one-shot) + ## + ## @param + ## key + ## The + ## secret + ## key + ## to + ## use + ## + ## @param + ## keylen + ## The + ## length + ## of + ## the + ## secret + ## key + ## (octets) + ## + ## @param + ## uskey + ## A + ## previously + ## scheduled + ## key + ## [optional + ## can + ## be + ## NULL] + ## + ## @param + ## nonce + ## The + ## session + ## nonce + ## [use + ## once] + ## + ## @param + ## noncelen + ## The + ## length + ## of + ## the + ## nonce + ## + ## @param + ## header + ## The + ## header + ## for + ## the + ## session + ## + ## @param + ## headerlen + ## The + ## length + ## of + ## the + ## header + ## (octets) + ## + ## @param + ## pt + ## [out] + ## The + ## plaintext + ## + ## @param + ## ptlen + ## The + ## length + ## of + ## the + ## plaintext + ## (octets) + ## + ## @param + ## ct + ## [out] + ## The + ## ciphertext + ## + ## @param + ## tag + ## [out] + ## The + ## destination + ## tag + ## + ## @param + ## taglen + ## [in/out] + ## The + ## max + ## size + ## and + ## resulting + ## size + ## of + ## the + ## authentication + ## tag + ## + ## @param + ## direction + ## Encrypt + ## or + ## Decrypt + ## direction + ## (0 + ## or + ## 1) + ## + ## @return + ## CRYPT_OK + ## if + ## successful + ## + accel_ccm_memory*: proc (key: ptr cuchar; keylen: culong; uskey: ptr symmetric_key; + nonce: ptr cuchar; noncelen: culong; header: ptr cuchar; + headerlen: culong; pt: ptr cuchar; ptlen: culong; + ct: ptr cuchar; tag: ptr cuchar; taglen: ptr culong; + direction: cint): cint ## * Accelerated GCM packet (one shot) + ## @param key The secret key + ## @param keylen The length of the secret key + ## @param IV The initialization vector + ## @param IVlen The length of the initialization vector + ## @param adata The additional authentication data (header) + ## @param adatalen The length of the adata + ## @param pt The plaintext + ## @param ptlen The length of the plaintext (ciphertext length is the same) + ## @param ct The ciphertext + ## @param tag [out] The MAC tag + ## @param taglen [in/out] The MAC tag length + ## @param direction Encrypt or Decrypt mode (GCM_ENCRYPT or GCM_DECRYPT) + ## @return CRYPT_OK on success + ## + accel_gcm_memory*: proc (key: ptr cuchar; keylen: culong; IV: ptr cuchar; + IVlen: culong; adata: ptr cuchar; adatalen: culong; + pt: ptr cuchar; ptlen: culong; ct: ptr cuchar; + tag: ptr cuchar; taglen: ptr culong; direction: cint): cint ## * + ## Accelerated + ## one + ## shot + ## LTC_OMAC + ## + ## @param + ## key + ## The + ## secret + ## key + ## + ## @param + ## keylen + ## The + ## key + ## length + ## (octets) + ## + ## @param in + ## The + ## message + ## + ## @param + ## inlen + ## Length of + ## message + ## (octets) + ## + ## @param + ## out + ## [out] + ## Destination + ## for + ## tag + ## + ## @param + ## outlen + ## [in/out] + ## Initial + ## and + ## final + ## size of + ## out + ## + ## @return + ## CRYPT_OK on + ## success + ## + omac_memory*: proc (key: ptr cuchar; keylen: culong; `in`: ptr cuchar; inlen: culong; + `out`: ptr cuchar; outlen: ptr culong): cint ## * Accelerated one shot XCBC + ## @param key The secret key + ## @param keylen The key length (octets) + ## @param in The message + ## @param inlen Length of message (octets) + ## @param out [out] Destination for tag + ## @param outlen [in/out] Initial and final size of out + ## @return CRYPT_OK on success + ## + xcbc_memory*: proc (key: ptr cuchar; keylen: culong; `in`: ptr cuchar; inlen: culong; + `out`: ptr cuchar; outlen: ptr culong): cint ## * Accelerated one shot F9 + ## @param key The secret key + ## @param keylen The key length (octets) + ## @param in The message + ## @param inlen Length of message (octets) + ## @param out [out] Destination for tag + ## @param outlen [in/out] Initial and final size of out + ## @return CRYPT_OK on success + ## @remark Requires manual padding + ## + f9_memory*: proc (key: ptr cuchar; keylen: culong; `in`: ptr cuchar; inlen: culong; + `out`: ptr cuchar; outlen: ptr culong): cint ## * Accelerated XTS encryption + ## @param pt Plaintext + ## @param ct Ciphertext + ## @param blocks The number of complete blocks to process + ## @param tweak The 128-bit encryption tweak (input/output). + ## The tweak should not be encrypted on input, but + ## next tweak will be copied encrypted on output. + ## @param skey1 The first scheduled key context + ## @param skey2 The second scheduled key context + ## @return CRYPT_OK if successful + ## + accel_xts_encrypt*: proc (pt: ptr cuchar; ct: ptr cuchar; blocks: culong; + tweak: ptr cuchar; skey1: ptr symmetric_key; + skey2: ptr symmetric_key): cint ## * Accelerated XTS decryption + ## @param ct Ciphertext + ## @param pt Plaintext + ## @param blocks The number of complete blocks to process + ## @param tweak The 128-bit encryption tweak (input/output). + ## The tweak should not be encrypted on input, but + ## next tweak will be copied encrypted on output. + ## @param skey1 The first scheduled key context + ## @param skey2 The second scheduled key context + ## @return CRYPT_OK if successful + ## + accel_xts_decrypt*: proc (ct: ptr cuchar; pt: ptr cuchar; blocks: culong; + tweak: ptr cuchar; skey1: ptr symmetric_key; + skey2: ptr symmetric_key): cint + +var cipher_descriptor* {.importc: "cipher_descriptor", header:"tomcrypt.h".}: array[1_000_000, ltc_cipher_descriptor] + +when declared(LTC_BLOWFISH): + proc blowfish_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "blowfish_setup", header:"tomcrypt.h".} + proc blowfish_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {. + importc: "blowfish_ecb_encrypt", header:"tomcrypt.h".} + proc blowfish_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {. + importc: "blowfish_ecb_decrypt", header:"tomcrypt.h".} + proc blowfish_test*(): cint {.importc: "blowfish_test", header:"tomcrypt.h".} + proc blowfish_done*(skey: ptr symmetric_key) {.importc: "blowfish_done", header:"tomcrypt.h".} + proc blowfish_keysize*(keysize: ptr cint): cint {.importc: "blowfish_keysize", header:"tomcrypt.h".} + var blowfish_desc* {.importc: "blowfish_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_RC5): + proc rc5_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "rc5_setup", header:"tomcrypt.h".} + proc rc5_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "rc5_ecb_encrypt", header:"tomcrypt.h".} + proc rc5_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "rc5_ecb_decrypt", header:"tomcrypt.h".} + proc rc5_test*(): cint {.importc: "rc5_test", header:"tomcrypt.h".} + proc rc5_done*(skey: ptr symmetric_key) {.importc: "rc5_done", header:"tomcrypt.h".} + proc rc5_keysize*(keysize: ptr cint): cint {.importc: "rc5_keysize", header:"tomcrypt.h".} + var rc5_desc* {.importc: "rc5_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_RC6): + proc rc6_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "rc6_setup", header:"tomcrypt.h".} + proc rc6_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "rc6_ecb_encrypt", header:"tomcrypt.h".} + proc rc6_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "rc6_ecb_decrypt", header:"tomcrypt.h".} + proc rc6_test*(): cint {.importc: "rc6_test", header:"tomcrypt.h".} + proc rc6_done*(skey: ptr symmetric_key) {.importc: "rc6_done", header:"tomcrypt.h".} + proc rc6_keysize*(keysize: ptr cint): cint {.importc: "rc6_keysize", header:"tomcrypt.h".} + var rc6_desc* {.importc: "rc6_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_RC2): + proc rc2_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "rc2_setup", header:"tomcrypt.h".} + proc rc2_setup_ex*(key: ptr cuchar; keylen: cint; bits: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "rc2_setup_ex", header:"tomcrypt.h".} + proc rc2_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "rc2_ecb_encrypt", header:"tomcrypt.h".} + proc rc2_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "rc2_ecb_decrypt", header:"tomcrypt.h".} + proc rc2_test*(): cint {.importc: "rc2_test", header:"tomcrypt.h".} + proc rc2_done*(skey: ptr symmetric_key) {.importc: "rc2_done", header:"tomcrypt.h".} + proc rc2_keysize*(keysize: ptr cint): cint {.importc: "rc2_keysize", header:"tomcrypt.h".} + var rc2_desc* {.importc: "rc2_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_SAFERP): + proc saferp_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "saferp_setup", header:"tomcrypt.h".} + proc saferp_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "saferp_ecb_encrypt", header:"tomcrypt.h".} + proc saferp_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "saferp_ecb_decrypt", header:"tomcrypt.h".} + proc saferp_test*(): cint {.importc: "saferp_test", header:"tomcrypt.h".} + proc saferp_done*(skey: ptr symmetric_key) {.importc: "saferp_done", header:"tomcrypt.h".} + proc saferp_keysize*(keysize: ptr cint): cint {.importc: "saferp_keysize", header:"tomcrypt.h".} + var saferp_desc* {.importc: "saferp_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_SAFER): + proc safer_k64_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "safer_k64_setup", header:"tomcrypt.h".} + proc safer_sk64_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "safer_sk64_setup", header:"tomcrypt.h".} + proc safer_k128_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "safer_k128_setup", header:"tomcrypt.h".} + proc safer_sk128_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "safer_sk128_setup", header:"tomcrypt.h".} + proc safer_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; key: ptr symmetric_key): cint {.importc: "safer_ecb_encrypt", header:"tomcrypt.h".} + proc safer_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; key: ptr symmetric_key): cint {.importc: "safer_ecb_decrypt", header:"tomcrypt.h".} + proc safer_k64_test*(): cint {.importc: "safer_k64_test", header:"tomcrypt.h".} + proc safer_sk64_test*(): cint {.importc: "safer_sk64_test", header:"tomcrypt.h".} + proc safer_sk128_test*(): cint {.importc: "safer_sk128_test", header:"tomcrypt.h".} + proc safer_done*(skey: ptr symmetric_key) {.importc: "safer_done", header:"tomcrypt.h".} + proc safer_64_keysize*(keysize: ptr cint): cint {.importc: "safer_64_keysize", header:"tomcrypt.h".} + proc safer_128_keysize*(keysize: ptr cint): cint {.importc: "safer_128_keysize", header:"tomcrypt.h".} + var + safer_k64_desc* {.importc: "safer_k64_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor + safer_k128_desc* {.importc: "safer_k128_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor + safer_sk64_desc* {.importc: "safer_sk64_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor + safer_sk128_desc* {.importc: "safer_sk128_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_RIJNDAEL): + ## make aes an alias + template aes_setup*(params: varargs[untyped]): cint = + rijndael_setup(params) + template aes_ecb_encrypt*(params: varargs[untyped]): cint = + rijndael_ecb_encrypt(params) + template aes_ecb_decrypt*(params: varargs[untyped]): cint = + rijndael_ecb_decrypt(params) + template aes_test*(params: varargs[untyped]): cint = + rijndael_test(params) + template aes_done*(params: varargs[untyped]) = + rijndael_done(params) + template aes_keysize*(params: varargs[untyped]): cint = + rijndael_keysize(params) + template aes_enc_setup*(params: varargs[untyped]): cint = + rijndael_enc_setup(params) + template aes_enc_ecb_encrypt*(params: varargs[untyped]): cint = + rijndael_enc_ecb_encrypt(params) + template aes_enc_keysize*(params: varargs[untyped]): cint = + rijndael_enc_keysize(params) + proc rijndael_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "rijndael_setup", header:"tomcrypt.h".} + proc rijndael_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "rijndael_ecb_encrypt", header:"tomcrypt.h".} + proc rijndael_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "rijndael_ecb_decrypt", header:"tomcrypt.h".} + proc rijndael_test*(): cint {.importc: "rijndael_test", header:"tomcrypt.h".} + proc rijndael_done*(skey: ptr symmetric_key) {.importc: "rijndael_done", header:"tomcrypt.h".} + proc rijndael_keysize*(keysize: ptr cint): cint {.importc: "rijndael_keysize", header:"tomcrypt.h".} + proc rijndael_enc_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "rijndael_enc_setup", header:"tomcrypt.h".} + proc rijndael_enc_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; + skey: ptr symmetric_key): cint {.importc: "rijndael_enc_ecb_encrypt", header:"tomcrypt.h".} + proc rijndael_enc_done*(skey: ptr symmetric_key) {.importc: "rijndael_enc_done", header:"tomcrypt.h".} + proc rijndael_enc_keysize*(keysize: ptr cint): cint {.importc: "rijndael_enc_keysize", header:"tomcrypt.h".} + var + rijndael_desc* {.importc: "rijndael_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor + aes_desc* {.importc: "aes_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor + var + rijndael_enc_desc* {.importc: "rijndael_enc_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor + aes_enc_desc* {.importc: "aes_enc_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_XTEA): + proc xtea_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "xtea_setup", header:"tomcrypt.h".} + proc xtea_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "xtea_ecb_encrypt", header:"tomcrypt.h".} + proc xtea_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "xtea_ecb_decrypt", header:"tomcrypt.h".} + proc xtea_test*(): cint {.importc: "xtea_test", header:"tomcrypt.h".} + proc xtea_done*(skey: ptr symmetric_key) {.importc: "xtea_done", header:"tomcrypt.h".} + proc xtea_keysize*(keysize: ptr cint): cint {.importc: "xtea_keysize", header:"tomcrypt.h".} + var xtea_desc* {.importc: "xtea_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_TWOFISH): + proc twofish_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "twofish_setup", header:"tomcrypt.h".} + proc twofish_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "twofish_ecb_encrypt", header:"tomcrypt.h".} + proc twofish_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "twofish_ecb_decrypt", header:"tomcrypt.h".} + proc twofish_test*(): cint {.importc: "twofish_test", header:"tomcrypt.h".} + proc twofish_done*(skey: ptr symmetric_key) {.importc: "twofish_done", header:"tomcrypt.h".} + proc twofish_keysize*(keysize: ptr cint): cint {.importc: "twofish_keysize", header:"tomcrypt.h".} + var twofish_desc* {.importc: "twofish_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_DES): + proc des_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "des_setup", header:"tomcrypt.h".} + proc des_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "des_ecb_encrypt", header:"tomcrypt.h".} + proc des_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "des_ecb_decrypt", header:"tomcrypt.h".} + proc des_test*(): cint {.importc: "des_test", header:"tomcrypt.h".} + proc des_done*(skey: ptr symmetric_key) {.importc: "des_done", header:"tomcrypt.h".} + proc des_keysize*(keysize: ptr cint): cint {.importc: "des_keysize", header:"tomcrypt.h".} + proc des3_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "des3_setup", header:"tomcrypt.h".} + proc des3_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "des3_ecb_encrypt", header:"tomcrypt.h".} + proc des3_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "des3_ecb_decrypt", header:"tomcrypt.h".} + proc des3_test*(): cint {.importc: "des3_test", header:"tomcrypt.h".} + proc des3_done*(skey: ptr symmetric_key) {.importc: "des3_done", header:"tomcrypt.h".} + proc des3_keysize*(keysize: ptr cint): cint {.importc: "des3_keysize", header:"tomcrypt.h".} + var + des_desc* {.importc: "des_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor + des3_desc* {.importc: "des3_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_CAST5): + proc cast5_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "cast5_setup", header:"tomcrypt.h".} + proc cast5_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "cast5_ecb_encrypt", header:"tomcrypt.h".} + proc cast5_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "cast5_ecb_decrypt", header:"tomcrypt.h".} + proc cast5_test*(): cint {.importc: "cast5_test", header:"tomcrypt.h".} + proc cast5_done*(skey: ptr symmetric_key) {.importc: "cast5_done", header:"tomcrypt.h".} + proc cast5_keysize*(keysize: ptr cint): cint {.importc: "cast5_keysize", header:"tomcrypt.h".} + var cast5_desc* {.importc: "cast5_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_NOEKEON): + proc noekeon_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "noekeon_setup", header:"tomcrypt.h".} + proc noekeon_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "noekeon_ecb_encrypt", header:"tomcrypt.h".} + proc noekeon_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "noekeon_ecb_decrypt", header:"tomcrypt.h".} + proc noekeon_test*(): cint {.importc: "noekeon_test", header:"tomcrypt.h".} + proc noekeon_done*(skey: ptr symmetric_key) {.importc: "noekeon_done", header:"tomcrypt.h".} + proc noekeon_keysize*(keysize: ptr cint): cint {.importc: "noekeon_keysize", header:"tomcrypt.h".} + var noekeon_desc* {.importc: "noekeon_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_SKIPJACK): + proc skipjack_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "skipjack_setup", header:"tomcrypt.h".} + proc skipjack_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "skipjack_ecb_encrypt", header:"tomcrypt.h".} + proc skipjack_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "skipjack_ecb_decrypt", header:"tomcrypt.h".} + proc skipjack_test*(): cint {.importc: "skipjack_test", header:"tomcrypt.h".} + proc skipjack_done*(skey: ptr symmetric_key) {.importc: "skipjack_done", header:"tomcrypt.h".} + proc skipjack_keysize*(keysize: ptr cint): cint {.importc: "skipjack_keysize", header:"tomcrypt.h".} + var skipjack_desc* {.importc: "skipjack_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_KHAZAD): + proc khazad_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "khazad_setup", header:"tomcrypt.h".} + proc khazad_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "khazad_ecb_encrypt", header:"tomcrypt.h".} + proc khazad_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "khazad_ecb_decrypt", header:"tomcrypt.h".} + proc khazad_test*(): cint {.importc: "khazad_test", header:"tomcrypt.h".} + proc khazad_done*(skey: ptr symmetric_key) {.importc: "khazad_done", header:"tomcrypt.h".} + proc khazad_keysize*(keysize: ptr cint): cint {.importc: "khazad_keysize", header:"tomcrypt.h".} + var khazad_desc* {.importc: "khazad_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_ANUBIS): + proc anubis_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "anubis_setup", header:"tomcrypt.h".} + proc anubis_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "anubis_ecb_encrypt", header:"tomcrypt.h".} + proc anubis_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "anubis_ecb_decrypt", header:"tomcrypt.h".} + proc anubis_test*(): cint {.importc: "anubis_test", header:"tomcrypt.h".} + proc anubis_done*(skey: ptr symmetric_key) {.importc: "anubis_done", header:"tomcrypt.h".} + proc anubis_keysize*(keysize: ptr cint): cint {.importc: "anubis_keysize", header:"tomcrypt.h".} + var anubis_desc* {.importc: "anubis_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_KSEED): + proc kseed_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "kseed_setup", header:"tomcrypt.h".} + proc kseed_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "kseed_ecb_encrypt", header:"tomcrypt.h".} + proc kseed_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "kseed_ecb_decrypt", header:"tomcrypt.h".} + proc kseed_test*(): cint {.importc: "kseed_test", header:"tomcrypt.h".} + proc kseed_done*(skey: ptr symmetric_key) {.importc: "kseed_done", header:"tomcrypt.h".} + proc kseed_keysize*(keysize: ptr cint): cint {.importc: "kseed_keysize", header:"tomcrypt.h".} + var kseed_desc* {.importc: "kseed_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_KASUMI): + proc kasumi_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "kasumi_setup", header:"tomcrypt.h".} + proc kasumi_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "kasumi_ecb_encrypt", header:"tomcrypt.h".} + proc kasumi_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "kasumi_ecb_decrypt", header:"tomcrypt.h".} + proc kasumi_test*(): cint {.importc: "kasumi_test", header:"tomcrypt.h".} + proc kasumi_done*(skey: ptr symmetric_key) {.importc: "kasumi_done", header:"tomcrypt.h".} + proc kasumi_keysize*(keysize: ptr cint): cint {.importc: "kasumi_keysize", header:"tomcrypt.h".} + var kasumi_desc* {.importc: "kasumi_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_MULTI2): + proc multi2_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "multi2_setup", header:"tomcrypt.h".} + proc multi2_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "multi2_ecb_encrypt", header:"tomcrypt.h".} + proc multi2_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "multi2_ecb_decrypt", header:"tomcrypt.h".} + proc multi2_test*(): cint {.importc: "multi2_test", header:"tomcrypt.h".} + proc multi2_done*(skey: ptr symmetric_key) {.importc: "multi2_done", header:"tomcrypt.h".} + proc multi2_keysize*(keysize: ptr cint): cint {.importc: "multi2_keysize", header:"tomcrypt.h".} + var multi2_desc* {.importc: "multi2_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_CAMELLIA): + proc camellia_setup*(key: ptr cuchar; keylen: cint; num_rounds: cint; + skey: ptr symmetric_key): cint {.importc: "camellia_setup", header:"tomcrypt.h".} + proc camellia_ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "camellia_ecb_encrypt", header:"tomcrypt.h".} + proc camellia_ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; skey: ptr symmetric_key): cint {.importc: "camellia_ecb_decrypt", header:"tomcrypt.h".} + proc camellia_test*(): cint {.importc: "camellia_test", header:"tomcrypt.h".} + proc camellia_done*(skey: ptr symmetric_key) {.importc: "camellia_done", header:"tomcrypt.h".} + proc camellia_keysize*(keysize: ptr cint): cint {.importc: "camellia_keysize", header:"tomcrypt.h".} + var camellia_desc* {.importc: "camellia_desc", header:"tomcrypt.h".}: ltc_cipher_descriptor +when declared(LTC_ECB_MODE): + proc ecb_start*(cipher: cint; key: ptr cuchar; keylen: cint; num_rounds: cint; + ecb: ptr symmetric_ECB): cint {.importc: "ecb_start", header:"tomcrypt.h".} + proc ecb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; len: culong; ecb: ptr symmetric_ECB): cint {.importc: "ecb_encrypt", header:"tomcrypt.h".} + proc ecb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; len: culong; ecb: ptr symmetric_ECB): cint {.importc: "ecb_decrypt", header:"tomcrypt.h".} + proc ecb_done*(ecb: ptr symmetric_ECB): cint {.importc: "ecb_done", header:"tomcrypt.h".} +when declared(LTC_CFB_MODE): + proc cfb_start*(cipher: cint; IV: ptr cuchar; key: ptr cuchar; keylen: cint; + num_rounds: cint; cfb: ptr symmetric_CFB): cint {.importc: "cfb_start", header:"tomcrypt.h".} + proc cfb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; len: culong; cfb: ptr symmetric_CFB): cint {.importc: "cfb_encrypt", header:"tomcrypt.h".} + proc cfb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; len: culong; cfb: ptr symmetric_CFB): cint {.importc: "cfb_decrypt", header:"tomcrypt.h".} + proc cfb_getiv*(IV: ptr cuchar; len: ptr culong; cfb: ptr symmetric_CFB): cint {.importc: "cfb_getiv", header:"tomcrypt.h".} + proc cfb_setiv*(IV: ptr cuchar; len: culong; cfb: ptr symmetric_CFB): cint {.importc: "cfb_setiv", header:"tomcrypt.h".} + proc cfb_done*(cfb: ptr symmetric_CFB): cint {.importc: "cfb_done", header:"tomcrypt.h".} +when declared(LTC_OFB_MODE): + proc ofb_start*(cipher: cint; IV: ptr cuchar; key: ptr cuchar; keylen: cint; + num_rounds: cint; ofb: ptr symmetric_OFB): cint {.importc: "ofb_start", header:"tomcrypt.h".} + proc ofb_encrypt*(pt: ptr cuchar; ct: ptr cuchar; len: culong; ofb: ptr symmetric_OFB): cint {.importc: "ofb_encrypt", header:"tomcrypt.h".} + proc ofb_decrypt*(ct: ptr cuchar; pt: ptr cuchar; len: culong; ofb: ptr symmetric_OFB): cint {.importc: "ofb_decrypt", header:"tomcrypt.h".} + proc ofb_getiv*(IV: ptr cuchar; len: ptr culong; ofb: ptr symmetric_OFB): cint {.importc: "ofb_getiv", header:"tomcrypt.h".} + proc ofb_setiv*(IV: ptr cuchar; len: culong; ofb: ptr symmetric_OFB): cint {.importc: "ofb_setiv", header:"tomcrypt.h".} + proc ofb_done*(ofb: ptr symmetric_OFB): cint {.importc: "ofb_done", header:"tomcrypt.h".} +when declared(LTC_CBC_MODE): + proc cbc_start*(cipher: cint; IV: ptr cuchar; key: ptr cuchar; keylen: cint; + num_rounds: cint; cbc: ptr symmetric_CBC): cint {.importc: "cbc_start", header:"tomcrypt.h".} + proc cbc_encrypt*(pt: ptr cuchar; ct: ptr cuchar; len: culong; cbc: ptr symmetric_CBC): cint {.importc: "cbc_encrypt", header:"tomcrypt.h".} + proc cbc_decrypt*(ct: ptr cuchar; pt: ptr cuchar; len: culong; cbc: ptr symmetric_CBC): cint {.importc: "cbc_decrypt", header:"tomcrypt.h".} + proc cbc_getiv*(IV: ptr cuchar; len: ptr culong; cbc: ptr symmetric_CBC): cint {.importc: "cbc_getiv", header:"tomcrypt.h".} + proc cbc_setiv*(IV: ptr cuchar; len: culong; cbc: ptr symmetric_CBC): cint {.importc: "cbc_setiv", header:"tomcrypt.h".} + proc cbc_done*(cbc: ptr symmetric_CBC): cint {.importc: "cbc_done", header:"tomcrypt.h".} +when declared(LTC_CTR_MODE): + const + CTR_COUNTER_LITTLE_ENDIAN* = 0x00000000 + CTR_COUNTER_BIG_ENDIAN* = 0x00001000 + LTC_CTR_RFC3686* = 0x00002000 + proc ctr_start*(cipher: cint; IV: ptr cuchar; key: ptr cuchar; keylen: cint; + num_rounds: cint; ctr_mode: cint; ctr: ptr symmetric_CTR): cint {.importc: "ctr_start", header:"tomcrypt.h".} + proc ctr_encrypt*(pt: ptr cuchar; ct: ptr cuchar; len: culong; ctr: ptr symmetric_CTR): cint {.importc: "ctr_encrypt", header:"tomcrypt.h".} + proc ctr_decrypt*(ct: ptr cuchar; pt: ptr cuchar; len: culong; ctr: ptr symmetric_CTR): cint {.importc: "ctr_decrypt", header:"tomcrypt.h".} + proc ctr_getiv*(IV: ptr cuchar; len: ptr culong; ctr: ptr symmetric_CTR): cint {.importc: "ctr_getiv", header:"tomcrypt.h".} + proc ctr_setiv*(IV: ptr cuchar; len: culong; ctr: ptr symmetric_CTR): cint {.importc: "ctr_setiv", header:"tomcrypt.h".} + proc ctr_done*(ctr: ptr symmetric_CTR): cint {.importc: "ctr_done", header:"tomcrypt.h".} + proc ctr_test*(): cint {.importc: "ctr_test", header:"tomcrypt.h".} +when declared(LTC_LRW_MODE): + const + LRW_ENCRYPT* = LTC_ENCRYPT + LRW_DECRYPT* = LTC_DECRYPT + proc lrw_start*(cipher: cint; IV: ptr cuchar; key: ptr cuchar; keylen: cint; + tweak: ptr cuchar; num_rounds: cint; lrw: ptr symmetric_LRW): cint {.importc: "lrw_start", header:"tomcrypt.h".} + proc lrw_encrypt*(pt: ptr cuchar; ct: ptr cuchar; len: culong; lrw: ptr symmetric_LRW): cint {.importc: "lrw_encrypt", header:"tomcrypt.h".} + proc lrw_decrypt*(ct: ptr cuchar; pt: ptr cuchar; len: culong; lrw: ptr symmetric_LRW): cint {.importc: "lrw_decrypt", header:"tomcrypt.h".} + proc lrw_getiv*(IV: ptr cuchar; len: ptr culong; lrw: ptr symmetric_LRW): cint {.importc: "lrw_getiv", header:"tomcrypt.h".} + proc lrw_setiv*(IV: ptr cuchar; len: culong; lrw: ptr symmetric_LRW): cint {.importc: "lrw_setiv", header:"tomcrypt.h".} + proc lrw_done*(lrw: ptr symmetric_LRW): cint {.importc: "lrw_done", header:"tomcrypt.h".} + proc lrw_test*(): cint {.importc: "lrw_test", header:"tomcrypt.h".} + ## don't call + proc lrw_process*(pt: ptr cuchar; ct: ptr cuchar; len: culong; mode: cint; + lrw: ptr symmetric_LRW): cint {.importc: "lrw_process", header:"tomcrypt.h".} +when declared(LTC_F8_MODE): + proc f8_start*(cipher: cint; IV: ptr cuchar; key: ptr cuchar; keylen: cint; + salt_key: ptr cuchar; skeylen: cint; num_rounds: cint; + f8: ptr symmetric_F8): cint {.importc: "f8_start", header:"tomcrypt.h".} + proc f8_encrypt*(pt: ptr cuchar; ct: ptr cuchar; len: culong; f8: ptr symmetric_F8): cint {.importc: "f8_encrypt", header:"tomcrypt.h".} + proc f8_decrypt*(ct: ptr cuchar; pt: ptr cuchar; len: culong; f8: ptr symmetric_F8): cint {.importc: "f8_decrypt", header:"tomcrypt.h".} + proc f8_getiv*(IV: ptr cuchar; len: ptr culong; f8: ptr symmetric_F8): cint {.importc: "f8_getiv", header:"tomcrypt.h".} + proc f8_setiv*(IV: ptr cuchar; len: culong; f8: ptr symmetric_F8): cint {.importc: "f8_setiv", header:"tomcrypt.h".} + proc f8_done*(f8: ptr symmetric_F8): cint {.importc: "f8_done", header:"tomcrypt.h".} + proc f8_test_mode*(): cint {.importc: "f8_test_mode", header:"tomcrypt.h".} +when declared(LTC_XTS_MODE): + type + symmetric_xts* {.bycopy.} = object + key1*: symmetric_key + key2*: symmetric_key + cipher*: cint + + proc xts_start*(cipher: cint; key1: ptr cuchar; key2: ptr cuchar; keylen: culong; + num_rounds: cint; xts: ptr symmetric_xts): cint {.importc: "xts_start", header:"tomcrypt.h".} + proc xts_encrypt*(pt: ptr cuchar; ptlen: culong; ct: ptr cuchar; tweak: ptr cuchar; + xts: ptr symmetric_xts): cint {.importc: "xts_encrypt", header:"tomcrypt.h".} + proc xts_decrypt*(ct: ptr cuchar; ptlen: culong; pt: ptr cuchar; tweak: ptr cuchar; + xts: ptr symmetric_xts): cint {.importc: "xts_decrypt", header:"tomcrypt.h".} + proc xts_done*(xts: ptr symmetric_xts) {.importc: "xts_done", header:"tomcrypt.h".} + proc xts_test*(): cint {.importc: "xts_test", header:"tomcrypt.h".} + proc xts_mult_x*(I: ptr cuchar) {.importc: "xts_mult_x", header:"tomcrypt.h".} +proc find_cipher*(name: cstring): cint {.importc: "find_cipher", header:"tomcrypt.h".} +proc find_cipher_any*(name: cstring; blocklen: cint; keylen: cint): cint {.importc: "find_cipher_any", header:"tomcrypt.h".} +proc find_cipher_id*(ID: cuchar): cint {.importc: "find_cipher_id", header:"tomcrypt.h".} +proc register_cipher*(cipher: ptr ltc_cipher_descriptor): cint {.importc: "register_cipher", header:"tomcrypt.h".} +proc unregister_cipher*(cipher: ptr ltc_cipher_descriptor): cint {.importc: "unregister_cipher", header:"tomcrypt.h".} +proc register_all_ciphers*(): cint {.importc: "register_all_ciphers", header:"tomcrypt.h".} +proc cipher_is_valid*(idx: cint): cint {.importc: "cipher_is_valid", header:"tomcrypt.h".} +## ---- stream ciphers ---- + +when declared(LTC_CHACHA): + type + chacha_state* {.bycopy.} = object + input*: array[16, ulong32] + kstream*: array[64, cuchar] + ksleft*: culong + ivlen*: culong + rounds*: cint + + proc chacha_setup*(st: ptr chacha_state; key: ptr cuchar; keylen: culong; rounds: cint): cint {.importc: "chacha_setup", header:"tomcrypt.h".} + proc chacha_ivctr32*(st: ptr chacha_state; iv: ptr cuchar; ivlen: culong; + counter: ulong32): cint {.importc: "chacha_ivctr32", header:"tomcrypt.h".} + proc chacha_ivctr64*(st: ptr chacha_state; iv: ptr cuchar; ivlen: culong; + counter: ulong64): cint {.importc: "chacha_ivctr64", header:"tomcrypt.h".} + proc chacha_crypt*(st: ptr chacha_state; `in`: ptr cuchar; inlen: culong; + `out`: ptr cuchar): cint {.importc: "chacha_crypt", header:"tomcrypt.h".} + proc chacha_keystream*(st: ptr chacha_state; `out`: ptr cuchar; outlen: culong): cint {.importc: "chacha_keystream", header:"tomcrypt.h".} + proc chacha_done*(st: ptr chacha_state): cint {.importc: "chacha_done", header:"tomcrypt.h".} + proc chacha_test*(): cint {.importc: "chacha_test", header:"tomcrypt.h".} +when declared(LTC_RC4_STREAM): + type + rc4_state* {.bycopy.} = object + x*: cuint + y*: cuint + buf*: array[256, cuchar] + + proc rc4_stream_setup*(st: ptr rc4_state; key: ptr cuchar; keylen: culong): cint {.importc: "rc4_stream_setup", header:"tomcrypt.h".} + proc rc4_stream_crypt*(st: ptr rc4_state; `in`: ptr cuchar; inlen: culong; + `out`: ptr cuchar): cint {.importc: "rc4_stream_crypt", header:"tomcrypt.h".} + proc rc4_stream_keystream*(st: ptr rc4_state; `out`: ptr cuchar; outlen: culong): cint {.importc: "rc4_stream_keystream", header:"tomcrypt.h".} + proc rc4_stream_done*(st: ptr rc4_state): cint {.importc: "rc4_stream_done", header:"tomcrypt.h".} + proc rc4_stream_test*(): cint {.importc: "rc4_stream_test", header:"tomcrypt.h".} +when declared(LTC_SOBER128_STREAM): + type + sober128_state* {.bycopy.} = object + R*: array[17, ulong32] ## Working storage for the shift register + initR*: array[17, ulong32] ## saved register contents + konst*: ulong32 ## key dependent constant + sbuf*: ulong32 ## partial word encryption buffer + nbuf*: cint ## number of part-word stream bits buffered + + proc sober128_stream_setup*(st: ptr sober128_state; key: ptr cuchar; keylen: culong): cint {.importc: "sober128_stream_setup", header:"tomcrypt.h".} + proc sober128_stream_setiv*(st: ptr sober128_state; iv: ptr cuchar; ivlen: culong): cint {.importc: "sober128_stream_setiv", header:"tomcrypt.h".} + proc sober128_stream_crypt*(st: ptr sober128_state; `in`: ptr cuchar; inlen: culong; + `out`: ptr cuchar): cint {.importc: "sober128_stream_crypt", header:"tomcrypt.h".} + proc sober128_stream_keystream*(st: ptr sober128_state; `out`: ptr cuchar; + outlen: culong): cint {.importc: "sober128_stream_keystream", header:"tomcrypt.h".} + proc sober128_stream_done*(st: ptr sober128_state): cint {.importc: "sober128_stream_done", header:"tomcrypt.h".} + proc sober128_stream_test*(): cint {.importc: "sober128_stream_test", header:"tomcrypt.h".} +## ref: $Format:%D$ +## git commit: $Format:%H$ +## commit time: $Format:%ai$ |