Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / contrib / bind-9.2.4rc7 / lib / bind / dst / hmac_link.c
1 #ifdef HMAC_MD5
2 #ifndef LINT
3 static const char rcsid[] = "$Header: /proj/cvs/prod/bind9/lib/bind/dst/hmac_link.c,v 1.2.2.1 2003/06/27 03:51:36 marka Exp $";
4 #endif
5 /*
6  * Portions Copyright (c) 1995-1998 by Trusted Information Systems, Inc.
7  *
8  * Permission to use, copy modify, and distribute this software for any
9  * purpose with or without fee is hereby granted, provided that the above
10  * copyright notice and this permission notice appear in all copies.
11  *
12  * THE SOFTWARE IS PROVIDED "AS IS" AND TRUSTED INFORMATION SYSTEMS
13  * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
14  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL
15  * TRUSTED INFORMATION SYSTEMS BE LIABLE FOR ANY SPECIAL, DIRECT,
16  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
17  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
18  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
19  * WITH THE USE OR PERFORMANCE OF THE SOFTWARE.
20  */
21
22 /* 
23  * This file contains an implementation of the HMAC-MD5 algorithm.
24  */
25 #include "port_before.h"
26
27 #include <stdio.h>
28 #include <unistd.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <memory.h>
32 #include <sys/param.h>
33 #include <sys/time.h>
34 #include <netinet/in.h>
35 #include <arpa/nameser.h>
36 #include <resolv.h>
37
38 #include "dst_internal.h"
39 #ifdef USE_MD5
40 # include "md5.h"
41 # ifndef _MD5_H_
42 #  define _MD5_H_ 1     /* make sure we do not include rsaref md5.h file */
43 # endif
44 #endif
45
46 #include "port_after.h"
47
48
49 #define HMAC_LEN        64
50 #define HMAC_IPAD       0x36
51 #define HMAC_OPAD       0x5c
52 #define MD5_LEN         16
53
54
55 typedef struct hmackey {
56         u_char hk_ipad[64], hk_opad[64];
57 } HMAC_Key;
58
59
60 /************************************************************************** 
61  * dst_hmac_md5_sign
62  *     Call HMAC signing functions to sign a block of data.
63  *     There are three steps to signing, INIT (initialize structures), 
64  *     UPDATE (hash (more) data), FINAL (generate a signature).  This
65  *     routine performs one or more of these steps.
66  * Parameters
67  *     mode     SIG_MODE_INIT, SIG_MODE_UPDATE and/or SIG_MODE_FINAL.
68  *     priv_key    key to use for signing.
69  *     context   the context to be used in this digest
70  *     data     data to be signed.
71  *     len       length in bytes of data.
72  *     signature   location to store signature.
73  *     sig_len     size of the signature location
74  * returns 
75  *      N  Success on SIG_MODE_FINAL = returns signature length in bytes
76  *      0  Success on SIG_MODE_INIT  and UPDATE
77  *       <0  Failure
78  */
79
80 static int
81 dst_hmac_md5_sign(const int mode, DST_KEY *d_key, void **context, 
82                   const u_char *data, const int len, 
83                   u_char *signature, const int sig_len)
84 {
85         HMAC_Key *key;
86         int sign_len = 0;
87         MD5_CTX *ctx = NULL;
88
89         if (mode & SIG_MODE_INIT) 
90                 ctx = (MD5_CTX *) malloc(sizeof(*ctx));
91         else if (context)
92                 ctx = (MD5_CTX *) *context;
93         if (ctx == NULL) 
94                 return (-1);
95
96         if (d_key == NULL || d_key->dk_KEY_struct == NULL)
97                 return (-1);
98         key = (HMAC_Key *) d_key->dk_KEY_struct;
99
100         if (mode & SIG_MODE_INIT) {
101                 MD5Init(ctx);
102                 MD5Update(ctx, key->hk_ipad, HMAC_LEN);
103         }
104
105         if ((mode & SIG_MODE_UPDATE) && (data && len > 0))
106                 MD5Update(ctx, data, len);
107
108         if (mode & SIG_MODE_FINAL) {
109                 if (signature == NULL || sig_len < MD5_LEN)
110                         return (SIGN_FINAL_FAILURE);
111                 MD5Final(signature, ctx);
112
113                 /* perform outer MD5 */
114                 MD5Init(ctx);
115                 MD5Update(ctx, key->hk_opad, HMAC_LEN);
116                 MD5Update(ctx, signature, MD5_LEN);
117                 MD5Final(signature, ctx);
118                 sign_len = MD5_LEN;
119                 SAFE_FREE(ctx);
120         }
121         else { 
122                 if (context == NULL) 
123                         return (-1);
124                 *context = (void *) ctx;
125         }               
126         return (sign_len);
127 }
128
129
130 /************************************************************************** 
131  * dst_hmac_md5_verify() 
132  *     Calls HMAC verification routines.  There are three steps to 
133  *     verification, INIT (initialize structures), UPDATE (hash (more) data), 
134  *     FINAL (generate a signature).  This routine performs one or more of 
135  *     these steps.
136  * Parameters
137  *     mode     SIG_MODE_INIT, SIG_MODE_UPDATE and/or SIG_MODE_FINAL.
138  *     dkey     key to use for verify.
139  *     data     data signed.
140  *     len       length in bytes of data.
141  *     signature   signature.
142  *     sig_len     length in bytes of signature.
143  * returns 
144  *     0  Success 
145  *    <0  Failure
146  */
147
148 static int
149 dst_hmac_md5_verify(const int mode, DST_KEY *d_key, void **context,
150                 const u_char *data, const int len,
151                 const u_char *signature, const int sig_len)
152 {
153         HMAC_Key *key;
154         MD5_CTX *ctx = NULL;
155
156         if (mode & SIG_MODE_INIT) 
157                 ctx = (MD5_CTX *) malloc(sizeof(*ctx));
158         else if (context)
159                 ctx = (MD5_CTX *) *context;
160         if (ctx == NULL) 
161                 return (-1);
162
163         if (d_key == NULL || d_key->dk_KEY_struct == NULL)
164                 return (-1);
165
166         key = (HMAC_Key *) d_key->dk_KEY_struct;
167         if (mode & SIG_MODE_INIT) {
168                 MD5Init(ctx);
169                 MD5Update(ctx, key->hk_ipad, HMAC_LEN);
170         }
171         if ((mode & SIG_MODE_UPDATE) && (data && len > 0))
172                 MD5Update(ctx, data, len);
173
174         if (mode & SIG_MODE_FINAL) {
175                 u_char digest[MD5_LEN];
176                 if (signature == NULL || key == NULL || sig_len != MD5_LEN)
177                         return (VERIFY_FINAL_FAILURE);
178                 MD5Final(digest, ctx);
179
180                 /* perform outer MD5 */
181                 MD5Init(ctx);
182                 MD5Update(ctx, key->hk_opad, HMAC_LEN);
183                 MD5Update(ctx, digest, MD5_LEN);
184                 MD5Final(digest, ctx);
185
186                 SAFE_FREE(ctx);
187                 if (memcmp(digest, signature, MD5_LEN) != 0)
188                         return (VERIFY_FINAL_FAILURE);
189         }
190         else { 
191                 if (context == NULL) 
192                         return (-1);
193                 *context = (void *) ctx;
194         }               
195         return (0);
196 }
197
198
199 /************************************************************************** 
200  * dst_buffer_to_hmac_md5
201  *     Converts key from raw data to an HMAC Key
202  *     This function gets in a pointer to the data
203  * Parameters
204  *     hkey     the HMAC key to be filled in
205  *     key      the key in raw format
206  *     keylen   the length of the key
207  * Return
208  *      0       Success
209  *      <0      Failure
210  */
211 static int
212 dst_buffer_to_hmac_md5(DST_KEY *dkey, const u_char *key, const int keylen)
213 {
214         int i;
215         HMAC_Key *hkey = NULL;
216         MD5_CTX ctx;
217         int local_keylen = keylen;
218
219         if (dkey == NULL || key == NULL || keylen < 0)
220                 return (-1);
221
222         if ((hkey = (HMAC_Key *) malloc(sizeof(HMAC_Key))) == NULL)
223                   return (-2);
224
225         memset(hkey->hk_ipad, 0, sizeof(hkey->hk_ipad));
226         memset(hkey->hk_opad, 0, sizeof(hkey->hk_opad));
227
228         /* if key is longer than HMAC_LEN bytes reset it to key=MD5(key) */
229         if (keylen > HMAC_LEN) {
230                 u_char tk[MD5_LEN];
231                 MD5Init(&ctx);
232                 MD5Update(&ctx, key, keylen);
233                 MD5Final(tk, &ctx);
234                 memset((void *) &ctx, 0, sizeof(ctx));
235                 key = tk;
236                 local_keylen = MD5_LEN;
237         }
238         /* start out by storing key in pads */
239         memcpy(hkey->hk_ipad, key, local_keylen);
240         memcpy(hkey->hk_opad, key, local_keylen);
241
242         /* XOR key with hk_ipad and opad values */
243         for (i = 0; i < HMAC_LEN; i++) {
244                 hkey->hk_ipad[i] ^= HMAC_IPAD;
245                 hkey->hk_opad[i] ^= HMAC_OPAD;
246         }
247         dkey->dk_key_size = local_keylen;
248         dkey->dk_KEY_struct = (void *) hkey;
249         return (1);
250 }
251
252
253 /************************************************************************** 
254  *  dst_hmac_md5_key_to_file_format
255  *      Encodes an HMAC Key into the portable file format.
256  *  Parameters 
257  *      hkey      HMAC KEY structure 
258  *      buff      output buffer
259  *      buff_len  size of output buffer 
260  *  Return
261  *      0  Failure - null input hkey
262  *     -1  Failure - not enough space in output area
263  *      N  Success - Length of data returned in buff
264  */
265
266 static int
267 dst_hmac_md5_key_to_file_format(const DST_KEY *dkey, char *buff,
268                             const int buff_len)
269 {
270         char *bp;
271         int len, b_len, i, key_len;
272         u_char key[HMAC_LEN];
273         HMAC_Key *hkey;
274
275         if (dkey == NULL || dkey->dk_KEY_struct == NULL) 
276                 return (0);
277         if (buff == NULL || buff_len <= (int) strlen(key_file_fmt_str))
278                 return (-1);    /* no OR not enough space in output area */
279
280         hkey = (HMAC_Key *) dkey->dk_KEY_struct;
281         memset(buff, 0, buff_len);      /* just in case */
282         /* write file header */
283         sprintf(buff, key_file_fmt_str, KEY_FILE_FORMAT, KEY_HMAC_MD5, "HMAC");
284
285         bp = (char *) strchr(buff, '\0');
286         b_len = buff_len - (bp - buff);
287
288         memset(key, 0, HMAC_LEN);
289         for (i = 0; i < HMAC_LEN; i++)
290                 key[i] = hkey->hk_ipad[i] ^ HMAC_IPAD;
291         for (i = HMAC_LEN - 1; i >= 0; i--)
292                 if (key[i] != 0)
293                         break;
294         key_len = i + 1;
295
296         strcat(bp, "Key: ");
297         bp += strlen("Key: ");
298         b_len = buff_len - (bp - buff);
299
300         len = b64_ntop(key, key_len, bp, b_len);
301         if (len < 0) 
302                 return (-1);
303         bp += len;
304         *(bp++) = '\n';
305         *bp = '\0';
306         b_len = buff_len - (bp - buff);
307
308         return (buff_len - b_len);
309 }
310
311
312 /************************************************************************** 
313  * dst_hmac_md5_key_from_file_format
314  *     Converts contents of a key file into an HMAC key. 
315  * Parameters 
316  *     hkey    structure to put key into 
317  *     buff       buffer containing the encoded key 
318  *     buff_len   the length of the buffer
319  * Return
320  *     n >= 0 Foot print of the key converted 
321  *     n <  0 Error in conversion 
322  */
323
324 static int
325 dst_hmac_md5_key_from_file_format(DST_KEY *dkey, const char *buff,
326                               const int buff_len)
327 {
328         const char *p = buff, *eol;
329         u_char key[HMAC_LEN+1]; /* b64_pton needs more than 64 bytes do decode
330                                                          * it should probably be fixed rather than doing
331                                                          * this
332                                                          */
333         u_char *tmp;
334         int key_len, len;
335
336         if (dkey == NULL)
337                 return (-2);
338         if (buff == NULL || buff_len < 0)
339                 return (-1);
340
341         memset(key, 0, sizeof(key));
342
343         if (!dst_s_verify_str(&p, "Key: "))
344                 return (-3);
345
346         eol = strchr(p, '\n');
347         if (eol == NULL)
348                 return (-4);
349         len = eol - p;
350         tmp = malloc(len + 2);
351         memcpy(tmp, p, len);
352         *(tmp + len) = 0x0;
353         key_len = b64_pton((char *)tmp, key, HMAC_LEN+1);       /* see above */
354         SAFE_FREE2(tmp, len + 2);
355
356         if (dst_buffer_to_hmac_md5(dkey, key, key_len) < 0) {
357                 return (-6);
358         }
359         return (0);
360 }
361
362 /*
363  * dst_hmac_md5_to_dns_key() 
364  *         function to extract hmac key from DST_KEY structure 
365  * intput: 
366  *      in_key:  HMAC-MD5 key 
367  * output: 
368  *      out_str: buffer to write ot
369  *      out_len: size of output buffer 
370  * returns:
371  *      number of bytes written to output buffer 
372  */
373 static int
374 dst_hmac_md5_to_dns_key(const DST_KEY *in_key, u_char *out_str,
375                         const int out_len)
376 {
377
378         HMAC_Key *hkey;
379         int i;
380         
381         if (in_key == NULL || in_key->dk_KEY_struct == NULL ||
382             out_len <= in_key->dk_key_size || out_str == NULL)
383                 return (-1);
384
385         hkey = (HMAC_Key *) in_key->dk_KEY_struct;
386         for (i = 0; i < in_key->dk_key_size; i++)
387                 out_str[i] = hkey->hk_ipad[i] ^ HMAC_IPAD;
388         return (i);
389 }
390
391 /************************************************************************** 
392  *  dst_hmac_md5_compare_keys
393  *      Compare two keys for equality.
394  *  Return
395  *      0         The keys are equal
396  *      NON-ZERO   The keys are not equal
397  */
398
399 static int
400 dst_hmac_md5_compare_keys(const DST_KEY *key1, const DST_KEY *key2)
401 {
402         HMAC_Key *hkey1 = (HMAC_Key *) key1->dk_KEY_struct;
403         HMAC_Key *hkey2 = (HMAC_Key *) key2->dk_KEY_struct;
404         return memcmp(hkey1->hk_ipad, hkey2->hk_ipad, HMAC_LEN);
405 }
406
407 /************************************************************************** 
408  * dst_hmac_md5_free_key_structure
409  *     Frees all (none) dynamically allocated structures in hkey
410  */
411
412 static void *
413 dst_hmac_md5_free_key_structure(void *key)
414 {
415         HMAC_Key *hkey = key;
416         SAFE_FREE(hkey);
417         return (NULL);
418 }
419
420
421 /*************************************************************************** 
422  * dst_hmac_md5_generate_key
423  *     Creates a HMAC key of size size with a maximum size of 63 bytes
424  *     generating a HMAC key larger than 63 bytes makes no sense as that key 
425  *     is digested before use. 
426  */
427
428 static int
429 dst_hmac_md5_generate_key(DST_KEY *key, const int nothing)
430 {
431         (void)key;
432         (void)nothing;
433         return (-1);
434 }
435
436 /*
437  * dst_hmac_md5_init()  Function to answer set up function pointers for HMAC
438  *         related functions 
439  */
440 int
441 dst_hmac_md5_init()
442 {
443         if (dst_t_func[KEY_HMAC_MD5] != NULL)
444                 return (1);
445         dst_t_func[KEY_HMAC_MD5] = malloc(sizeof(struct dst_func));
446         if (dst_t_func[KEY_HMAC_MD5] == NULL)
447                 return (0);
448         memset(dst_t_func[KEY_HMAC_MD5], 0, sizeof(struct dst_func));
449         dst_t_func[KEY_HMAC_MD5]->sign = dst_hmac_md5_sign;
450         dst_t_func[KEY_HMAC_MD5]->verify = dst_hmac_md5_verify;
451         dst_t_func[KEY_HMAC_MD5]->compare = dst_hmac_md5_compare_keys;
452         dst_t_func[KEY_HMAC_MD5]->generate = dst_hmac_md5_generate_key;
453         dst_t_func[KEY_HMAC_MD5]->destroy = dst_hmac_md5_free_key_structure;
454         dst_t_func[KEY_HMAC_MD5]->to_dns_key = dst_hmac_md5_to_dns_key;
455         dst_t_func[KEY_HMAC_MD5]->from_dns_key = dst_buffer_to_hmac_md5;
456         dst_t_func[KEY_HMAC_MD5]->to_file_fmt = dst_hmac_md5_key_to_file_format;
457         dst_t_func[KEY_HMAC_MD5]->from_file_fmt = dst_hmac_md5_key_from_file_format;
458         return (1);
459 }
460
461 #else 
462 #define dst_hmac_md5_init       __dst_hmac_md5_init
463
464 int
465 dst_hmac_md5_init(){
466         return (0);
467 }
468 #endif