Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / contrib / bind-9.2.4rc7 / lib / bind / dst / dst_api.c
1 #ifndef LINT
2 static const char rcsid[] = "$Header: /proj/cvs/prod/bind9/lib/bind/dst/dst_api.c,v 1.4.2.6 2002/07/12 00:17:19 marka Exp $";
3 #endif
4
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  * This file contains the interface between the DST API and the crypto API.
23  * This is the only file that needs to be changed if the crypto system is
24  * changed.  Exported functions are:
25  * void dst_init()       Initialize the toolkit
26  * int  dst_check_algorithm()   Function to determines if alg is suppored.
27  * int  dst_compare_keys()      Function to compare two keys for equality.
28  * int  dst_sign_data()         Incremental signing routine.
29  * int  dst_verify_data()       Incremental verify routine.
30  * int  dst_generate_key()      Function to generate new KEY
31  * DST_KEY *dst_read_key()      Function to retrieve private/public KEY.
32  * void dst_write_key()         Function to write out a key.
33  * DST_KEY *dst_dnskey_to_key() Function to convert DNS KEY RR to a DST
34  *                              KEY structure.
35  * int dst_key_to_dnskey()      Function to return a public key in DNS 
36  *                              format binary
37  * DST_KEY *dst_buffer_to_key() Converst a data in buffer to KEY
38  * int *dst_key_to_buffer()     Writes out DST_KEY key matterial in buffer
39  * void dst_free_key()          Releases all memory referenced by key structure
40  */
41
42 #include "port_before.h"
43 #include <stdio.h>
44 #include <errno.h>
45 #include <fcntl.h>
46 #include <stdlib.h>
47 #include <unistd.h>
48 #include <string.h>
49 #include <memory.h>
50 #include <ctype.h>
51 #include <time.h>
52 #include <sys/param.h>
53 #include <sys/stat.h>
54 #include <sys/socket.h>
55 #include <netinet/in.h>
56 #include <arpa/nameser.h>
57 #include <resolv.h>
58
59 #include "dst_internal.h"
60 #include "port_after.h"
61
62 /* static variables */
63 static int done_init = 0;
64 dst_func *dst_t_func[DST_MAX_ALGS];
65 const char *key_file_fmt_str = "Private-key-format: v%s\nAlgorithm: %d (%s)\n";
66 const char *dst_path = "";
67
68 /* internal I/O functions */
69 static DST_KEY *dst_s_read_public_key(const char *in_name, 
70                                       const u_int16_t in_id, int in_alg);
71 static int dst_s_read_private_key_file(char *name, DST_KEY *pk_key,
72                                        u_int16_t in_id, int in_alg);
73 static int dst_s_write_public_key(const DST_KEY *key);
74 static int dst_s_write_private_key(const DST_KEY *key);
75
76 /* internal function to set up data structure */
77 static DST_KEY *dst_s_get_key_struct(const char *name, const int alg,
78                                      const int flags, const int protocol,
79                                      const int bits);
80
81 /*
82  *  dst_init
83  *      This function initializes the Digital Signature Toolkit.
84  *      Right now, it just checks the DSTKEYPATH environment variable.
85  *  Parameters
86  *      none
87  *  Returns
88  *      none
89  */
90 void
91 dst_init()
92 {
93         char *s;
94         int len;
95
96         if (done_init != 0)
97                 return;
98         done_init = 1;
99
100         s = getenv("DSTKEYPATH");
101         len = 0;
102         if (s) {
103                 struct stat statbuf;
104
105                 len = strlen(s);
106                 if (len > PATH_MAX) {
107                         EREPORT(("%s is longer than %d characters, ignoring\n",
108                                  s, PATH_MAX));
109                 } else if (stat(s, &statbuf) != 0 || !S_ISDIR(statbuf.st_mode)) {
110                         EREPORT(("%s is not a valid directory\n", s));
111                 } else {
112                         char *tmp;
113                         tmp = (char *) malloc(len + 2);
114                         memcpy(tmp, s, len + 1);
115                         if (tmp[strlen(tmp) - 1] != '/') {
116                                 tmp[strlen(tmp) + 1] = 0;
117                                 tmp[strlen(tmp)] = '/';
118                         }
119                         dst_path = tmp;
120                 }
121         }
122         memset(dst_t_func, 0, sizeof(dst_t_func));
123         /* first one is selected */
124         dst_hmac_md5_init();
125 }
126
127 /*
128  *  dst_check_algorithm
129  *      This function determines if the crypto system for the specified
130  *      algorithm is present.
131  *  Parameters
132  *      alg     1       KEY_RSA
133  *              3       KEY_DSA
134  *            157     KEY_HMAC_MD5
135  *                    future algorithms TBD and registered with IANA.
136  *  Returns
137  *      1 - The algorithm is available.
138  *      0 - The algorithm is not available.
139  */
140 int
141 dst_check_algorithm(const int alg)
142 {
143         return (dst_t_func[alg] != NULL);
144 }
145
146 /* 
147  * dst_s_get_key_struct 
148  *      This function allocates key structure and fills in some of the 
149  *      fields of the structure. 
150  * Parameters: 
151  *      name:     the name of the key 
152  *      alg:      the algorithm number 
153  *      flags:    the dns flags of the key
154  *      protocol: the dns protocol of the key
155  *      bits:     the size of the key
156  * Returns:
157  *       NULL if error
158  *       valid pointer otherwise
159  */
160 static DST_KEY *
161 dst_s_get_key_struct(const char *name, const int alg, const int flags,
162                      const int protocol, const int bits)
163 {
164         DST_KEY *new_key = NULL; 
165
166         if (dst_check_algorithm(alg)) /* make sure alg is available */
167                 new_key = (DST_KEY *) malloc(sizeof(*new_key));
168         if (new_key == NULL)
169                 return (NULL);
170
171         memset(new_key, 0, sizeof(*new_key));
172         new_key->dk_key_name = strdup(name);
173         new_key->dk_alg = alg;
174         new_key->dk_flags = flags;
175         new_key->dk_proto = protocol;
176         new_key->dk_KEY_struct = NULL;
177         new_key->dk_key_size = bits;
178         new_key->dk_func = dst_t_func[alg];
179         return (new_key);
180 }
181
182 /*
183  *  dst_compare_keys
184  *      Compares two keys for equality.
185  *  Parameters
186  *      key1, key2      Two keys to be compared.
187  *  Returns
188  *      0              The keys are equal.
189  *      non-zero        The keys are not equal.
190  */
191
192 int
193 dst_compare_keys(const DST_KEY *key1, const DST_KEY *key2)
194 {
195         if (key1 == key2)
196                 return (0);
197         if (key1 == NULL || key2 == NULL)
198                 return (4);
199         if (key1->dk_alg != key2->dk_alg)
200                 return (1);
201         if (key1->dk_key_size != key2->dk_key_size)
202                 return (2);
203         if (key1->dk_id != key2->dk_id)
204                 return (3);
205         return (key1->dk_func->compare(key1, key2));
206 }
207
208
209 /*
210  * dst_sign_data
211  *      An incremental signing function.  Data is signed in steps.
212  *      First the context must be initialized (SIG_MODE_INIT).
213  *      Then data is hashed (SIG_MODE_UPDATE).  Finally the signature
214  *      itself is created (SIG_MODE_FINAL).  This function can be called
215  *      once with INIT, UPDATE and FINAL modes all set, or it can be
216  *      called separately with a different mode set for each step.  The
217  *      UPDATE step can be repeated.
218  * Parameters
219  *      mode    A bit mask used to specify operation(s) to be performed.
220  *                SIG_MODE_INIT    1   Initialize digest
221  *                SIG_MODE_UPDATE        2   Add data to digest
222  *                SIG_MODE_FINAL          4   Generate signature
223  *                                            from signature
224  *                SIG_MODE_ALL (SIG_MODE_INIT,SIG_MODE_UPDATE,SIG_MODE_FINAL
225  *      data    Data to be signed.
226  *      len     The length in bytes of data to be signed.
227  *      in_key  Contains a private key to sign with.
228  *                KEY structures should be handled (created, converted,
229  *                compared, stored, freed) by the DST.
230  *      signature
231  *            The location to which the signature will be written.
232  *      sig_len Length of the signature field in bytes.
233  * Return
234  *       0      Successfull INIT or Update operation
235  *      >0      success FINAL (sign) operation
236  *      <0      failure
237  */
238
239 int
240 dst_sign_data(const int mode, DST_KEY *in_key, void **context, 
241               const u_char *data, const int len,
242               u_char *signature, const int sig_len)
243 {
244         DUMP(data, mode, len, "dst_sign_data()");
245
246         if (mode & SIG_MODE_FINAL &&
247             (in_key->dk_KEY_struct == NULL || signature == NULL))
248                 return (MISSING_KEY_OR_SIGNATURE);
249
250         if (in_key->dk_func && in_key->dk_func->sign)
251                 return (in_key->dk_func->sign(mode, in_key, context, data, len,
252                                               signature, sig_len));
253         return (UNKNOWN_KEYALG);
254 }
255
256
257 /*
258  *  dst_verify_data
259  *      An incremental verify function.  Data is verified in steps.
260  *      First the context must be initialized (SIG_MODE_INIT).
261  *      Then data is hashed (SIG_MODE_UPDATE).  Finally the signature
262  *      is verified (SIG_MODE_FINAL).  This function can be called
263  *      once with INIT, UPDATE and FINAL modes all set, or it can be
264  *      called separately with a different mode set for each step.  The
265  *      UPDATE step can be repeated.
266  *  Parameters
267  *      mode    Operations to perform this time.
268  *                    SIG_MODE_INIT       1   Initialize digest
269  *                    SIG_MODE_UPDATE     2   add data to digest
270  *                    SIG_MODE_FINAL      4   verify signature
271  *                    SIG_MODE_ALL
272  *                        (SIG_MODE_INIT,SIG_MODE_UPDATE,SIG_MODE_FINAL)
273  *      data    Data to pass through the hash function.
274  *      len      Length of the data in bytes.
275  *      in_key      Key for verification.
276  *      signature   Location of signature.
277  *      sig_len     Length of the signature in bytes.
278  *  Returns
279  *      0          Verify success
280  *      Non-Zero    Verify Failure
281  */
282
283 int
284 dst_verify_data(const int mode, DST_KEY *in_key, void **context, 
285                 const u_char *data, const int len,
286                 const u_char *signature, const int sig_len)
287 {
288         DUMP(data, mode, len, "dst_verify_data()");
289         if (mode & SIG_MODE_FINAL &&
290             (in_key->dk_KEY_struct == NULL || signature == NULL))
291                 return (MISSING_KEY_OR_SIGNATURE);
292
293         if (in_key->dk_func == NULL || in_key->dk_func->verify == NULL)
294                 return (UNSUPPORTED_KEYALG);
295         return (in_key->dk_func->verify(mode, in_key, context, data, len,
296                                         signature, sig_len));
297 }
298
299
300 /*
301  *  dst_read_private_key
302  *      Access a private key.  First the list of private keys that have
303  *      already been read in is searched, then the key accessed on disk.
304  *      If the private key can be found, it is returned.  If the key cannot
305  *      be found, a null pointer is returned.  The options specify required
306  *      key characteristics.  If the private key requested does not have
307  *      these characteristics, it will not be read.
308  *  Parameters
309  *      in_keyname  The private key name.
310  *      in_id       The id of the private key.
311  *      options     DST_FORCE_READ  Read from disk - don't use a previously
312  *                                    read key.
313  *                DST_CAN_SIGN    The key must be useable for signing.
314  *                DST_NO_AUTHEN   The key must be useable for authentication.
315  *                DST_STANDARD    Return any key 
316  *  Returns
317  *      NULL    If there is no key found in the current directory or
318  *                    this key has not been loaded before.
319  *      !NULL       Success - KEY structure returned.
320  */
321
322 DST_KEY *
323 dst_read_key(const char *in_keyname, const u_int16_t in_id, 
324              const int in_alg, const int type)
325 {
326         char keyname[PATH_MAX];
327         DST_KEY *dg_key = NULL, *pubkey = NULL;
328
329         if (!dst_check_algorithm(in_alg)) { /* make sure alg is available */
330                 EREPORT(("dst_read_private_key(): Algorithm %d not suppored\n",
331                          in_alg));
332                 return (NULL);
333         }
334         if ((type & (DST_PUBLIC | DST_PRIVATE)) == 0) 
335                 return (NULL);
336         if (in_keyname == NULL) {
337                 EREPORT(("dst_read_private_key(): Null key name passed in\n"));
338                 return (NULL);
339         } else
340                 strcpy(keyname, in_keyname);
341
342         /* before I read in the public key, check if it is allowed to sign */
343         if ((pubkey = dst_s_read_public_key(keyname, in_id, in_alg)) == NULL)
344                 return (NULL);
345
346         if (type == DST_PUBLIC) 
347                 return pubkey; 
348
349         if (!(dg_key = dst_s_get_key_struct(keyname, pubkey->dk_alg,
350                                          pubkey->dk_flags, pubkey->dk_proto,
351                                             0)))
352                 return (dg_key);
353         /* Fill in private key and some fields in the general key structure */
354         if (dst_s_read_private_key_file(keyname, dg_key, pubkey->dk_id,
355                                         pubkey->dk_alg) == 0)
356                 dg_key = dst_free_key(dg_key);
357
358         pubkey = dst_free_key(pubkey);
359         return (dg_key);
360 }
361
362 int 
363 dst_write_key(const DST_KEY *key, const int type)
364 {
365         int pub = 0, priv = 0;
366
367         if (key == NULL) 
368                 return (0);
369         if (!dst_check_algorithm(key->dk_alg)) { /* make sure alg is available */
370                 EREPORT(("dst_write_key(): Algorithm %d not suppored\n", 
371                          key->dk_alg));
372                 return (UNSUPPORTED_KEYALG);
373         }
374         if ((type & (DST_PRIVATE|DST_PUBLIC)) == 0)
375                 return (0);
376
377         if (type & DST_PUBLIC) 
378                 if ((pub = dst_s_write_public_key(key)) < 0)
379                         return (pub);
380         if (type & DST_PRIVATE)
381                 if ((priv = dst_s_write_private_key(key)) < 0)
382                         return (priv);
383         return (priv+pub);
384 }
385
386 /*
387  *  dst_write_private_key
388  *      Write a private key to disk.  The filename will be of the form:
389  *      K<key->dk_name>+<key->dk_alg>+<key->dk_id>.<private key suffix>.
390  *      If there is already a file with this name, an error is returned.
391  *
392  *  Parameters
393  *      key     A DST managed key structure that contains
394  *            all information needed about a key.
395  *  Return
396  *      >= 0    Correct behavior.  Returns length of encoded key value
397  *                written to disk.
398  *      <  0    error.
399  */
400
401 static int
402 dst_s_write_private_key(const DST_KEY *key)
403 {
404         u_char encoded_block[RAW_KEY_SIZE];
405         char file[PATH_MAX];
406         int len;
407         FILE *fp;
408
409         /* First encode the key into the portable key format */
410         if (key == NULL)
411                 return (-1);
412         if (key->dk_KEY_struct == NULL)
413                 return (0);     /* null key has no private key */
414
415         if (key->dk_func == NULL || key->dk_func->to_file_fmt == NULL) {
416                 EREPORT(("dst_write_private_key(): Unsupported operation %d\n",
417                          key->dk_alg));
418                 return (-5);
419         } else if ((len = key->dk_func->to_file_fmt(key, (char *)encoded_block,
420                                              sizeof(encoded_block))) <= 0) {
421                 EREPORT(("dst_write_private_key(): Failed encoding private RSA bsafe key %d\n", len));
422                 return (-8);
423         }
424         /* Now I can create the file I want to use */
425         dst_s_build_filename(file, key->dk_key_name, key->dk_id, key->dk_alg,
426                              PRIVATE_KEY, PATH_MAX);
427
428         /* Do not overwrite an existing file */
429         if ((fp = dst_s_fopen(file, "w", 0600)) != NULL) {
430                 int nn;
431                 if ((nn = fwrite(encoded_block, 1, len, fp)) != len) {
432                         EREPORT(("dst_write_private_key(): Write failure on %s %d != %d errno=%d\n",
433                                  file, len, nn, errno));
434                         return (-5);
435                 }
436                 fclose(fp);
437         } else {
438                 EREPORT(("dst_write_private_key(): Can not create file %s\n"
439                          ,file));
440                 return (-6);
441         }
442         memset(encoded_block, 0, len);
443         return (len);
444 }
445
446 /*
447 *
448  *  dst_read_public_key
449  *      Read a public key from disk and store in a DST key structure.
450  *  Parameters
451  *      in_name  K<in_name><in_id>.<public key suffix> is the
452  *                    filename of the key file to be read.
453  *  Returns
454  *      NULL        If the key does not exist or no name is supplied.
455  *      NON-NULL        Initialized key structure if the key exists.
456  */
457
458 static DST_KEY *
459 dst_s_read_public_key(const char *in_name, const u_int16_t in_id, int in_alg)
460 {
461         int flags, proto, alg, len, dlen;
462         int c;
463         char name[PATH_MAX], enckey[RAW_KEY_SIZE], *notspace;
464         u_char deckey[RAW_KEY_SIZE];
465         FILE *fp;
466
467         if (in_name == NULL) {
468                 EREPORT(("dst_read_public_key(): No key name given\n"));
469                 return (NULL);
470         }
471         if (dst_s_build_filename(name, in_name, in_id, in_alg, PUBLIC_KEY,
472                                  PATH_MAX) == -1) {
473                 EREPORT(("dst_read_public_key(): Cannot make filename from %s, %d, and %s\n",
474                          in_name, in_id, PUBLIC_KEY));
475                 return (NULL);
476         }
477         /*
478          * Open the file and read it's formatted contents up to key
479          * File format:
480          *    domain.name [ttl] [IN] KEY  <flags> <protocol> <algorithm> <key>
481          * flags, proto, alg stored as decimal (or hex numbers FIXME).
482          * (FIXME: handle parentheses for line continuation.)
483          */
484         if ((fp = dst_s_fopen(name, "r", 0)) == NULL) {
485                 EREPORT(("dst_read_public_key(): Public Key not found %s\n",
486                          name));
487                 return (NULL);
488         }
489         /* Skip domain name, which ends at first blank */
490         while ((c = getc(fp)) != EOF)
491                 if (isspace(c))
492                         break;
493         /* Skip blank to get to next field */
494         while ((c = getc(fp)) != EOF)
495                 if (!isspace(c))
496                         break;
497
498         /* Skip optional TTL -- if initial digit, skip whole word. */
499         if (isdigit(c)) {
500                 while ((c = getc(fp)) != EOF)
501                         if (isspace(c))
502                                 break;
503                 while ((c = getc(fp)) != EOF)
504                         if (!isspace(c))
505                                 break;
506         }
507         /* Skip optional "IN" */
508         if (c == 'I' || c == 'i') {
509                 while ((c = getc(fp)) != EOF)
510                         if (isspace(c))
511                                 break;
512                 while ((c = getc(fp)) != EOF)
513                         if (!isspace(c))
514                                 break;
515         }
516         /* Locate and skip "KEY" */
517         if (c != 'K' && c != 'k') {
518                 EREPORT(("\"KEY\" doesn't appear in file: %s", name));
519                 return NULL;
520         }
521         while ((c = getc(fp)) != EOF)
522                 if (isspace(c))
523                         break;
524         while ((c = getc(fp)) != EOF)
525                 if (!isspace(c))
526                         break;
527         ungetc(c, fp);          /* return the charcter to the input field */
528         /* Handle hex!! FIXME.  */
529
530         if (fscanf(fp, "%d %d %d", &flags, &proto, &alg) != 3) {
531                 EREPORT(("dst_read_public_key(): Can not read flag/proto/alg field from %s\n"
532                          ,name));
533                 return (NULL);
534         }
535         /* read in the key string */
536         fgets(enckey, sizeof(enckey), fp);
537
538         /* If we aren't at end-of-file, something is wrong.  */
539         while ((c = getc(fp)) != EOF)
540                 if (!isspace(c))
541                         break;
542         if (!feof(fp)) {
543                 EREPORT(("Key too long in file: %s", name));
544                 return NULL;
545         }
546         fclose(fp);
547
548         if ((len = strlen(enckey)) <= 0)
549                 return (NULL);
550
551         /* discard \n */
552         enckey[--len] = '\0';
553
554         /* remove leading spaces */
555         for (notspace = (char *) enckey; isspace((*notspace)&0xff); len--)
556                 notspace++;
557
558         dlen = b64_pton(notspace, deckey, sizeof(deckey));
559         if (dlen < 0) {
560                 EREPORT(("dst_read_public_key: bad return from b64_pton = %d",
561                          dlen));
562                 return (NULL);
563         }
564         /* store key and info in a key structure that is returned */
565 /*      return dst_store_public_key(in_name, alg, proto, 666, flags, deckey,
566                                     dlen);*/
567         return dst_buffer_to_key(in_name, alg, flags, proto, deckey, dlen);
568 }
569
570
571 /*
572  *  dst_write_public_key
573  *      Write a key to disk in DNS format.
574  *  Parameters
575  *      key     Pointer to a DST key structure.
576  *  Returns
577  *      0       Failure
578  *      1       Success
579  */
580
581 static int
582 dst_s_write_public_key(const DST_KEY *key)
583 {
584         FILE *fp;
585         char filename[PATH_MAX];
586         u_char out_key[RAW_KEY_SIZE];
587         char enc_key[RAW_KEY_SIZE];
588         int len = 0;
589         int mode;
590
591         memset(out_key, 0, sizeof(out_key));
592         if (key == NULL) {
593                 EREPORT(("dst_write_public_key(): No key specified \n"));
594                 return (0);
595         } else if ((len = dst_key_to_dnskey(key, out_key, sizeof(out_key)))< 0)
596                 return (0);
597
598         /* Make the filename */
599         if (dst_s_build_filename(filename, key->dk_key_name, key->dk_id,
600                                  key->dk_alg, PUBLIC_KEY, PATH_MAX) == -1) {
601                 EREPORT(("dst_write_public_key(): Cannot make filename from %s, %d, and %s\n",
602                          key->dk_key_name, key->dk_id, PUBLIC_KEY));
603                 return (0);
604         }
605         /* XXX in general this should be a check for symmetric keys */
606         mode = (key->dk_alg == KEY_HMAC_MD5) ? 0600 : 0644;
607         /* create public key file */
608         if ((fp = dst_s_fopen(filename, "w+", mode)) == NULL) {
609                 EREPORT(("DST_write_public_key: open of file:%s failed (errno=%d)\n",
610                          filename, errno));
611                 return (0);
612         }
613         /*write out key first base64 the key data */
614         if (key->dk_flags & DST_EXTEND_FLAG)
615                 b64_ntop(&out_key[6], len - 6, enc_key, sizeof(enc_key));
616         else
617                 b64_ntop(&out_key[4], len - 4, enc_key, sizeof(enc_key));
618         fprintf(fp, "%s IN KEY %d %d %d %s\n",
619                 key->dk_key_name,
620                 key->dk_flags, key->dk_proto, key->dk_alg, enc_key);
621         fclose(fp);
622         return (1);
623 }
624
625
626 /*
627  *  dst_dnskey_to_public_key
628  *      This function converts the contents of a DNS KEY RR into a DST
629  *      key structure.
630  *  Paramters
631  *      len      Length of the RDATA of the KEY RR RDATA
632  *      rdata    A pointer to the the KEY RR RDATA.
633  *      in_name     Key name to be stored in key structure.
634  *  Returns
635  *      NULL        Failure
636  *      NON-NULL        Success.  Pointer to key structure.
637  *                      Caller's responsibility to free() it.
638  */
639
640 DST_KEY *
641 dst_dnskey_to_key(const char *in_name, const u_char *rdata, const int len)
642 {
643         DST_KEY *key_st;
644         int alg ;
645         int start = DST_KEY_START;
646
647         if (rdata == NULL || len <= DST_KEY_ALG) /* no data */
648                 return (NULL);
649         alg = (u_int8_t) rdata[DST_KEY_ALG];
650         if (!dst_check_algorithm(alg)) { /* make sure alg is available */
651                 EREPORT(("dst_dnskey_to_key(): Algorithm %d not suppored\n",
652                          alg));
653                 return (NULL);
654         }
655         if ((key_st = dst_s_get_key_struct(in_name, alg, 0, 0, 0)) == NULL)
656                 return (NULL);
657
658         if (in_name == NULL)
659                 return (NULL);
660         key_st->dk_id = dst_s_dns_key_id(rdata, len);
661         key_st->dk_flags = dst_s_get_int16(rdata);
662         key_st->dk_proto = (u_int16_t) rdata[DST_KEY_PROT];
663         if (key_st->dk_flags & DST_EXTEND_FLAG) {
664                 u_int32_t ext_flags;
665                 ext_flags = (u_int32_t) dst_s_get_int16(&rdata[DST_EXT_FLAG]);
666                 key_st->dk_flags = key_st->dk_flags | (ext_flags << 16);
667                 start += 2;
668         }
669         /*
670          * now point to the begining of the data representing the encoding
671          * of the key
672          */
673         if (key_st->dk_func && key_st->dk_func->from_dns_key) {
674                 if (key_st->dk_func->from_dns_key(key_st, &rdata[start],
675                                                   len - start) > 0)
676                         return (key_st);
677         } else
678                 EREPORT(("dst_dnskey_to_public_key(): unsuppored alg %d\n",
679                          alg));
680
681         SAFE_FREE(key_st);
682         return (key_st);
683 }
684
685
686 /*
687  *  dst_public_key_to_dnskey
688  *      Function to encode a public key into DNS KEY wire format 
689  *  Parameters
690  *      key          Key structure to encode.
691  *      out_storage     Location to write the encoded key to.
692  *      out_len  Size of the output array.
693  *  Returns
694  *      <0      Failure
695  *      >=0     Number of bytes written to out_storage
696  */
697
698 int
699 dst_key_to_dnskey(const DST_KEY *key, u_char *out_storage,
700                          const int out_len)
701 {
702         u_int16_t val;
703         int loc = 0;
704         int enc_len = 0;
705         if (key == NULL)
706                 return (-1);
707
708         if (!dst_check_algorithm(key->dk_alg)) { /* make sure alg is available */
709                 EREPORT(("dst_key_to_dnskey(): Algorithm %d not suppored\n",
710                          key->dk_alg));
711                 return (UNSUPPORTED_KEYALG);
712         }
713         memset(out_storage, 0, out_len);
714         val = (u_int16_t)(key->dk_flags & 0xffff);
715         dst_s_put_int16(out_storage, val);
716         loc += 2;
717
718         out_storage[loc++] = (u_char) key->dk_proto;
719         out_storage[loc++] = (u_char) key->dk_alg;
720
721         if (key->dk_flags > 0xffff) {   /* Extended flags */
722                 val = (u_int16_t)((key->dk_flags >> 16) & 0xffff);
723                 dst_s_put_int16(&out_storage[loc], val);
724                 loc += 2;
725         }
726         if (key->dk_KEY_struct == NULL)
727                 return (loc);
728         if (key->dk_func && key->dk_func->to_dns_key) {
729                 enc_len = key->dk_func->to_dns_key(key,
730                                                  (u_char *) &out_storage[loc],
731                                                    out_len - loc);
732                 if (enc_len > 0)
733                         return (enc_len + loc);
734                 else
735                         return (-1);
736         } else
737                 EREPORT(("dst_key_to_dnskey(): Unsupported ALG %d\n",
738                          key->dk_alg));
739         return (-1);
740 }
741
742
743 /*
744  *  dst_buffer_to_key
745  *      Function to encode a string of raw data into a DST key
746  *  Parameters
747  *      alg             The algorithm (HMAC only)
748  *      key             A pointer to the data
749  *      keylen          The length of the data
750  *  Returns
751  *      NULL        an error occurred
752  *      NON-NULL        the DST key
753  */
754 DST_KEY *
755 dst_buffer_to_key(const char *key_name,         /* name of the key */
756                   const int alg,                /* algorithm */
757                   const int flags,              /* dns flags */
758                   const int protocol,           /* dns protocol */
759                   const u_char *key_buf,        /* key in dns wire fmt */
760                   const int key_len)            /* size of key */
761 {
762         
763         DST_KEY *dkey = NULL; 
764         int dnslen;
765         u_char dns[2048];
766
767         if (!dst_check_algorithm(alg)) { /* make sure alg is available */
768                 EREPORT(("dst_buffer_to_key(): Algorithm %d not suppored\n", alg));
769                 return (NULL);
770         }
771
772         dkey = dst_s_get_key_struct(key_name, alg, flags, 
773                                              protocol, -1);
774
775         if (dkey == NULL)
776                 return (NULL);
777         if (dkey->dk_func == NULL || dkey->dk_func->from_dns_key == NULL)
778                 return NULL;
779
780         if (dkey->dk_func->from_dns_key(dkey, key_buf, key_len) < 0) {
781                 EREPORT(("dst_buffer_to_key(): dst_buffer_to_hmac failed\n"));
782                 return (dst_free_key(dkey));
783         }
784
785         dnslen = dst_key_to_dnskey(dkey, dns, sizeof(dns));
786         dkey->dk_id = dst_s_dns_key_id(dns, dnslen);
787         return (dkey);
788 }
789
790 int 
791 dst_key_to_buffer(DST_KEY *key, u_char *out_buff, int buf_len)
792 {
793         int len;
794   /* this function will extrac the secret of HMAC into a buffer */
795         if (key == NULL) 
796                 return (0);
797         if (key->dk_func != NULL && key->dk_func->to_dns_key != NULL) {
798                 len = key->dk_func->to_dns_key(key, out_buff, buf_len);
799                 if (len < 0)
800                         return (0);
801                 return (len);
802         }
803         return (0);
804 }
805
806
807 /*
808  * dst_s_read_private_key_file
809  *     Function reads in private key from a file.
810  *     Fills out the KEY structure.
811  * Parameters
812  *     name    Name of the key to be read.
813  *     pk_key  Structure that the key is returned in.
814  *     in_id   Key identifier (tag)
815  * Return
816  *     1 if everthing works
817  *     0 if there is any problem
818  */
819
820 static int
821 dst_s_read_private_key_file(char *name, DST_KEY *pk_key, u_int16_t in_id,
822                             int in_alg)
823 {
824         int cnt, alg, len, major, minor, file_major, file_minor;
825         int ret, id;
826         char filename[PATH_MAX];
827         u_char in_buff[RAW_KEY_SIZE], *p;
828         FILE *fp;
829         int dnslen;
830         u_char dns[2048];
831
832         if (name == NULL || pk_key == NULL) {
833                 EREPORT(("dst_read_private_key_file(): No key name given\n"));
834                 return (0);
835         }
836         /* Make the filename */
837         if (dst_s_build_filename(filename, name, in_id, in_alg, PRIVATE_KEY,
838                                  PATH_MAX) == -1) {
839                 EREPORT(("dst_read_private_key(): Cannot make filename from %s, %d, and %s\n",
840                          name, in_id, PRIVATE_KEY));
841                 return (0);
842         }
843         /* first check if we can find the key file */
844         if ((fp = dst_s_fopen(filename, "r", 0)) == NULL) {
845                 EREPORT(("dst_s_read_private_key_file: Could not open file %s in directory %s\n",
846                          filename, dst_path[0] ? dst_path :
847                          (char *) getcwd(NULL, PATH_MAX - 1)));
848                 return (0);
849         }
850         /* now read the header info from the file */
851         if ((cnt = fread(in_buff, 1, sizeof(in_buff), fp)) < 5) {
852                 fclose(fp);
853                 EREPORT(("dst_s_read_private_key_file: error reading file %s (empty file)\n",
854                          filename));
855                 return (0);
856         }
857         /* decrypt key */
858         fclose(fp);
859         if (memcmp(in_buff, "Private-key-format: v", 20) != 0)
860                 goto fail;
861         len = cnt;
862         p = in_buff;
863
864         if (!dst_s_verify_str((const char **) &p, "Private-key-format: v")) {
865                 EREPORT(("dst_s_read_private_key_file(): Not a Key file/Decrypt failed %s\n", name));
866                 goto fail;
867         }
868         /* read in file format */
869         sscanf((char *)p, "%d.%d", &file_major, &file_minor);
870         sscanf(KEY_FILE_FORMAT, "%d.%d", &major, &minor);
871         if (file_major < 1) {
872                 EREPORT(("dst_s_read_private_key_file(): Unknown keyfile %d.%d version for %s\n",
873                          file_major, file_minor, name));
874                 goto fail;
875         } else if (file_major > major || file_minor > minor)
876                 EREPORT((
877                                 "dst_s_read_private_key_file(): Keyfile %s version higher than mine %d.%d MAY FAIL\n",
878                                 name, file_major, file_minor));
879
880         while (*p++ != '\n') ;  /* skip to end of line */
881
882         if (!dst_s_verify_str((const char **) &p, "Algorithm: "))
883                 goto fail;
884
885         if (sscanf((char *)p, "%d", &alg) != 1)
886                 goto fail;
887         while (*p++ != '\n') ;  /* skip to end of line */
888
889         if (pk_key->dk_key_name && !strcmp(pk_key->dk_key_name, name))
890                 SAFE_FREE2(pk_key->dk_key_name, strlen(pk_key->dk_key_name));
891         pk_key->dk_key_name = (char *) strdup(name);
892
893         /* allocate and fill in key structure */
894         if (pk_key->dk_func == NULL || pk_key->dk_func->from_file_fmt == NULL)
895                 goto fail;
896
897         ret = pk_key->dk_func->from_file_fmt(pk_key, (char *)p, &in_buff[len] - p);
898         if (ret < 0)
899                 goto fail;
900
901         dnslen = dst_key_to_dnskey(pk_key, dns, sizeof(dns));
902         id = dst_s_dns_key_id(dns, dnslen);
903
904         /* Make sure the actual key tag matches the input tag used in the filename
905          */
906         if (id != in_id) {
907                 EREPORT(("dst_s_read_private_key_file(): actual tag of key read %d != input tag used to build filename %d.\n", id, in_id));
908                 goto fail;
909         }
910         pk_key->dk_id = (u_int16_t) id;
911         pk_key->dk_alg = alg;
912         memset(in_buff, 0, cnt);
913         return (1);
914
915  fail:
916         memset(in_buff, 0, cnt);
917         return (0);
918 }
919
920
921 /*
922  *  dst_generate_key
923  *      Generate and store a public/private keypair.
924  *      Keys will be stored in formatted files.
925  *  Parameters
926  *      name    Name of the new key.  Used to create key files
927  *                K<name>+<alg>+<id>.public and K<name>+<alg>+<id>.private.
928  *      bits    Size of the new key in bits.
929  *      exp     What exponent to use:
930  *                0        use exponent 3
931  *                non-zero    use Fermant4
932  *      flags   The default value of the DNS Key flags.
933  *                The DNS Key RR Flag field is defined in RFC 2065,
934  *                section 3.3.  The field has 16 bits.
935  *      protocol
936  *            Default value of the DNS Key protocol field.
937  *                The DNS Key protocol field is defined in RFC 2065,
938  *                section 3.4.  The field has 8 bits.
939  *      alg     What algorithm to use.  Currently defined:
940  *                KEY_RSA       1
941  *                KEY_DSA       3
942  *                KEY_HMAC    157
943  *      out_id The key tag is returned.
944  *
945  *  Return
946  *      NULL            Failure
947  *      non-NULL        the generated key pair
948  *                      Caller frees the result, and its dk_name pointer.
949  */
950 DST_KEY *
951 dst_generate_key(const char *name, const int bits, const int exp,
952                  const int flags, const int protocol, const int alg)
953 {
954         DST_KEY *new_key = NULL;
955         int res;
956         int dnslen;
957         u_char dns[2048];
958
959         if (name == NULL)
960                 return (NULL);
961
962         if (!dst_check_algorithm(alg)) { /* make sure alg is available */
963                 EREPORT(("dst_generate_key(): Algorithm %d not suppored\n", alg));
964                 return (NULL);
965         }
966
967         new_key = dst_s_get_key_struct(name, alg, flags, protocol, bits);
968         if (new_key == NULL)
969                 return (NULL);
970         if (bits == 0) /* null key we are done */
971                 return (new_key);
972         if (new_key->dk_func == NULL || new_key->dk_func->generate == NULL) {
973                 EREPORT(("dst_generate_key_pair():Unsupported algorithm %d\n",
974                          alg));
975                 return (dst_free_key(new_key));
976         }
977         if ((res = new_key->dk_func->generate(new_key, exp)) <= 0) {
978                 EREPORT(("dst_generate_key_pair(): Key generation failure %s %d %d %d\n",
979                          new_key->dk_key_name, new_key->dk_alg,
980                          new_key->dk_key_size, exp));
981                 return (dst_free_key(new_key));
982         }
983
984         dnslen = dst_key_to_dnskey(new_key, dns, sizeof(dns));
985         if (dnslen != UNSUPPORTED_KEYALG)
986                 new_key->dk_id = dst_s_dns_key_id(dns, dnslen);
987         else
988                 new_key->dk_id = 0;
989
990         return (new_key);
991 }
992
993
994 /*
995  *  dst_free_key
996  *      Release all data structures pointed to by a key structure.
997  *  Parameters
998  *      f_key   Key structure to be freed.
999  */
1000
1001 DST_KEY *
1002 dst_free_key(DST_KEY *f_key)
1003 {
1004
1005         if (f_key == NULL)
1006                 return (f_key);
1007         if (f_key->dk_func && f_key->dk_func->destroy)
1008                 f_key->dk_KEY_struct =
1009                         f_key->dk_func->destroy(f_key->dk_KEY_struct);
1010         else {
1011                 EREPORT(("dst_free_key(): Unknown key alg %d\n",
1012                          f_key->dk_alg));
1013                 free(f_key->dk_KEY_struct);     /* SHOULD NOT happen */
1014         }
1015         if (f_key->dk_KEY_struct) {
1016                 free(f_key->dk_KEY_struct);
1017                 f_key->dk_KEY_struct = NULL;
1018         }
1019         if (f_key->dk_key_name)
1020                 SAFE_FREE(f_key->dk_key_name);
1021         SAFE_FREE(f_key);
1022         return (NULL);
1023 }
1024
1025 /*
1026  * dst_sig_size
1027  *      Return the maximim size of signature from the key specified in bytes
1028  * Parameters
1029  *      key 
1030  * Returns
1031  *     bytes
1032  */
1033 int
1034 dst_sig_size(DST_KEY *key) {
1035         switch (key->dk_alg) {
1036             case KEY_HMAC_MD5:
1037                 return (16);
1038             case KEY_HMAC_SHA1:
1039                 return (20);
1040             case KEY_RSA:
1041                 return (key->dk_key_size + 7) / 8;
1042             case KEY_DSA:
1043                 return (40);
1044             default:
1045                 EREPORT(("dst_sig_size(): Unknown key alg %d\n", key->dk_alg));
1046                 return -1;
1047         }
1048 }