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);