5 Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
7 Copyright (C) 1997 - 2000 Pekka Riikonen
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
23 * Revision 1.3 2000/07/14 09:12:24 priikone
24 * Fixed bug in silc_hmac_make.
26 * Revision 1.2 2000/07/05 06:08:43 priikone
27 * Global cosmetic change.
29 * Revision 1.1.1.1 2000/06/27 11:36:55 priikone
30 * Imported from internal CVS/Added Log headers.
35 #include "silcincludes.h"
37 /* Allocates a new SilcHmac object. First argument is the hash function
38 object to tell the hmac which hash function should be used when creating
39 HMAC's. The new SilcHmac object is returned to new_hmac argument. */
41 int silc_hmac_alloc(SilcHash hash, SilcHmac *new_hmac)
43 SILC_LOG_DEBUG(("Allocating new hmac object"));
45 *new_hmac = silc_calloc(1, sizeof(**new_hmac));
46 (*new_hmac)->hash = hash;
47 (*new_hmac)->set_key = silc_hmac_set_key;
48 (*new_hmac)->make_hmac = silc_hmac_make;
49 (*new_hmac)->make_hmac_with_key = silc_hmac_make_with_key;
50 (*new_hmac)->make_hmac_truncated = silc_hmac_make_truncated;
55 /* Free's the SilcHmac object. */
57 void silc_hmac_free(SilcHmac hmac)
63 /* Creates the HMAC. The created keyed hash value is returned to
64 return_hash argument. */
66 void silc_hmac_make_internal(SilcHmac hmac, unsigned char *data,
67 unsigned int data_len, unsigned char *key,
68 unsigned int key_len, unsigned char *return_hash)
70 SilcHash hash = hmac->hash;
71 unsigned char inner_pad[hash->hash->block_len + 1];
72 unsigned char outer_pad[hash->hash->block_len + 1];
73 unsigned char hvalue[hash->hash->hash_len];
77 SILC_LOG_DEBUG(("Making HMAC for message"));
79 hash_context = silc_calloc(1, hash->hash->context_len());
81 memset(inner_pad, 0, sizeof(inner_pad));
82 memset(outer_pad, 0, sizeof(outer_pad));
84 /* If the key length is more than block size of the hash function, the
86 if (key_len > hash->hash->block_len) {
87 hash->make_hash(hash, key, key_len, hvalue);
89 key_len = hash->hash->hash_len;
92 /* Copy the key into the pads */
93 memcpy(inner_pad, key, key_len);
94 memcpy(outer_pad, key, key_len);
96 /* XOR the key with pads */
97 for (i = 0; i < hash->hash->block_len; i++) {
102 /* Do the HMAC transform (too bad I can't do make_hash directly, sigh) */
103 hash->hash->init(hash_context);
104 hash->hash->update(hash_context, inner_pad, hash->hash->block_len);
105 hash->hash->update(hash_context, data, data_len);
106 hash->hash->final(hash_context, return_hash);
107 hash->hash->init(hash_context);
108 hash->hash->update(hash_context, outer_pad, hash->hash->block_len);
109 hash->hash->update(hash_context, return_hash, hash->hash->hash_len);
110 hash->hash->final(hash_context, return_hash);
113 /* Create the HMAC. This is thee make_hmac function pointer. This
114 uses the internal key set with silc_hmac_set_key. */
116 void silc_hmac_make(SilcHmac hmac, unsigned char *data,
117 unsigned int data_len, unsigned char *return_hash)
119 silc_hmac_make_internal(hmac, data, data_len, hmac->key,
120 hmac->key_len, return_hash);
123 /* Creates the HMAC just as above except that the hash value is truncated
124 to the truncated_len sent as argument. NOTE: One should not truncate to
125 less than half of the length of original hash value. However, this
126 routine allows these dangerous truncations. */
128 void silc_hmac_make_truncated(SilcHmac hmac, unsigned char *data,
129 unsigned int data_len,
130 unsigned int truncated_len,
131 unsigned char *return_hash)
133 unsigned char hvalue[hmac->hash->hash->hash_len];
135 silc_hmac_make_internal(hmac, data, data_len,
136 hmac->key, hmac->key_len, hvalue);
137 memcpy(return_hash, hvalue, truncated_len);
138 memset(hvalue, 0, sizeof(hvalue));
141 /* Creates HMAC just as above except that this doesn't use the internal
142 key. The key is sent as argument to the function. */
144 void silc_hmac_make_with_key(SilcHmac hmac, unsigned char *data,
145 unsigned int data_len,
146 unsigned char *key, unsigned int key_len,
147 unsigned char *return_hash)
149 silc_hmac_make_internal(hmac, data, data_len, key, key_len, return_hash);
152 /* Sets the HMAC key used in the HMAC creation */
154 void silc_hmac_set_key(SilcHmac hmac, const unsigned char *key,
155 unsigned int key_len)
157 hmac->key = silc_calloc(key_len, sizeof(unsigned char));
158 hmac->key_len = key_len;
159 memcpy(hmac->key, key, key_len);