1/*
2 * Copyright (c) 2006 - 2007 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * 3. Neither the name of the Institute nor the names of its contributors
18 *    may be used to endorse or promote products derived from this software
19 *    without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#include <sys/types.h>
35#include <stdio.h>
36#include <stdlib.h>
37#include <string.h>
38#include <hmac.h>
39
40void
41HMAC_CTX_init(HMAC_CTX *ctx)
42{
43    memset(ctx, 0, sizeof(*ctx));
44}
45
46void
47HMAC_CTX_cleanup(HMAC_CTX *ctx)
48{
49    if (ctx->buf) {
50	memset(ctx->buf, 0, ctx->key_length);
51	free(ctx->buf);
52	ctx->buf = NULL;
53    }
54    if (ctx->opad) {
55	memset(ctx->opad, 0, EVP_MD_block_size(ctx->md));
56	free(ctx->opad);
57	ctx->opad = NULL;
58    }
59    if (ctx->ipad) {
60	memset(ctx->ipad, 0, EVP_MD_block_size(ctx->md));
61	free(ctx->ipad);
62	ctx->ipad = NULL;
63    }
64    if (ctx->ctx) {
65	EVP_MD_CTX_destroy(ctx->ctx);
66	ctx->ctx = NULL;
67    }
68}
69
70size_t
71HMAC_size(const HMAC_CTX *ctx)
72{
73    return EVP_MD_size(ctx->md);
74}
75
76void
77HMAC_Init_ex(HMAC_CTX *ctx,
78	     const void *key,
79	     size_t keylen,
80	     const EVP_MD *md,
81	     ENGINE *engine)
82{
83    unsigned char *p;
84    size_t i;
85
86    if (ctx->md != md) {
87	ctx->md = md;
88	if (ctx->buf) {
89	    memset(ctx->buf, 0, ctx->key_length);
90	    free (ctx->buf);
91	}
92	ctx->key_length = EVP_MD_size(ctx->md);
93	ctx->buf = malloc(ctx->key_length);
94    }
95#if 0
96    ctx->engine = engine;
97#endif
98
99    if (keylen > EVP_MD_block_size(ctx->md)) {
100	EVP_Digest(key, keylen, ctx->buf, NULL, ctx->md, engine);
101	key = ctx->buf;
102	keylen = EVP_MD_size(ctx->md);
103    }
104
105    if (ctx->opad) {
106	memset(ctx->opad, 0, ctx->key_length);
107	free(ctx->opad);
108    }
109    if (ctx->ipad) {
110	memset(ctx->ipad, 0, ctx->key_length);
111	free(ctx->ipad);
112    }
113
114    ctx->opad = malloc(EVP_MD_block_size(ctx->md));
115    ctx->ipad = malloc(EVP_MD_block_size(ctx->md));
116    memset(ctx->ipad, 0x36, EVP_MD_block_size(ctx->md));
117    memset(ctx->opad, 0x5c, EVP_MD_block_size(ctx->md));
118
119    for (i = 0, p = ctx->ipad; i < keylen; i++)
120	p[i] ^= ((const unsigned char *)key)[i];
121    for (i = 0, p = ctx->opad; i < keylen; i++)
122	p[i] ^= ((const unsigned char *)key)[i];
123
124    if (ctx->ctx == NULL)
125	ctx->ctx = EVP_MD_CTX_create();
126
127    EVP_DigestInit_ex(ctx->ctx, ctx->md, ctx->engine);
128    EVP_DigestUpdate(ctx->ctx, ctx->ipad, EVP_MD_block_size(ctx->md));
129}
130
131void
132HMAC_Update(HMAC_CTX *ctx, const void *data, size_t len)
133{
134    EVP_DigestUpdate(ctx->ctx, data, len);
135}
136
137void
138HMAC_Final(HMAC_CTX *ctx, void *md, unsigned int *len)
139{
140    EVP_DigestFinal_ex(ctx->ctx, ctx->buf, NULL);
141
142    EVP_DigestInit_ex(ctx->ctx, ctx->md, ctx->engine);
143    EVP_DigestUpdate(ctx->ctx, ctx->opad, EVP_MD_block_size(ctx->md));
144    EVP_DigestUpdate(ctx->ctx, ctx->buf, ctx->key_length);
145    EVP_DigestFinal_ex(ctx->ctx, md, len);
146}
147
148void *
149HMAC(const EVP_MD *md,
150     const void *key, size_t key_size,
151     const void *data, size_t data_size,
152     void *hash, unsigned int *hash_len)
153{
154    HMAC_CTX ctx;
155
156    HMAC_CTX_init(&ctx);
157    HMAC_Init_ex(&ctx, key, key_size, md, NULL);
158    HMAC_Update(&ctx, data, data_size);
159    HMAC_Final(&ctx, hash, hash_len);
160    HMAC_CTX_cleanup(&ctx);
161    return hash;
162}
163