Merge from vendor branch TEXINFO:
[dragonfly.git] / contrib / bind-9.2.4rc7 / bin / dnssec / dnssec-signkey.c
1 /*
2  * Portions Copyright (C) 2004  Internet Systems Consortium, Inc. ("ISC")
3  * Portions Copyright (C) 2000, 2001, 2003  Internet Software Consortium.
4  * Portions Copyright (C) 1995-2000 by Network Associates, Inc.
5  *
6  * Permission to use, copy, modify, and distribute this software for any
7  * purpose with or without fee is hereby granted, provided that the above
8  * copyright notice and this permission notice appear in all copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NETWORK ASSOCIATES DISCLAIMS
11  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12  * WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE
13  * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
16  * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18
19 /* $Id: dnssec-signkey.c,v 1.50.2.4 2004/03/09 06:09:15 marka Exp $ */
20
21 #include <config.h>
22
23 #include <stdlib.h>
24
25 #include <isc/string.h>
26 #include <isc/commandline.h>
27 #include <isc/entropy.h>
28 #include <isc/mem.h>
29 #include <isc/util.h>
30
31 #include <dns/db.h>
32 #include <dns/dbiterator.h>
33 #include <dns/dnssec.h>
34 #include <dns/fixedname.h>
35 #include <dns/log.h>
36 #include <dns/rdata.h>
37 #include <dns/rdataclass.h>
38 #include <dns/rdatalist.h>
39 #include <dns/rdataset.h>
40 #include <dns/rdatasetiter.h>
41 #include <dns/rdatastruct.h>
42 #include <dns/result.h>
43 #include <dns/secalg.h>
44
45 #include <dst/dst.h>
46
47 #include "dnssectool.h"
48
49 const char *program = "dnssec-signkey";
50 int verbose;
51
52 #define BUFSIZE 2048
53
54 typedef struct keynode keynode_t;
55 struct keynode {
56         dst_key_t *key;
57         isc_boolean_t verified;
58         ISC_LINK(keynode_t) link;
59 };
60 typedef ISC_LIST(keynode_t) keylist_t;
61
62 static isc_stdtime_t starttime = 0, endtime = 0, now;
63
64 static isc_mem_t *mctx = NULL;
65 static isc_entropy_t *ectx = NULL;
66 static keylist_t keylist;
67
68 static void
69 usage(void) {
70         fprintf(stderr, "Usage:\n");
71         fprintf(stderr, "\t%s [options] keyset keys\n", program);
72
73         fprintf(stderr, "\n");
74
75         fprintf(stderr, "Options: (default value in parenthesis) \n");
76         fprintf(stderr, "\t-a\n");
77         fprintf(stderr, "\t\tverify generated signatures\n");
78         fprintf(stderr, "\t-c class (IN)\n");
79         fprintf(stderr, "\t-s YYYYMMDDHHMMSS|+offset:\n");
80         fprintf(stderr, "\t\tSIG start time - absolute|offset (from keyset)\n");
81         fprintf(stderr, "\t-e YYYYMMDDHHMMSS|+offset|\"now\"+offset]:\n");
82         fprintf(stderr, "\t\tSIG end time  - absolute|from start|from now "
83                 "(from keyset)\n");
84         fprintf(stderr, "\t-v level:\n");
85         fprintf(stderr, "\t\tverbose level (0)\n");
86         fprintf(stderr, "\t-p\n");
87         fprintf(stderr, "\t\tuse pseudorandom data (faster but less secure)\n");
88         fprintf(stderr, "\t-r randomdev:\n");
89         fprintf(stderr, "\t\ta file containing random data\n");
90
91         fprintf(stderr, "\n");
92
93         fprintf(stderr, "keyset:\n");
94         fprintf(stderr, "\tfile with keyset to be signed (keyset-<name>)\n");
95         fprintf(stderr, "keys:\n");
96         fprintf(stderr, "\tkeyfile (Kname+alg+tag)\n");
97
98         fprintf(stderr, "\n");
99         fprintf(stderr, "Output:\n");
100         fprintf(stderr, "\tsigned keyset (signedkey-<name>)\n");
101         exit(0);
102 }
103
104 static void
105 loadkeys(dns_name_t *name, dns_rdataset_t *rdataset) {
106         dst_key_t *key;
107         dns_rdata_t rdata = DNS_RDATA_INIT;
108         keynode_t *keynode;
109         isc_result_t result;
110
111         ISC_LIST_INIT(keylist);
112         result = dns_rdataset_first(rdataset);
113         check_result(result, "dns_rdataset_first");
114         for (; result == ISC_R_SUCCESS; result = dns_rdataset_next(rdataset)) {
115                 dns_rdata_reset(&rdata);
116                 dns_rdataset_current(rdataset, &rdata);
117                 key = NULL;
118                 result = dns_dnssec_keyfromrdata(name, &rdata, mctx, &key);
119                 if (result != ISC_R_SUCCESS)
120                         continue;
121                 if (!dst_key_iszonekey(key))
122                         continue;
123                 keynode = isc_mem_get(mctx, sizeof (keynode_t));
124                 if (keynode == NULL)
125                         fatal("out of memory");
126                 keynode->key = key;
127                 keynode->verified = ISC_FALSE;
128                 ISC_LIST_INITANDAPPEND(keylist, keynode, link);
129         }
130         if (result != ISC_R_NOMORE)
131                 fatal("failure traversing key list");
132 }
133
134 static dst_key_t *
135 findkey(dns_rdata_sig_t *sig) {
136         keynode_t *keynode;
137         for (keynode = ISC_LIST_HEAD(keylist);
138              keynode != NULL;
139              keynode = ISC_LIST_NEXT(keynode, link))
140         {
141                 if (dst_key_id(keynode->key) == sig->keyid &&
142                     dst_key_alg(keynode->key) == sig->algorithm) {
143                         keynode->verified = ISC_TRUE;
144                         return (keynode->key);
145                 }
146         }
147         fatal("signature generated by non-zone or missing key");
148         return (NULL);
149 }
150
151 int
152 main(int argc, char *argv[]) {
153         int i, ch;
154         char *startstr = NULL, *endstr = NULL, *classname = NULL;
155         char tdomain[1025];
156         dns_fixedname_t fdomain;
157         dns_name_t *domain;
158         char *output = NULL;
159         char *endp;
160         unsigned char *data;
161         char *randomfile = NULL;
162         dns_db_t *db;
163         dns_dbnode_t *node;
164         dns_dbversion_t *version;
165         dns_dbiterator_t *dbiter;
166         dns_rdatasetiter_t *rdsiter;
167         dst_key_t *key = NULL;
168         dns_rdata_t *rdata;
169         dns_rdata_t sigrdata = DNS_RDATA_INIT;
170         dns_rdatalist_t sigrdatalist;
171         dns_rdataset_t rdataset, sigrdataset, newsigrdataset;
172         dns_rdata_sig_t sig;
173         isc_result_t result;
174         isc_buffer_t b;
175         isc_textregion_t tr;
176         isc_log_t *log = NULL;
177         keynode_t *keynode;
178         isc_boolean_t pseudorandom = ISC_FALSE;
179         unsigned int eflags;
180         dns_rdataclass_t rdclass;
181         static isc_boolean_t tryverify = ISC_FALSE;
182
183         result = isc_mem_create(0, 0, &mctx);
184         check_result(result, "isc_mem_create()");
185
186         dns_result_register();
187
188         while ((ch = isc_commandline_parse(argc, argv, "ac:s:e:pr:v:h")) != -1)
189         {
190                 switch (ch) {
191                 case 'a':
192                         tryverify = ISC_TRUE;
193                         break;
194                 case 'c':
195                         classname = isc_commandline_argument;
196                         break;
197
198                 case 's':
199                         startstr = isc_commandline_argument;
200                         break;
201                                                 
202                 case 'e':
203                         endstr = isc_commandline_argument;
204                         break;
205
206                 case 'p':
207                         pseudorandom = ISC_TRUE;
208                         break;
209
210                 case 'r':
211                         randomfile = isc_commandline_argument;
212                         break;
213
214                 case 'v':
215                         endp = NULL;
216                         verbose = strtol(isc_commandline_argument, &endp, 0);
217                         if (*endp != '\0')
218                                 fatal("verbose level must be numeric");
219                         break;
220
221                 case 'h':
222                 default:
223                         usage();
224
225                 }
226         }
227
228         argc -= isc_commandline_index;
229         argv += isc_commandline_index;
230
231         if (argc < 2)
232                 usage();
233
234         if (classname != NULL) {
235                 tr.base = classname;
236                 tr.length = strlen(classname);
237                 result = dns_rdataclass_fromtext(&rdclass, &tr);
238                 if (result != ISC_R_SUCCESS)
239                         fatal("unknown class %s",classname);
240         } else
241                 rdclass = dns_rdataclass_in;
242
243         setup_entropy(mctx, randomfile, &ectx);
244         eflags = ISC_ENTROPY_BLOCKING;
245         if (!pseudorandom)
246                 eflags |= ISC_ENTROPY_GOODONLY;
247         result = dst_lib_init(mctx, ectx, eflags);
248         if (result != ISC_R_SUCCESS)
249                 fatal("could not initialize dst: %s", 
250                       isc_result_totext(result));
251
252         isc_stdtime_get(&now);
253
254         if ((startstr == NULL || endstr == NULL) &&
255             !(startstr == NULL && endstr == NULL))
256                 fatal("if -s or -e is specified, both must be");
257
258         setup_logging(verbose, mctx, &log);
259
260         if (strlen(argv[0]) < 8U || strncmp(argv[0], "keyset-", 7) != 0)
261                 fatal("keyset file '%s' must start with keyset-", argv[0]);
262
263         db = NULL;
264         result = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone,
265                                rdclass, 0, NULL, &db);
266         check_result(result, "dns_db_create()");
267
268         result = dns_db_load(db, argv[0]);
269         if (result != ISC_R_SUCCESS && result != DNS_R_SEENINCLUDE)
270                 fatal("failed to load database from '%s': %s", argv[0],
271                       isc_result_totext(result));
272
273         dns_fixedname_init(&fdomain);
274         domain = dns_fixedname_name(&fdomain);
275
276         dbiter = NULL;
277         result = dns_db_createiterator(db, ISC_FALSE, &dbiter);
278         check_result(result, "dns_db_createiterator()");
279
280         result = dns_dbiterator_first(dbiter);
281         check_result(result, "dns_dbiterator_first()");
282         while (result == ISC_R_SUCCESS) {
283                 node = NULL;
284                 dns_dbiterator_current(dbiter, &node, domain);
285                 rdsiter = NULL;
286                 result = dns_db_allrdatasets(db, node, NULL, 0, &rdsiter);
287                 check_result(result, "dns_db_allrdatasets()");
288                 result = dns_rdatasetiter_first(rdsiter);
289                 dns_rdatasetiter_destroy(&rdsiter);
290                 if (result == ISC_R_SUCCESS)
291                         break;
292                 dns_db_detachnode(db, &node);
293                 result = dns_dbiterator_next(dbiter);
294         }
295         dns_dbiterator_destroy(&dbiter);
296         if (result != ISC_R_SUCCESS)
297                 fatal("failed to find data in keyset file");
298
299         isc_buffer_init(&b, tdomain, sizeof(tdomain) - 1);
300         result = dns_name_tofilenametext(domain, ISC_FALSE, &b);
301         check_result(result, "dns_name_tofilenametext()");
302         isc_buffer_putuint8(&b, 0);
303
304         output = isc_mem_allocate(mctx,
305                                   strlen("signedkey-") + strlen(tdomain) + 1);
306         if (output == NULL)
307                 fatal("out of memory");
308         strcpy(output, "signedkey-");
309         strcat(output, tdomain);
310
311         version = NULL;
312         dns_db_newversion(db, &version);
313
314         dns_rdataset_init(&rdataset);
315         dns_rdataset_init(&sigrdataset);
316         result = dns_db_findrdataset(db, node, version, dns_rdatatype_key, 0,
317                                      0, &rdataset, &sigrdataset);
318         if (result != ISC_R_SUCCESS) {
319                 char domainstr[DNS_NAME_FORMATSIZE];
320                 dns_name_format(domain, domainstr, sizeof domainstr);
321                 fatal("failed to find rdataset '%s KEY': %s",
322                       domainstr, isc_result_totext(result));
323         }
324
325         loadkeys(domain, &rdataset);
326
327         if (!dns_rdataset_isassociated(&sigrdataset))
328                 fatal("no SIG KEY set present");
329
330         result = dns_rdataset_first(&sigrdataset);
331         check_result(result, "dns_rdataset_first()");
332         do {
333                 dns_rdataset_current(&sigrdataset, &sigrdata);
334                 result = dns_rdata_tostruct(&sigrdata, &sig, mctx);
335                 check_result(result, "dns_rdata_tostruct()");
336                 key = findkey(&sig);
337                 result = dns_dnssec_verify(domain, &rdataset, key,
338                                            ISC_TRUE, mctx, &sigrdata);
339                 if (result != ISC_R_SUCCESS) {
340                         char keystr[KEY_FORMATSIZE];
341                         key_format(key, keystr, sizeof keystr);
342                         fatal("signature by key '%s' did not verify: %s",
343                               keystr, isc_result_totext(result));
344                 }
345                 dns_rdata_reset(&sigrdata);
346                 dns_rdata_freestruct(&sig);
347                 result = dns_rdataset_next(&sigrdataset);
348         } while (result == ISC_R_SUCCESS);
349
350         if (startstr != NULL) {
351                 starttime = strtotime(startstr, now, now);
352                 endtime = strtotime(endstr, now, starttime);
353         } else {
354                 starttime = sig.timesigned;
355                 endtime = sig.timeexpire;
356         }
357
358
359         for (keynode = ISC_LIST_HEAD(keylist);
360              keynode != NULL;
361              keynode = ISC_LIST_NEXT(keynode, link))
362                 if (!keynode->verified)
363                         fatal("Not all zone keys self signed the key set");
364
365         result = dns_rdataset_first(&sigrdataset);
366         check_result(result, "dns_rdataset_first()");
367         dns_rdataset_current(&sigrdataset, &sigrdata);
368         result = dns_rdata_tostruct(&sigrdata, &sig, mctx);
369         check_result(result, "dns_rdata_tostruct()");
370
371         dns_rdataset_disassociate(&sigrdataset);
372
373         argc -= 1;
374         argv += 1;
375
376         dns_rdatalist_init(&sigrdatalist);
377         sigrdatalist.rdclass = rdataset.rdclass;
378         sigrdatalist.type = dns_rdatatype_sig;
379         sigrdatalist.covers = dns_rdatatype_key;
380         sigrdatalist.ttl = rdataset.ttl;
381
382         for (i = 0; i < argc; i++) {
383                 key = NULL;
384                 result = dst_key_fromnamedfile(argv[i],
385                                                DST_TYPE_PUBLIC |
386                                                DST_TYPE_PRIVATE,
387                                                mctx, &key);
388                 if (result != ISC_R_SUCCESS)
389                         fatal("failed to read key %s from disk: %s",
390                               argv[i], isc_result_totext(result));
391
392                 rdata = isc_mem_get(mctx, sizeof(dns_rdata_t));
393                 if (rdata == NULL)
394                         fatal("out of memory");
395                 dns_rdata_init(rdata);
396                 data = isc_mem_get(mctx, BUFSIZE);
397                 if (data == NULL)
398                         fatal("out of memory");
399                 isc_buffer_init(&b, data, BUFSIZE);
400                 result = dns_dnssec_sign(domain, &rdataset, key,
401                                          &starttime, &endtime,
402                                          mctx, &b, rdata);
403                 isc_entropy_stopcallbacksources(ectx);
404                 if (result != ISC_R_SUCCESS) {
405                         char keystr[KEY_FORMATSIZE];
406                         key_format(key, keystr, sizeof keystr);
407                         fatal("key '%s' failed to sign data: %s",
408                               keystr, isc_result_totext(result));
409                 }
410                 if (tryverify) {
411                         result = dns_dnssec_verify(domain, &rdataset, key,
412                                                    ISC_TRUE, mctx, rdata);
413                         if (result != ISC_R_SUCCESS) {
414                                 char keystr[KEY_FORMATSIZE];
415                                 key_format(key, keystr, sizeof keystr);
416                                 fatal("signature from key '%s' failed to "
417                                       "verify: %s",
418                                       keystr, isc_result_totext(result));
419                         }
420                 }
421                 ISC_LIST_APPEND(sigrdatalist.rdata, rdata, link);
422                 dst_key_free(&key);
423         }
424
425         dns_rdataset_init(&newsigrdataset);
426         result = dns_rdatalist_tordataset(&sigrdatalist, &newsigrdataset);
427         check_result (result, "dns_rdatalist_tordataset()");
428
429         dns_db_addrdataset(db, node, version, 0, &newsigrdataset, 0, NULL);
430         check_result (result, "dns_db_addrdataset()");
431
432         dns_db_detachnode(db, &node);
433         dns_db_closeversion(db, &version, ISC_TRUE);
434         result = dns_db_dump(db, version, output);
435         if (result != ISC_R_SUCCESS)
436                 fatal("failed to write database to '%s': %s",
437                       output, isc_result_totext(result));
438
439         printf("%s\n", output);
440
441         dns_rdataset_disassociate(&rdataset);
442         dns_rdataset_disassociate(&newsigrdataset);
443
444         dns_rdata_freestruct(&sig);
445
446         while (!ISC_LIST_EMPTY(sigrdatalist.rdata)) {
447                 rdata = ISC_LIST_HEAD(sigrdatalist.rdata);
448                 ISC_LIST_UNLINK(sigrdatalist.rdata, rdata, link);
449                 isc_mem_put(mctx, rdata->data, BUFSIZE);
450                 isc_mem_put(mctx, rdata, sizeof *rdata);
451         }
452
453         dns_db_detach(&db);
454
455         while (!ISC_LIST_EMPTY(keylist)) {
456                 keynode = ISC_LIST_HEAD(keylist);
457                 ISC_LIST_UNLINK(keylist, keynode, link);
458                 dst_key_free(&keynode->key);
459                 isc_mem_put(mctx, keynode, sizeof(keynode_t));
460         }
461
462         cleanup_logging(&log);
463
464         isc_mem_free(mctx, output);
465         cleanup_entropy(&ectx);
466         dst_lib_destroy();
467         if (verbose > 10)
468                 isc_mem_stats(mctx, stdout);
469         isc_mem_destroy(&mctx);
470         return (0);
471 }