nettle-meta.h

   1 /* nettle-meta.h
   2  *
   3  * Information about algorithms.
   4  */
   5
   6 /* nettle, low-level cryptographics library
   7  *
   8  * Copyright (C) 2002 Niels Möller
   9  *
  10  * The nettle library is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or (at your
  13  * option) any later version.
  14  *
  15  * The nettle library is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  17  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  18  * License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with the nettle library; see the file COPYING.LIB.  If not, write to
  22  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  23  * MA 02111-1307, USA.
  24  */
  25
  26 #ifndef NETTLE_META_H_INCLUDED
  27 #define NETTLE_META_H_INCLUDED
  28
  29 #include "nettle-types.h"
  30
  31 #ifdef __cplusplus
  32 extern "C" {
  33 #endif
  34
  35
  36 struct nettle_cipher
  37 {
  38   const char *name;
  39
  40   unsigned context_size;
  41
  42   /* Zero for stream ciphers */
  43   unsigned block_size;
  44
  45   /* Suggested key size; other sizes are sometimes possible. */
  46   unsigned key_size;
  47
  48   nettle_set_key_func *set_encrypt_key;
  49   nettle_set_key_func *set_decrypt_key;
  50
  51   nettle_crypt_func *encrypt;
  52   nettle_crypt_func *decrypt;
  53 };
  54
  55 #define _NETTLE_CIPHER(name, NAME, keysize) {   \
  56   #name #keysize,                               \
  57   sizeof(struct name##_ctx),                    \
  58   NAME##_BLOCK_SIZE,                            \
  59   keysize / 8,                                  \
  60   (nettle_set_key_func *) name##_set_key,       \
  61   (nettle_set_key_func *) name##_set_key,       \
  62   (nettle_crypt_func *) name##_encrypt,         \
  63   (nettle_crypt_func *) name##_decrypt,         \
  64 }
  65
  66 #define _NETTLE_CIPHER_SEP(name, NAME, keysize) {       \
  67   #name #keysize,                                       \
  68   sizeof(struct name##_ctx),                            \
  69   NAME##_BLOCK_SIZE,                                    \
  70   keysize / 8,                                          \
  71   (nettle_set_key_func *) name##_set_encrypt_key,       \
  72   (nettle_set_key_func *) name##_set_decrypt_key,       \
  73   (nettle_crypt_func *) name##_encrypt,                 \
  74   (nettle_crypt_func *) name##_decrypt,                 \
  75 }
  76
  77 #define _NETTLE_CIPHER_SEP_SET_KEY(name, NAME, keysize) {\
  78   #name #keysize,                                       \
  79   sizeof(struct name##_ctx),                            \
  80   NAME##_BLOCK_SIZE,                                    \
  81   keysize / 8,                                          \
  82   (nettle_set_key_func *) name##_set_encrypt_key,       \
  83   (nettle_set_key_func *) name##_set_decrypt_key,       \
  84   (nettle_crypt_func *) name##_crypt,                   \
  85   (nettle_crypt_func *) name##_crypt,                   \
  86 }
  87
  88 #define _NETTLE_CIPHER_FIX(name, NAME, keysize) {       \
  89   #name,                                                \
  90   sizeof(struct name##_ctx),                            \
  91   NAME##_BLOCK_SIZE,                                    \
  92   keysize / 8,                                          \
  93   (nettle_set_key_func *) name##_set_key,               \
  94   (nettle_set_key_func *) name##_set_key,               \
  95   (nettle_crypt_func *) name##_encrypt,                 \
  96   (nettle_crypt_func *) name##_decrypt,                 \
  97 }
  98
  99 extern const struct nettle_cipher nettle_aes128;
 100 extern const struct nettle_cipher nettle_aes192;
 101 extern const struct nettle_cipher nettle_aes256;
 102
 103 extern const struct nettle_cipher nettle_arcfour128;
 104
 105 extern const struct nettle_cipher nettle_camellia128;
 106 extern const struct nettle_cipher nettle_camellia192;
 107 extern const struct nettle_cipher nettle_camellia256;
 108
 109 extern const struct nettle_cipher nettle_cast128;
 110
 111 extern const struct nettle_cipher nettle_serpent128;
 112 extern const struct nettle_cipher nettle_serpent192;
 113 extern const struct nettle_cipher nettle_serpent256;
 114
 115 extern const struct nettle_cipher nettle_twofish128;
 116 extern const struct nettle_cipher nettle_twofish192;
 117 extern const struct nettle_cipher nettle_twofish256;
 118
 119 extern const struct nettle_cipher nettle_arctwo40;
 120 extern const struct nettle_cipher nettle_arctwo64;
 121 extern const struct nettle_cipher nettle_arctwo128;
 122 extern const struct nettle_cipher nettle_arctwo_gutmann128;
 123
 124 struct nettle_hash
 125 {
 126   const char *name;
 127
 128   /* Size of the context struct */
 129   unsigned context_size;
 130
 131   /* Size of digests */
 132   unsigned digest_size;
 133
 134   /* Internal block size */
 135   unsigned block_size;
 136
 137   nettle_hash_init_func *init;
 138   nettle_hash_update_func *update;
 139   nettle_hash_digest_func *digest;
 140 };
 141
 142 #define _NETTLE_HASH(name, NAME) {              \
 143  #name,                                         \
 144  sizeof(struct name##_ctx),                     \
 145  NAME##_DIGEST_SIZE,                            \
 146  NAME##_DATA_SIZE,                              \
 147  (nettle_hash_init_func *) name##_init,         \
 148  (nettle_hash_update_func *) name##_update,     \
 149  (nettle_hash_digest_func *) name##_digest      \
 150 }
 151
 152 extern const struct nettle_hash nettle_md2;
 153 extern const struct nettle_hash nettle_md4;
 154 extern const struct nettle_hash nettle_md5;
 155 extern const struct nettle_hash nettle_sha1;
 156 extern const struct nettle_hash nettle_sha224;
 157 extern const struct nettle_hash nettle_sha256;
 158 extern const struct nettle_hash nettle_sha384;
 159 extern const struct nettle_hash nettle_sha512;
 160
 161 struct nettle_armor
 162 {
 163   const char *name;
 164   unsigned encode_context_size;
 165   unsigned decode_context_size;
 166
 167   unsigned encode_final_length;
 168
 169   nettle_armor_init_func *encode_init;
 170   nettle_armor_length_func *encode_length;
 171   nettle_armor_encode_update_func *encode_update;
 172   nettle_armor_encode_final_func *encode_final;
 173
 174   nettle_armor_init_func *decode_init;
 175   nettle_armor_length_func *decode_length;
 176   nettle_armor_decode_update_func *decode_update;
 177   nettle_armor_decode_final_func *decode_final;
 178 };
 179
 180 #define _NETTLE_ARMOR(name, NAME) {                             \
 181   #name,                                                        \
 182   sizeof(struct name##_encode_ctx),                             \
 183   sizeof(struct name##_decode_ctx),                             \
 184   NAME##_ENCODE_FINAL_LENGTH,                                   \
 185   (nettle_armor_init_func *) name##_encode_init,                \
 186   (nettle_armor_length_func *) name##_encode_length,            \
 187   (nettle_armor_encode_update_func *) name##_encode_update,     \
 188   (nettle_armor_encode_final_func *) name##_encode_final,       \
 189   (nettle_armor_init_func *) name##_decode_init,                \
 190   (nettle_armor_length_func *) name##_decode_length,            \
 191   (nettle_armor_decode_update_func *) name##_decode_update,     \
 192   (nettle_armor_decode_final_func *) name##_decode_final,       \
 193 }
 194
 195 #define _NETTLE_ARMOR_0(name, NAME) {                           \
 196   #name,                                                        \
 197   0,                                                            \
 198   sizeof(struct name##_decode_ctx),                             \
 199   NAME##_ENCODE_FINAL_LENGTH,                                   \
 200   (nettle_armor_init_func *) name##_encode_init,                \
 201   (nettle_armor_length_func *) name##_encode_length,            \
 202   (nettle_armor_encode_update_func *) name##_encode_update,     \
 203   (nettle_armor_encode_final_func *) name##_encode_final,       \
 204   (nettle_armor_init_func *) name##_decode_init,                \
 205   (nettle_armor_length_func *) name##_decode_length,            \
 206   (nettle_armor_decode_update_func *) name##_decode_update,     \
 207   (nettle_armor_decode_final_func *) name##_decode_final,       \
 208 }
 209
 210 extern const struct nettle_armor nettle_base64;
 211 extern const struct nettle_armor nettle_base16;
 212
 213 #ifdef __cplusplus
 214 }
 215 #endif
 216
 217 #endif /* NETTLE_META_H_INCLUDED */