nettle-meta.h 4.88 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
31
32
33
34
35
/* 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>

/* Ciphers */
typedef void (*nettle_crypt_func)(void *ctx,
				  unsigned length, uint8_t *dst,
				  const uint8_t *src);

36
typedef void (*nettle_set_key_func)(void *ctx,
Niels Möller's avatar
Niels Möller committed
37
38
39
40
41
42
43
44
45
46
47
48
49
				   unsigned length,
				   const uint8_t *key);


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

50
  /* Suggested key size; other sizes are sometimes possible. */
Niels Möller's avatar
Niels Möller committed
51
52
  unsigned key_size;

53
54
  nettle_set_key_func set_encrypt_key;
  nettle_set_key_func set_decrypt_key;
Niels Möller's avatar
Niels Möller committed
55
56
57
58
59
60

  nettle_crypt_func encrypt;
  nettle_crypt_func decrypt;
};

#define _NETTLE_CIPHER(name, NAME, keysize) {	\
61
  #name #keysize,				\
Niels Möller's avatar
Niels Möller committed
62
63
  sizeof(struct name##_ctx),			\
  NAME##_BLOCK_SIZE,				\
64
  keysize / 8,					\
Niels Möller's avatar
Niels Möller committed
65
66
67
68
69
  (nettle_set_key_func) name##_set_key,		\
  (nettle_set_key_func) name##_set_key,		\
  (nettle_crypt_func) name##_encrypt,		\
  (nettle_crypt_func) name##_decrypt,		\
}
70
71
72
73
74
75
76
77
78
79
80
81

#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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
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;


98
/* Hash algorithms */
Niels Möller's avatar
Niels Möller committed
99
100
101
102
103
104
105
106
107
108
109
110
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 */
111
  unsigned context_size;
Niels Möller's avatar
Niels Möller committed
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

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

138
139

/* ASCII armor codecs */
140
141
142
143
144
145
146
147
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);
148
149
150
151

struct nettle_armor
{
  const char *name;
152
153
154
155
156
157
  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;
158
159
};

160
161
162
163
164
165
166
167
#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	\
168
169
170
}

extern const struct nettle_armor nettle_base64;
171
/* extern const struct nettle_armor nettle_base16; */
172

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