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 */