nettle-internal.c 5.48 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"
Niels Möller's avatar
Niels Möller committed
39
#include "chacha.h"
40
#include "salsa20.h"
41

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

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

58 59
/* 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
60 61 62 63 64
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,
65 66
  (nettle_crypt_func *) des_encrypt,
  (nettle_crypt_func *) des_decrypt
Niels Möller's avatar
Niels Möller committed
67 68 69 70 71 72 73
};

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,
74 75
 (nettle_crypt_func *) des3_encrypt,
 (nettle_crypt_func *) des3_decrypt
Niels Möller's avatar
Niels Möller committed
76 77
};

78 79
/* 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
80
const struct nettle_cipher
81
nettle_blowfish128 = _NETTLE_CIPHER(blowfish, BLOWFISH, 128);
82

Niels Möller's avatar
Niels Möller committed
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
/* Sets a fix zero iv. For benchmarking only. */
static void
chacha_set_key_hack(void *ctx, size_t length, const uint8_t *key)
{
  static const uint8_t iv[CHACHA_IV_SIZE];
  chacha_set_key (ctx, length, key);
  chacha_set_iv (ctx, iv);
}

/* Claim zero block size, to classify as a stream cipher. */
const struct nettle_cipher
nettle_chacha = {
  "chacha", sizeof(struct chacha_ctx),
  0, CHACHA_KEY_SIZE,
  chacha_set_key_hack, chacha_set_key_hack,
  (nettle_crypt_func *) chacha_crypt,
  (nettle_crypt_func *) chacha_crypt
};

102 103
/* Sets a fix zero iv. For benchmarking only. */
static void
104
salsa20_set_key_hack(void *ctx, size_t length, const uint8_t *key)
105 106 107
{
  static const uint8_t iv[SALSA20_IV_SIZE];
  salsa20_set_key (ctx, length, key);
108
  salsa20_set_iv (ctx, iv);
109 110 111 112 113 114 115 116 117 118 119 120
}

/* 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
121 122 123 124 125 126 127 128 129
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
};

Niels Möller's avatar
Niels Möller committed
130 131 132
#define gcm_aes128_set_nonce gcm_aes128_set_iv
#define gcm_aes192_set_nonce gcm_aes192_set_iv
#define gcm_aes256_set_nonce gcm_aes256_set_iv
133
const struct nettle_aead
Niels Möller's avatar
Niels Möller committed
134
nettle_gcm_aes128 = _NETTLE_AEAD(gcm, GCM, aes128, 128);
135
const struct nettle_aead
Niels Möller's avatar
Niels Möller committed
136
nettle_gcm_aes192 = _NETTLE_AEAD(gcm, GCM, aes192, 192);
137
const struct nettle_aead
Niels Möller's avatar
Niels Möller committed
138 139
nettle_gcm_aes256 = _NETTLE_AEAD(gcm, GCM, aes256, 256);

Niels Möller's avatar
Niels Möller committed
140 141 142 143 144

/* 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
145 146
const struct nettle_cipher nettle_unified_aes192
= _NETTLE_CIPHER_SEP(aes, AES, 192);
147 148 149

const struct nettle_cipher nettle_unified_aes256
= _NETTLE_CIPHER_SEP(aes, AES, 256);
Niels Möller's avatar
Niels Möller committed
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 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199

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

const struct nettle_aead
Niels Möller's avatar
Niels Möller committed
200
nettle_eax_aes128 = _NETTLE_AEAD(eax, EAX, aes128, 128);