nettle-internal.h 6.15 KB
Newer Older
Niels Möller's avatar
Niels Möller committed
1 2 3 4 5 6 7 8
/* nettle-internal.h
 *
 * Things that are used only by the testsuite and benchmark, and
 * subject to change.
 */

/* nettle, low-level cryptographics library
 *
Niels Möller's avatar
Niels Möller committed
9
 * Copyright (C) 2002 Niels Möller
Niels Möller's avatar
Niels Möller committed
10 11 12 13 14 15 16 17 18 19 20 21 22
 *  
 * The nettle library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 * 
 * The nettle library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with the nettle library; see the file COPYING.LIB.  If not, write to
23 24
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02111-1301, USA.
Niels Möller's avatar
Niels Möller committed
25 26 27 28 29 30 31
 */

#ifndef NETTLE_INTERNAL_H_INCLUDED
#define NETTLE_INTERNAL_H_INCLUDED

#include "nettle-meta.h"

Niels Möller's avatar
Niels Möller committed
32 33
#include "eax.h"

34 35 36 37 38 39
/* Temporary allocation, for systems that don't support alloca. Note
 * that the allocation requests should always be reasonably small, so
 * that they can fit on the stack. For non-alloca systems, we use a
 * fix maximum size, and abort if we ever need anything larger. */

#if HAVE_ALLOCA
40
# define TMP_DECL(name, type, max) type *name
41
# define TMP_ALLOC(name, size) (name = alloca(sizeof (*name) * (size)))
42
#else /* !HAVE_ALLOCA */
43
# define TMP_DECL(name, type, max) type name[max]
44
# define TMP_ALLOC(name, size) \
45
  do { if ((size) > (sizeof(name) / sizeof(name[0]))) abort(); } while (0)
46 47 48 49
#endif 

/* Arbitrary limits which apply to systems that don't have alloca */
#define NETTLE_MAX_BIGNUM_BITS 10000
50
#define NETTLE_MAX_BIGNUM_SIZE ((NETTLE_MAX_BIGNUM_BITS + 7)/8)
Niels Möller's avatar
Niels Möller committed
51 52
#define NETTLE_MAX_HASH_BLOCK_SIZE 128
#define NETTLE_MAX_HASH_DIGEST_SIZE 64
53
#define NETTLE_MAX_SEXP_ASSOC 17
54 55
#define NETTLE_MAX_CIPHER_BLOCK_SIZE 32

Niels Möller's avatar
Niels Möller committed
56 57 58 59 60 61 62 63 64
/* Doesn't quite fit with the other algorithms, because of the weak
 * keys. Weak keys are not reported, the functions will simply crash
 * if you try to use a weak key. */

extern const struct nettle_cipher nettle_des;
extern const struct nettle_cipher nettle_des3;

extern const struct nettle_cipher nettle_blowfish128;

65 66
/* For benchmarking only, sets no iv and lies about the block size. */
extern const struct nettle_cipher nettle_salsa20;
Niels Möller's avatar
Niels Möller committed
67
extern const struct nettle_cipher nettle_salsa20r12;
68

Niels Möller's avatar
Niels Möller committed
69
extern const struct nettle_cipher nettle_unified_aes128;
Niels Möller's avatar
Niels Möller committed
70
extern const struct nettle_cipher nettle_unified_aes192;
71
extern const struct nettle_cipher nettle_unified_aes256;
Niels Möller's avatar
Niels Möller committed
72

73
/* Glue to openssl, for comparative benchmarking. Code in
74
 * examples/nettle-openssl.c. */
75 76 77 78
extern const struct nettle_cipher nettle_openssl_aes128;
extern const struct nettle_cipher nettle_openssl_aes192;
extern const struct nettle_cipher nettle_openssl_aes256;
extern const struct nettle_cipher nettle_openssl_arcfour128;
Niels Möller's avatar
Niels Möller committed
79 80 81 82
extern const struct nettle_cipher nettle_openssl_blowfish128;
extern const struct nettle_cipher nettle_openssl_des;
extern const struct nettle_cipher nettle_openssl_cast128;

83 84 85
extern const struct nettle_hash nettle_openssl_md5;
extern const struct nettle_hash nettle_openssl_sha1;

86 87 88 89 90 91
/* Tentative interface for "authenticated encryption with associated
   data" algorithms. Should be moved to nettle-meta.h when stable. */
struct nettle_aead
{
  const char *name;
  
92
  size_t context_size;
93
  /* Block size of the input, and the size of the output digest */
94
  size_t block_size;
95 96

  /* Suggested key size; other sizes are sometimes possible. */
97
  size_t key_size;
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119

  nettle_set_key_func *set_key;
  nettle_set_key_func *set_iv;
  nettle_hash_update_func *update;
  nettle_crypt_func *encrypt;
  nettle_crypt_func *decrypt;
  nettle_hash_digest_func *digest;
};

#define _NETTLE_AEAD(type, TYPE, name, key_size) {	\
  #type "-" #name #key_size,				\
  sizeof(struct type##_##name##_ctx),			\
  TYPE##_BLOCK_SIZE,					\
  key_size / 8,						\
  (nettle_set_key_func *) type##_##name##_set_key,	\
  (nettle_set_key_func *) type##_##name##_set_iv,	\
  (nettle_hash_update_func *) type##_##name##_update,	\
  (nettle_crypt_func *) type##_##name##_encrypt,	\
  (nettle_crypt_func *) type##_##name##_decrypt,	\
  (nettle_hash_digest_func *) type##_##name##_digest,	\
}

Niels Möller's avatar
Niels Möller committed
120 121 122 123 124 125 126 127 128 129 130 131 132
#define _NETTLE_AEAD_FIX(type, TYPE, name, key_size) {	\
  #type "-" #name,				\
  sizeof(struct type##_##name##_ctx),			\
  TYPE##_BLOCK_SIZE,					\
  key_size / 8,						\
  (nettle_set_key_func *) type##_##name##_set_key,	\
  (nettle_set_key_func *) type##_##name##_set_iv,	\
  (nettle_hash_update_func *) type##_##name##_update,	\
  (nettle_crypt_func *) type##_##name##_encrypt,	\
  (nettle_crypt_func *) type##_##name##_decrypt,	\
  (nettle_hash_digest_func *) type##_##name##_digest,	\
}

133 134 135
extern const struct nettle_aead nettle_gcm_aes128;
extern const struct nettle_aead nettle_gcm_aes192;
extern const struct nettle_aead nettle_gcm_aes256;
136

137 138 139
extern const struct nettle_aead nettle_gcm_camellia128;
extern const struct nettle_aead nettle_gcm_camellia192;
extern const struct nettle_aead nettle_gcm_camellia256;
140

141 142 143
extern const struct nettle_aead nettle_gcm_serpent128;
extern const struct nettle_aead nettle_gcm_serpent192;
extern const struct nettle_aead nettle_gcm_serpent256;
144

145 146 147
extern const struct nettle_aead nettle_gcm_twofish128;
extern const struct nettle_aead nettle_gcm_twofish192;
extern const struct nettle_aead nettle_gcm_twofish256;
148

Niels Möller's avatar
Niels Möller committed
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
/* Tentative interface. */
struct eax_aes128_ctx EAX_CTX(struct aes128_ctx);

void
eax_aes128_set_key(struct eax_aes128_ctx *ctx,
		   size_t length, const uint8_t *key);

void
eax_aes128_set_nonce(struct eax_aes128_ctx *ctx,
		     size_t length, const uint8_t *iv);

void
eax_aes128_update(struct eax_aes128_ctx *ctx,
		  size_t length, const uint8_t *data);

void
eax_aes128_encrypt(struct eax_aes128_ctx *ctx,
		   size_t length, uint8_t *dst, const uint8_t *src);

void
eax_aes128_decrypt(struct eax_aes128_ctx *ctx,
		   size_t length, uint8_t *dst, const uint8_t *src);

void
eax_aes128_digest(struct eax_aes128_ctx *ctx, size_t length, uint8_t *digest);

extern const struct nettle_aead nettle_eax_aes128;

Niels Möller's avatar
Niels Möller committed
177
#endif /* NETTLE_INTERNAL_H_INCLUDED */