nettle-meta.h 5.48 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

/* ASCII armor codecs */
159
160
161
162
163
164
165
166
typedef unsigned (*nettle_armor_encode_func)(uint8_t *dst,
                                             unsigned src_length,
                                             const uint8_t *src);
typedef void (*nettle_armor_init_func)(void *ctx);
typedef unsigned (*nettle_armor_update_func)(void *ctx,
                                             uint8_t *dst,
                                             unsigned src_length,
                                             const uint8_t *src);
167
168
169
170

struct nettle_armor
{
  const char *name;
171
172
173
174
175
176
  unsigned context_size;
  unsigned text_block_size;
  unsigned binary_block_size;
  nettle_armor_encode_func encode;
  nettle_armor_init_func decode_init;
  nettle_armor_update_func decode_update;
177
178
};

179
180
181
182
183
184
185
186
#define _NETTLE_ARMOR(name, NAME) {			\
  #name,						\
  sizeof(struct name##_ctx),				\
  NAME##_TEXT_BLOCK_SIZE,				\
  NAME##_BINARY_BLOCK_SIZE,				\
  (nettle_armor_encode_func) name##_encode,		\
  (nettle_armor_init_func) name##_decode_init,		\
  (nettle_armor_update_func) name##_decode_update	\
187
188
189
}

extern const struct nettle_armor nettle_base64;
190
/* extern const struct nettle_armor nettle_base16; */
191

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