hmac.h 5.66 KB
Newer Older
Niels Möller's avatar
Niels Möller committed
1
/* hmac.h
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

   HMAC message authentication code (RFC-2104).

   Copyright (C) 2001, 2002 Niels Möller

   This file is part of GNU Nettle.

   GNU Nettle is free software: you can redistribute it and/or
   modify it under the terms of either:

     * the GNU Lesser General Public License as published by the Free
       Software Foundation; either version 3 of the License, or (at your
       option) any later version.

   or

     * the GNU General Public License as published by the Free
       Software Foundation; either version 2 of the License, or (at your
       option) any later version.

   or both in parallel, as here.

   GNU Nettle 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
   General Public License for more details.

   You should have received copies of the GNU General Public License and
   the GNU Lesser General Public License along with this program.  If
   not, see http://www.gnu.org/licenses/.
*/
Niels Möller's avatar
Niels Möller committed
33 34 35 36 37 38

#ifndef NETTLE_HMAC_H_INCLUDED
#define NETTLE_HMAC_H_INCLUDED

#include "nettle-meta.h"

39
#include "md5.h"
40
#include "ripemd160.h"
41 42
#include "sha1.h"
#include "sha2.h"
43

Niels Möller's avatar
Niels Möller committed
44 45 46 47
#ifdef __cplusplus
extern "C" {
#endif

48 49 50 51 52 53 54
/* Namespace mangling */
#define hmac_set_key nettle_hmac_set_key
#define hmac_update nettle_hmac_update
#define hmac_digest nettle_hmac_digest
#define hmac_md5_set_key nettle_hmac_md5_set_key
#define hmac_md5_update nettle_hmac_md5_update
#define hmac_md5_digest nettle_hmac_md5_digest
55 56 57
#define hmac_ripemd160_set_key nettle_hmac_ripemd160_set_key
#define hmac_ripemd160_update nettle_hmac_ripemd160_update
#define hmac_ripemd160_digest nettle_hmac_ripemd160_digest
58 59 60
#define hmac_sha1_set_key nettle_hmac_sha1_set_key
#define hmac_sha1_update nettle_hmac_sha1_update
#define hmac_sha1_digest nettle_hmac_sha1_digest
61 62
#define hmac_sha224_set_key nettle_hmac_sha224_set_key
#define hmac_sha224_digest nettle_hmac_sha224_digest
63 64 65
#define hmac_sha256_set_key nettle_hmac_sha256_set_key
#define hmac_sha256_update nettle_hmac_sha256_update
#define hmac_sha256_digest nettle_hmac_sha256_digest
66 67
#define hmac_sha384_set_key nettle_hmac_sha384_set_key
#define hmac_sha384_digest nettle_hmac_sha384_digest
68 69 70
#define hmac_sha512_set_key nettle_hmac_sha512_set_key
#define hmac_sha512_update nettle_hmac_sha512_update
#define hmac_sha512_digest nettle_hmac_sha512_digest
Niels Möller's avatar
Niels Möller committed
71 72

void
73 74
hmac_set_key(void *outer, void *inner, void *state,
	     const struct nettle_hash *hash,
75
	     size_t length, const uint8_t *key);
Niels Möller's avatar
Niels Möller committed
76

77 78
/* This function is not strictly needed, it's s just the same as the
 * hash update function. */
Niels Möller's avatar
Niels Möller committed
79
void
80 81
hmac_update(void *state,
	    const struct nettle_hash *hash,
82
	    size_t length, const uint8_t *data);
Niels Möller's avatar
Niels Möller committed
83 84

void
85 86
hmac_digest(const void *outer, const void *inner, void *state,
	    const struct nettle_hash *hash,
87
	    size_t length, uint8_t *digest);
88

Niels Möller's avatar
Niels Möller committed
89 90 91 92

#define HMAC_CTX(type) \
{ type outer; type inner; type state; }

93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
#define HMAC_SET_KEY(ctx, hash, length, key)			\
  hmac_set_key( &(ctx)->outer, &(ctx)->inner, &(ctx)->state,	\
                (hash), (length), (key) )

#define HMAC_DIGEST(ctx, hash, length, digest)			\
  hmac_digest( &(ctx)->outer, &(ctx)->inner, &(ctx)->state,	\
               (hash), (length), (digest) )

/* HMAC using specific hash functions */

/* hmac-md5 */
struct hmac_md5_ctx HMAC_CTX(struct md5_ctx);

void
hmac_md5_set_key(struct hmac_md5_ctx *ctx,
108
		 size_t key_length, const uint8_t *key);
109 110 111

void
hmac_md5_update(struct hmac_md5_ctx *ctx,
112
		size_t length, const uint8_t *data);
113 114 115

void
hmac_md5_digest(struct hmac_md5_ctx *ctx,
116
		size_t length, uint8_t *digest);
117 118


119 120 121 122 123
/* hmac-ripemd160 */
struct hmac_ripemd160_ctx HMAC_CTX(struct ripemd160_ctx);

void
hmac_ripemd160_set_key(struct hmac_ripemd160_ctx *ctx,
124
		       size_t key_length, const uint8_t *key);
125 126 127

void
hmac_ripemd160_update(struct hmac_ripemd160_ctx *ctx,
128
		      size_t length, const uint8_t *data);
129 130 131

void
hmac_ripemd160_digest(struct hmac_ripemd160_ctx *ctx,
132
		      size_t length, uint8_t *digest);
133 134


135 136 137 138 139
/* hmac-sha1 */
struct hmac_sha1_ctx HMAC_CTX(struct sha1_ctx);

void
hmac_sha1_set_key(struct hmac_sha1_ctx *ctx,
140
		  size_t key_length, const uint8_t *key);
141 142 143

void
hmac_sha1_update(struct hmac_sha1_ctx *ctx,
144
		 size_t length, const uint8_t *data);
145 146 147

void
hmac_sha1_digest(struct hmac_sha1_ctx *ctx,
148
		 size_t length, uint8_t *digest);
149 150 151 152 153 154

/* hmac-sha256 */
struct hmac_sha256_ctx HMAC_CTX(struct sha256_ctx);

void
hmac_sha256_set_key(struct hmac_sha256_ctx *ctx,
155
		    size_t key_length, const uint8_t *key);
156 157 158

void
hmac_sha256_update(struct hmac_sha256_ctx *ctx,
159
		   size_t length, const uint8_t *data);
160 161 162

void
hmac_sha256_digest(struct hmac_sha256_ctx *ctx,
163
		   size_t length, uint8_t *digest);
Niels Möller's avatar
Niels Möller committed
164

165 166 167 168 169
/* hmac-sha224 */
#define hmac_sha224_ctx hmac_sha256_ctx

void
hmac_sha224_set_key(struct hmac_sha224_ctx *ctx,
170
		    size_t key_length, const uint8_t *key);
171 172 173 174 175

#define hmac_sha224_update nettle_hmac_sha256_update

void
hmac_sha224_digest(struct hmac_sha224_ctx *ctx,
176
		   size_t length, uint8_t *digest);
177

178 179 180 181 182
/* hmac-sha512 */
struct hmac_sha512_ctx HMAC_CTX(struct sha512_ctx);

void
hmac_sha512_set_key(struct hmac_sha512_ctx *ctx,
183
		    size_t key_length, const uint8_t *key);
184 185 186

void
hmac_sha512_update(struct hmac_sha512_ctx *ctx,
187
		   size_t length, const uint8_t *data);
188 189 190

void
hmac_sha512_digest(struct hmac_sha512_ctx *ctx,
191
		   size_t length, uint8_t *digest);
192

Niels Möller's avatar
Niels Möller committed
193 194 195 196 197
/* hmac-sha384 */
#define hmac_sha384_ctx hmac_sha512_ctx

void
hmac_sha384_set_key(struct hmac_sha512_ctx *ctx,
198
		    size_t key_length, const uint8_t *key);
Niels Möller's avatar
Niels Möller committed
199

200
#define hmac_sha384_update nettle_hmac_sha512_update
Niels Möller's avatar
Niels Möller committed
201 202 203

void
hmac_sha384_digest(struct hmac_sha512_ctx *ctx,
204
		   size_t length, uint8_t *digest);
Niels Möller's avatar
Niels Möller committed
205

Niels Möller's avatar
Niels Möller committed
206 207 208 209
#ifdef __cplusplus
}
#endif

Niels Möller's avatar
Niels Möller committed
210
#endif /* NETTLE_HMAC_H_INCLUDED */