nettle-meta.h 6.77 KB
Newer Older
Niels Möller's avatar
Niels Möller committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/* nettle-meta.h
 *
 * Information about algorithms.
 */

/* nettle, low-level cryptographics library
 *
 * Copyright (C) 2002 Niels Mller
 *  
 * 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
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NETTLE_META_H_INCLUDED
#define NETTLE_META_H_INCLUDED

#include <inttypes.h>

31
32
33
34
35
36
37
38
/* Randomness. Used by key generation and dsa signature creation. */
typedef void (*nettle_random_func)(void *ctx,
				   unsigned length, uint8_t *dst);

/* Progress report function, mainly for key generation. */
typedef void (*nettle_progress_func)(void *ctx,
				     int c);

Niels Möller's avatar
Niels Möller committed
39
40
41
42
43
/* Ciphers */
typedef void (*nettle_crypt_func)(void *ctx,
				  unsigned length, uint8_t *dst,
				  const uint8_t *src);

44
typedef void (*nettle_set_key_func)(void *ctx,
Niels Möller's avatar
Niels Möller committed
45
46
47
48
49
50
51
52
53
54
55
56
57
				   unsigned length,
				   const uint8_t *key);


struct nettle_cipher
{
  const char *name;
  
  unsigned context_size;
  
  /* Zero for stream ciphers */
  unsigned block_size;

58
  /* Suggested key size; other sizes are sometimes possible. */
Niels Möller's avatar
Niels Möller committed
59
60
  unsigned key_size;

61
62
  nettle_set_key_func set_encrypt_key;
  nettle_set_key_func set_decrypt_key;
Niels Möller's avatar
Niels Möller committed
63
64
65
66
67
68

  nettle_crypt_func encrypt;
  nettle_crypt_func decrypt;
};

#define _NETTLE_CIPHER(name, NAME, keysize) {	\
69
  #name #keysize,				\
Niels Möller's avatar
Niels Möller committed
70
71
  sizeof(struct name##_ctx),			\
  NAME##_BLOCK_SIZE,				\
72
  keysize / 8,					\
Niels Möller's avatar
Niels Möller committed
73
74
75
76
  (nettle_set_key_func) name##_set_key,		\
  (nettle_set_key_func) name##_set_key,		\
  (nettle_crypt_func) name##_encrypt,		\
  (nettle_crypt_func) name##_decrypt,		\
77
78
79
80
81
82
83
84
85
86
87
}

#define _NETTLE_CIPHER_SEP(name, NAME, keysize) {	\
  #name #keysize,				\
  sizeof(struct name##_ctx),			\
  NAME##_BLOCK_SIZE,				\
  keysize / 8,					\
  (nettle_set_key_func) name##_set_encrypt_key,	\
  (nettle_set_key_func) name##_set_decrypt_key,	\
  (nettle_crypt_func) name##_encrypt,		\
  (nettle_crypt_func) name##_decrypt,		\
Niels Möller's avatar
Niels Möller committed
88
}
89
90
91
92
93
94
95
96
97
98
99
100

#define _NETTLE_CIPHER_FIX(name, NAME, keysize) {	\
  #name,					\
  sizeof(struct name##_ctx),			\
  NAME##_BLOCK_SIZE,				\
  keysize / 8,					\
  (nettle_set_key_func) name##_set_key,		\
  (nettle_set_key_func) name##_set_key,		\
  (nettle_crypt_func) name##_encrypt,		\
  (nettle_crypt_func) name##_decrypt,		\
}

Niels Möller's avatar
Niels Möller committed
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
extern const struct nettle_cipher nettle_aes128;
extern const struct nettle_cipher nettle_aes192;
extern const struct nettle_cipher nettle_aes256;

extern const struct nettle_cipher nettle_arcfour128;
extern const struct nettle_cipher nettle_cast128;

extern const struct nettle_cipher nettle_serpent128;
extern const struct nettle_cipher nettle_serpent192;
extern const struct nettle_cipher nettle_serpent256;

extern const struct nettle_cipher nettle_twofish128;
extern const struct nettle_cipher nettle_twofish192;
extern const struct nettle_cipher nettle_twofish256;


117
/* Hash algorithms */
Niels Möller's avatar
Niels Möller committed
118
119
120
121
122
123
124
125
126
127
128
129
typedef void (*nettle_hash_init_func)(void *ctx);
typedef void (*nettle_hash_update_func)(void *ctx,
					unsigned length,
					const uint8_t *src);
typedef void (*nettle_hash_digest_func)(void *ctx,
					unsigned length, uint8_t *dst);

struct nettle_hash
{
  const char *name;

  /* Size of the context struct */
130
  unsigned context_size;
Niels Möller's avatar
Niels Möller committed
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

  /* Size of digests */
  unsigned digest_size;
  
  /* Internal block size */
  unsigned block_size;

  nettle_hash_init_func init;
  nettle_hash_update_func update;
  nettle_hash_digest_func digest;
};

#define _NETTLE_HASH(name, NAME) {		\
 #name,						\
 sizeof(struct name##_ctx),			\
 NAME##_DIGEST_SIZE,				\
 NAME##_DATA_SIZE,				\
 (nettle_hash_init_func) name##_init,		\
 (nettle_hash_update_func) name##_update,	\
 (nettle_hash_digest_func) name##_digest	\
} 

extern const struct nettle_hash nettle_md5;
extern const struct nettle_hash nettle_sha1;
extern const struct nettle_hash nettle_sha256;

157

158
159
160
/* ASCII armor codecs. NOTE: Experimental and subject to change. */

typedef unsigned (*nettle_armor_length_func)(unsigned length);
161
typedef void (*nettle_armor_init_func)(void *ctx);
162

163
164
165
166
167
typedef unsigned (*nettle_armor_encode_update_func)(void *ctx,
						    uint8_t *dst,
						    unsigned src_length,
						    const uint8_t *src);

168
169
typedef unsigned (*nettle_armor_encode_final_func)(void *ctx, uint8_t *dst);

170
171
172
173
174
175
176
typedef int (*nettle_armor_decode_update_func)(void *ctx,
					       unsigned *dst_length,
					       uint8_t *dst,
					       unsigned src_length,
					       const uint8_t *src);

typedef int (*nettle_armor_decode_final_func)(void *ctx);
177
178
179
180

struct nettle_armor
{
  const char *name;
181
182
183
184
185
186
187
  unsigned encode_context_size;
  unsigned decode_context_size;

  unsigned encode_final_length;

  nettle_armor_init_func encode_init;
  nettle_armor_length_func encode_length;
188
  nettle_armor_encode_update_func encode_update;
189
190
  nettle_armor_encode_final_func encode_final;
  
191
  nettle_armor_init_func decode_init;
192
  nettle_armor_length_func decode_length;
193
194
  nettle_armor_decode_update_func decode_update;
  nettle_armor_decode_final_func decode_final;
195
196
};

197
198
199
200
201
#define _NETTLE_ARMOR(name, NAME) {				\
  #name,							\
  sizeof(struct name##_encode_ctx),				\
  sizeof(struct name##_decode_ctx),				\
  NAME##_ENCODE_FINAL_LENGTH,					\
202
203
204
  (nettle_armor_init_func) name##_encode_init,			\
  (nettle_armor_length_func) name##_encode_length,		\
  (nettle_armor_encode_update_func) name##_encode_update,	\
205
  (nettle_armor_encode_final_func) name##_encode_final,		\
206
207
208
209
  (nettle_armor_init_func) name##_decode_init,			\
  (nettle_armor_length_func) name##_decode_length,		\
  (nettle_armor_decode_update_func) name##_decode_update,	\
  (nettle_armor_decode_final_func) name##_decode_final,		\
210
211
}

212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
#define _NETTLE_ARMOR_0(name, NAME) {				\
  #name,							\
  0,								\
  sizeof(struct name##_decode_ctx),				\
  NAME##_ENCODE_FINAL_LENGTH,					\
  (nettle_armor_init_func) name##_encode_init,			\
  (nettle_armor_length_func) name##_encode_length,		\
  (nettle_armor_encode_update_func) name##_encode_update,	\
  (nettle_armor_encode_final_func) name##_encode_final,		\
  (nettle_armor_init_func) name##_decode_init,			\
  (nettle_armor_length_func) name##_decode_length,		\
  (nettle_armor_decode_update_func) name##_decode_update,	\
  (nettle_armor_decode_final_func) name##_decode_final,		\
}


228
extern const struct nettle_armor nettle_base64;
229
extern const struct nettle_armor nettle_base16;
230

Niels Möller's avatar
Niels Möller committed
231
#endif /* NETTLE_META_H_INCLUDED */