1 /* $OpenBSD: hmac.c,v 1.25 2018/02/17 14:53:58 jsing Exp $ */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 * All rights reserved.
4 *
5 * This package is an SSL implementation written
6 * by Eric Young (eay@cryptsoft.com).
7 * The implementation was written so as to conform with Netscapes SSL.
8 *
9 * This library is free for commercial and non-commercial use as long as
10 * the following conditions are aheared to. The following conditions
11 * apply to all code found in this distribution, be it the RC4, RSA,
12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 * included with this distribution is covered by the same copyright terms
14 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 *
16 * Copyright remains Eric Young's, and as such any Copyright notices in
17 * the code are not to be removed.
18 * If this package is used in a product, Eric Young should be given attribution
19 * as the author of the parts of the library used.
20 * This can be in the form of a textual message at program startup or
21 * in documentation (online or textual) provided with the package.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
25 * are met:
26 * 1. Redistributions of source code must retain the copyright
27 * notice, this list of conditions and the following disclaimer.
28 * 2. Redistributions in binary form must reproduce the above copyright
29 * notice, this list of conditions and the following disclaimer in the
30 * documentation and/or other materials provided with the distribution.
31 * 3. All advertising materials mentioning features or use of this software
32 * must display the following acknowledgement:
33 * "This product includes cryptographic software written by
34 * Eric Young (eay@cryptsoft.com)"
35 * The word 'cryptographic' can be left out if the rouines from the library
36 * being used are not cryptographic related :-).
37 * 4. If you include any Windows specific code (or a derivative thereof) from
38 * the apps directory (application code) you must include an acknowledgement:
39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 *
41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 * SUCH DAMAGE.
52 *
53 * The licence and distribution terms for any publically available version or
54 * derivative of this code cannot be changed. i.e. this code cannot simply be
55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.]
57 */
58
59 #include <stdio.h>
60 #include <stdlib.h>
61 #include <string.h>
62
63 #include <openssl/err.h>
64 #include <openssl/hmac.h>
65
66 int
HMAC_Init_ex(HMAC_CTX * ctx,const void * key,int len,const EVP_MD * md,ENGINE * impl)67 HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md,
68 ENGINE *impl)
69 {
70 int i, j, reset = 0;
71 unsigned char pad[HMAC_MAX_MD_CBLOCK];
72
73 /* If we are changing MD then we must have a key */
74 if (md != NULL && md != ctx->md && (key == NULL || len < 0))
75 return 0;
76
77 if (md != NULL) {
78 reset = 1;
79 ctx->md = md;
80 } else if (ctx->md != NULL)
81 md = ctx->md;
82 else
83 return 0;
84
85 if (key != NULL) {
86 reset = 1;
87 j = EVP_MD_block_size(md);
88 if ((size_t)j > sizeof(ctx->key)) {
89 EVPerror(EVP_R_BAD_BLOCK_LENGTH);
90 goto err;
91 }
92 if (j < len) {
93 if (!EVP_DigestInit_ex(&ctx->md_ctx, md, impl))
94 goto err;
95 if (!EVP_DigestUpdate(&ctx->md_ctx, key, len))
96 goto err;
97 if (!EVP_DigestFinal_ex(&(ctx->md_ctx), ctx->key,
98 &ctx->key_length))
99 goto err;
100 } else {
101 if (len < 0 || (size_t)len > sizeof(ctx->key)) {
102 EVPerror(EVP_R_BAD_KEY_LENGTH);
103 goto err;
104 }
105 memcpy(ctx->key, key, len);
106 ctx->key_length = len;
107 }
108 if (ctx->key_length != HMAC_MAX_MD_CBLOCK)
109 memset(&ctx->key[ctx->key_length], 0,
110 HMAC_MAX_MD_CBLOCK - ctx->key_length);
111 }
112
113 if (reset) {
114 for (i = 0; i < HMAC_MAX_MD_CBLOCK; i++)
115 pad[i] = 0x36 ^ ctx->key[i];
116 if (!EVP_DigestInit_ex(&ctx->i_ctx, md, impl))
117 goto err;
118 if (!EVP_DigestUpdate(&ctx->i_ctx, pad, EVP_MD_block_size(md)))
119 goto err;
120
121 for (i = 0; i < HMAC_MAX_MD_CBLOCK; i++)
122 pad[i] = 0x5c ^ ctx->key[i];
123 if (!EVP_DigestInit_ex(&ctx->o_ctx, md, impl))
124 goto err;
125 if (!EVP_DigestUpdate(&ctx->o_ctx, pad, EVP_MD_block_size(md)))
126 goto err;
127 }
128 if (!EVP_MD_CTX_copy_ex(&ctx->md_ctx, &ctx->i_ctx))
129 goto err;
130 return 1;
131 err:
132 return 0;
133 }
134
135 int
HMAC_Init(HMAC_CTX * ctx,const void * key,int len,const EVP_MD * md)136 HMAC_Init(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md)
137 {
138 if (key && md)
139 HMAC_CTX_init(ctx);
140 return HMAC_Init_ex(ctx, key, len, md, NULL);
141 }
142
143 int
HMAC_Update(HMAC_CTX * ctx,const unsigned char * data,size_t len)144 HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, size_t len)
145 {
146 if (ctx->md == NULL)
147 return 0;
148
149 return EVP_DigestUpdate(&ctx->md_ctx, data, len);
150 }
151
152 int
HMAC_Final(HMAC_CTX * ctx,unsigned char * md,unsigned int * len)153 HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len)
154 {
155 unsigned int i;
156 unsigned char buf[EVP_MAX_MD_SIZE];
157
158 if (ctx->md == NULL)
159 goto err;
160
161 if (!EVP_DigestFinal_ex(&ctx->md_ctx, buf, &i))
162 goto err;
163 if (!EVP_MD_CTX_copy_ex(&ctx->md_ctx, &ctx->o_ctx))
164 goto err;
165 if (!EVP_DigestUpdate(&ctx->md_ctx, buf, i))
166 goto err;
167 if (!EVP_DigestFinal_ex(&ctx->md_ctx, md, len))
168 goto err;
169 return 1;
170 err:
171 return 0;
172 }
173
174 HMAC_CTX *
HMAC_CTX_new(void)175 HMAC_CTX_new(void)
176 {
177 HMAC_CTX *ctx;
178
179 if ((ctx = calloc(1, sizeof(*ctx))) == NULL)
180 return NULL;
181
182 HMAC_CTX_init(ctx);
183
184 return ctx;
185 }
186
187 void
HMAC_CTX_free(HMAC_CTX * ctx)188 HMAC_CTX_free(HMAC_CTX *ctx)
189 {
190 if (ctx == NULL)
191 return;
192
193 HMAC_CTX_cleanup(ctx);
194
195 free(ctx);
196 }
197
198 int
HMAC_CTX_reset(HMAC_CTX * ctx)199 HMAC_CTX_reset(HMAC_CTX *ctx)
200 {
201 HMAC_CTX_cleanup(ctx);
202 HMAC_CTX_init(ctx);
203 return 1;
204 }
205
206 void
HMAC_CTX_init(HMAC_CTX * ctx)207 HMAC_CTX_init(HMAC_CTX *ctx)
208 {
209 EVP_MD_CTX_init(&ctx->i_ctx);
210 EVP_MD_CTX_init(&ctx->o_ctx);
211 EVP_MD_CTX_init(&ctx->md_ctx);
212 ctx->md = NULL;
213 }
214
215 int
HMAC_CTX_copy(HMAC_CTX * dctx,HMAC_CTX * sctx)216 HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx)
217 {
218 if (!EVP_MD_CTX_copy(&dctx->i_ctx, &sctx->i_ctx))
219 goto err;
220 if (!EVP_MD_CTX_copy(&dctx->o_ctx, &sctx->o_ctx))
221 goto err;
222 if (!EVP_MD_CTX_copy(&dctx->md_ctx, &sctx->md_ctx))
223 goto err;
224 memcpy(dctx->key, sctx->key, HMAC_MAX_MD_CBLOCK);
225 dctx->key_length = sctx->key_length;
226 dctx->md = sctx->md;
227 return 1;
228 err:
229 return 0;
230 }
231
232 void
HMAC_CTX_cleanup(HMAC_CTX * ctx)233 HMAC_CTX_cleanup(HMAC_CTX *ctx)
234 {
235 EVP_MD_CTX_cleanup(&ctx->i_ctx);
236 EVP_MD_CTX_cleanup(&ctx->o_ctx);
237 EVP_MD_CTX_cleanup(&ctx->md_ctx);
238 explicit_bzero(ctx, sizeof(*ctx));
239 }
240
241 void
HMAC_CTX_set_flags(HMAC_CTX * ctx,unsigned long flags)242 HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags)
243 {
244 EVP_MD_CTX_set_flags(&ctx->i_ctx, flags);
245 EVP_MD_CTX_set_flags(&ctx->o_ctx, flags);
246 EVP_MD_CTX_set_flags(&ctx->md_ctx, flags);
247 }
248
249 const EVP_MD *
HMAC_CTX_get_md(const HMAC_CTX * ctx)250 HMAC_CTX_get_md(const HMAC_CTX *ctx)
251 {
252 return ctx->md;
253 }
254
255 unsigned char *
HMAC(const EVP_MD * evp_md,const void * key,int key_len,const unsigned char * d,size_t n,unsigned char * md,unsigned int * md_len)256 HMAC(const EVP_MD *evp_md, const void *key, int key_len, const unsigned char *d,
257 size_t n, unsigned char *md, unsigned int *md_len)
258 {
259 HMAC_CTX c;
260 static unsigned char m[EVP_MAX_MD_SIZE];
261
262 if (md == NULL)
263 md = m;
264 HMAC_CTX_init(&c);
265 if (!HMAC_Init(&c, key, key_len, evp_md))
266 goto err;
267 if (!HMAC_Update(&c, d, n))
268 goto err;
269 if (!HMAC_Final(&c, md, md_len))
270 goto err;
271 HMAC_CTX_cleanup(&c);
272 return md;
273 err:
274 HMAC_CTX_cleanup(&c);
275 return NULL;
276 }
277