path: root/src/tomcrypt/cipher.nim

##  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$