nettle-internal.c 4.9 KB
Newer Older
Niels Möller's avatar
Niels Möller committed
1
2
3
4
5
6
7
8
/* nettle-internal.c
 *
 * 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
#if HAVE_CONFIG_H
28
# include "config.h"
29
#endif
Niels Möller's avatar
Niels Möller committed
30
31
32
33

#include <assert.h>
#include <stdlib.h>

34
35
#include "nettle-internal.h"
#include "blowfish.h"
36
#include "des.h"
Niels Möller's avatar
Niels Möller committed
37
#include "eax.h"
38
#include "gcm.h"
39
#include "salsa20.h"
40

41
/* DES uses a different signature for the key set function. We ignore
42
   the return value indicating weak keys. */
Niels Möller's avatar
Niels Möller committed
43
static void
44
des_set_key_hack(void *ctx, size_t length, const uint8_t *key)
Niels Möller's avatar
Niels Möller committed
45
46
{
  assert(length == DES_KEY_SIZE);
47
  des_set_key(ctx, key);
Niels Möller's avatar
Niels Möller committed
48
49
50
}

static void
51
des3_set_key_hack(void *ctx, size_t length, const uint8_t *key)
Niels Möller's avatar
Niels Möller committed
52
53
{
  assert(length == DES3_KEY_SIZE);
54
  des3_set_key(ctx, key);
Niels Möller's avatar
Niels Möller committed
55
56
}

57
58
/* NOTE: A bit ugly. Ignores weak keys, and pretends the set:key
   functions have no return value. */
Niels Möller's avatar
Niels Möller committed
59
60
61
62
63
const struct nettle_cipher
nettle_des = {
  "des", sizeof(struct des_ctx),
  DES_BLOCK_SIZE, DES_KEY_SIZE,
  des_set_key_hack, des_set_key_hack,
64
65
  (nettle_crypt_func *) des_encrypt,
  (nettle_crypt_func *) des_decrypt
Niels Möller's avatar
Niels Möller committed
66
67
68
69
70
71
72
};

const struct nettle_cipher
nettle_des3 = {
 "des3", sizeof(struct des3_ctx),
 DES3_BLOCK_SIZE, DES3_KEY_SIZE,
 des3_set_key_hack, des3_set_key_hack,
73
74
 (nettle_crypt_func *) des3_encrypt,
 (nettle_crypt_func *) des3_decrypt
Niels Möller's avatar
Niels Möller committed
75
76
};

77
78
/* NOTE: This is not as nice as one might think, as we pretend
   blowfish_set_key has no return value. */
Niels Möller's avatar
Niels Möller committed
79
const struct nettle_cipher
80
nettle_blowfish128 = _NETTLE_CIPHER(blowfish, BLOWFISH, 128);
81

82
83
/* Sets a fix zero iv. For benchmarking only. */
static void
84
salsa20_set_key_hack(void *ctx, size_t length, const uint8_t *key)
85
86
87
{
  static const uint8_t iv[SALSA20_IV_SIZE];
  salsa20_set_key (ctx, length, key);
88
  salsa20_set_iv (ctx, iv);
89
90
91
92
93
94
95
96
97
98
99
100
}

/* Claim zero block size, to classify as a stream cipher. */
const struct nettle_cipher
nettle_salsa20 = {
  "salsa20", sizeof(struct salsa20_ctx),
  0, SALSA20_KEY_SIZE,
  salsa20_set_key_hack, salsa20_set_key_hack,
  (nettle_crypt_func *) salsa20_crypt,
  (nettle_crypt_func *) salsa20_crypt
};

Niels Möller's avatar
Niels Möller committed
101
102
103
104
105
106
107
108
109
const struct nettle_cipher
nettle_salsa20r12 = {
  "salsa20r12", sizeof(struct salsa20_ctx),
  0, SALSA20_KEY_SIZE,
  salsa20_set_key_hack, salsa20_set_key_hack,
  (nettle_crypt_func *) salsa20r12_crypt,
  (nettle_crypt_func *) salsa20r12_crypt
};

110
111
112
113
114
115
const struct nettle_aead
nettle_gcm_aes128 = _NETTLE_AEAD(gcm, GCM, aes, 128);
const struct nettle_aead
nettle_gcm_aes192 = _NETTLE_AEAD(gcm, GCM, aes, 192);
const struct nettle_aead
nettle_gcm_aes256 = _NETTLE_AEAD(gcm, GCM, aes, 256);
Niels Möller's avatar
Niels Möller committed
116
117
118
119
120

/* Old, unified, interface */
const struct nettle_cipher nettle_unified_aes128
= _NETTLE_CIPHER_SEP(aes, AES, 128);

Niels Möller's avatar
Niels Möller committed
121
122
const struct nettle_cipher nettle_unified_aes192
= _NETTLE_CIPHER_SEP(aes, AES, 192);
123
124
125

const struct nettle_cipher nettle_unified_aes256
= _NETTLE_CIPHER_SEP(aes, AES, 256);
Niels Möller's avatar
Niels Möller committed
126
127
128
129
130
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

/* eax-aes128 */
void
eax_aes128_set_key(struct eax_aes128_ctx *ctx, size_t length,
		   const uint8_t *key)
{
  assert (length == AES128_KEY_SIZE);
  aes128_set_encrypt_key (&ctx->cipher, key);
  eax_set_key (&ctx->key, &ctx->cipher,
	       (nettle_crypt_func *) aes128_encrypt);

  /* Can't use EAX_SET_KEY due to aes128_set_encrypt_key /
     nettle_crypt_func impedance mismatch */
}

void
eax_aes128_set_nonce(struct eax_aes128_ctx *ctx,
		     size_t length, const uint8_t *iv)
{
  EAX_SET_NONCE(ctx, aes128_encrypt, length, iv);
}

void
eax_aes128_update(struct eax_aes128_ctx *ctx, size_t length, const uint8_t *data)
{
  EAX_UPDATE(ctx, aes128_encrypt, length, data);
}

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

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

void
eax_aes128_digest(struct eax_aes128_ctx *ctx,
	       size_t length, uint8_t *digest)
{
  EAX_DIGEST(ctx, aes128_encrypt, length, digest);
}

/* FIXME: Rename to set_nonce, in struct nettle_aead. */
#define eax_aes128_set_iv eax_aes128_set_nonce

const struct nettle_aead
nettle_eax_aes128 = _NETTLE_AEAD_FIX(eax, EAX, aes128, 128);