chiark / gitweb /
server/tests.at (AWAIT_KXDONE): Ignore the correct server messages.
[tripe] / server / keymgmt.c
1 /* -*-c-*-
2  *
3  * Key loading and storing
4  *
5  * (c) 2001 Straylight/Edgeware
6  */
7
8 /*----- Licensing notice --------------------------------------------------*
9  *
10  * This file is part of Trivial IP Encryption (TrIPE).
11  *
12  * TrIPE is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * TrIPE is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with TrIPE; if not, write to the Free Software Foundation,
24  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25  */
26
27 /*----- Header files ------------------------------------------------------*/
28
29 #include "tripe.h"
30
31 /*----- Key groups --------------------------------------------------------*/
32
33 /* The key-loading functions here must fill in the kdata slot @g@ and
34  * either @kpriv@ or @kpub@ as appropriate.  The caller will take care of
35  * determining @kpub@ given a private key, and of ensuring that @kpriv@ is
36  * null for a public key.
37  */
38
39 typedef struct kgops {
40   const char *ty;
41   int (*loadpriv)(key_data *, kdata *, dstr *, dstr *);
42   int (*loadpub)(key_data *, kdata *, dstr *, dstr *);
43 } kgops;
44
45 /* --- @KLOAD@ --- *
46  *
47  * Arguments:   @ty@, @TY@ = key type name (lower- and upper-case)
48  *              @which@, @WHICH@ = `pub' or `priv' (and upper-case)
49  *              @setgroup@ = code to initialize @kd->g@
50  *              @setpriv@ = code to initialize @kd->kpriv@
51  *              @setpub@ = code to initialize @kd->kpub@
52  *
53  * Use:         Generates the body of one of the (rather tedious) key loading
54  *              functions.  See the description of @KEYTYPES@ below for the
55  *              details.
56  */
57
58 #define KLOAD(ty, TY, which, WHICH, setgroup, setpriv, setpub)          \
59 static int kg##ty##_##which(key_data *d, kdata *kd, dstr *t, dstr *e)   \
60 {                                                                       \
61   key_packstruct kps[TY##_##WHICH##FETCHSZ];                            \
62   key_packdef *kp;                                                      \
63   ty##_##which p;                                                       \
64   int rc;                                                               \
65                                                                         \
66   /* --- Initialize things we've not set up yet --- */                  \
67                                                                         \
68   kd->g = 0; kd->kpub = 0;                                              \
69                                                                         \
70   /* --- Unpack the key --- */                                          \
71                                                                         \
72   kp = key_fetchinit(ty##_##which##fetch, kps, &p);                     \
73   if ((rc = key_unpack(kp, d, t)) != 0) {                               \
74     a_format(e, "unpack-failed", "%s", key_strerror(rc), A_END);        \
75     goto fail;                                                          \
76   }                                                                     \
77                                                                         \
78   /* --- Extract the pieces of the key --- */                           \
79                                                                         \
80   setgroup;                                                             \
81   setpriv;                                                              \
82   kd->kpub = G_CREATE(kd->g);                                           \
83   setpub;                                                               \
84                                                                         \
85   /* --- We win --- */                                                  \
86                                                                         \
87   rc = 0;                                                               \
88   goto done;                                                            \
89                                                                         \
90 fail:                                                                   \
91   if (kd->kpub) G_DESTROY(kd->g, kd->kpub);                             \
92   if (kd->g) G_DESTROYGROUP(kd->g);                                     \
93   rc = -1;                                                              \
94                                                                         \
95 done:                                                                   \
96   key_fetchdone(kp);                                                    \
97   return (rc);                                                          \
98 }
99
100 /* --- @KEYTYPES@ --- *
101  *
102  * A list of the various key types, and how to unpack them.  Each entry in
103  * the list has the form
104  *
105  *      _(ty, TY, setgroup, setpriv, setpub)
106  *
107  * The @ty@ and @TY@ are lower- and upper-case versions of the key type name,
108  * and there should be @key_fetchdef@s called @ty_{priv,pub}fetch@.
109  *
110  * The @setgroup@, @setpriv@ and @setpub@ items are code fragments which are
111  * passed to @KLOAD@ to build appropriate key-loading methods.  By the time
112  * these code fragments are run, the key has been unpacked from the incoming
113  * key data using @ty_whichfetch@ into a @ty_which@ structure named @p@.
114  * They can report errors by writing an appropriate token sequence to @e@ and
115  * jumping to @fail@.
116  */
117
118 #define KEYTYPES(_)                                                     \
119                                                                         \
120   /* --- Diffie-Hellman --- */                                          \
121                                                                         \
122   _(dh, DH,                                                             \
123     { kd->g = group_prime(&p.dp); },                                    \
124     { kd->kpriv = MP_COPY(p.x); },                                      \
125     { if (G_FROMINT(kd->g, kd->kpub, p.y)) {                            \
126         a_format(e, "bad-public-vector", A_END);                        \
127         goto fail;                                                      \
128       }                                                                 \
129     })                                                                  \
130                                                                         \
131   /* --- Elliptic curves --- */                                         \
132                                                                         \
133   _(ec, EC,                                                             \
134     { ec_info ei; const char *err;                                      \
135       if ((err = ec_getinfo(&ei, p.cstr)) != 0) {                       \
136         a_format(e, "decode-failed", "%s", err, A_END);                 \
137         goto fail;                                                      \
138       }                                                                 \
139       kd->g = group_ec(&ei);                                            \
140     },                                                                  \
141     { kd->kpriv = MP_COPY(p.x); },                                      \
142     { if (G_FROMEC(kd->g, kd->kpub, &p.p)) {                            \
143         a_format(e, "bad-public-vector", A_END);                        \
144         goto fail;                                                      \
145       }                                                                 \
146     })
147
148 #define KEYTYPE_DEF(ty, TY, setgroup, setpriv, setpub)                  \
149   KLOAD(ty, TY, priv, PRIV, setgroup, setpriv,                          \
150         { G_EXP(kd->g, kd->kpub, kd->g->g, kd->kpriv); })               \
151   KLOAD(ty, TY, pub, PUB, setgroup, { }, setpub)                        \
152   static const kgops kg##ty##_ops = { #ty, kg##ty##_priv, kg##ty##_pub };
153 KEYTYPES(KEYTYPE_DEF)
154
155 /* --- Table of supported key types --- */
156
157 static const kgops *kgtab[] = {
158 #define KEYTYPE_ENTRY(ty, TY, setgroup, setpriv, setpub) &kg##ty##_ops,
159   KEYTYPES(KEYTYPE_ENTRY)
160 #undef KEYTYPE_ENTRY
161   0
162 };
163
164 /*----- Algswitch stuff ---------------------------------------------------*/
165
166 /* --- @algs_get@ --- *
167  *
168  * Arguments:   @algswitch *a@ = where to put the algorithms
169  *              @dstr *e@ = where to write errror tokens
170  *              @key_file *kf@ = key file
171  *              @key *k@ = key to inspect
172  *
173  * Returns:     Zero if OK; nonzero on error.
174  *
175  * Use:         Extracts an algorithm choice from a key.
176  */
177
178 static int algs_get(algswitch *a, dstr *e, key_file *kf, key *k)
179 {
180   const char *p;
181   const bulkcrypto *bulk;
182   char *q, *qq;
183   dstr d = DSTR_INIT, dd = DSTR_INIT;
184   int rc = -1;
185
186   /* --- Hash function --- */
187
188   if ((p = key_getattr(kf, k, "hash")) == 0) p = "rmd160";
189   if ((a->h = ghash_byname(p)) == 0) {
190     a_format(e, "unknown-hash", "%s", p, A_END);
191     goto done;
192   }
193
194   /* --- Symmetric encryption for key derivation --- */
195
196   if ((p = key_getattr(kf, k, "mgf")) == 0) {
197     dstr_reset(&d);
198     dstr_putf(&d, "%s-mgf", a->h->name);
199     p = d.buf;
200   }
201   if ((a->mgf = gcipher_byname(p)) == 0) {
202     a_format(e, "unknown-mgf-cipher", "%s", p, A_END);
203     goto done;
204   }
205
206   /* --- Bulk crypto transform --- */
207
208   if ((p = key_getattr(kf, k, "bulk")) == 0) p = "v0";
209   for (bulk = bulktab; bulk->name && strcmp(p, bulk->name) != 0; bulk++);
210   if (!bulk->name) {
211     a_format(e, "unknown-bulk-transform", "%s", p, A_END);
212     goto done;
213   }
214   a->bulk = bulk;
215
216   /* --- Symmetric encryption for bulk data --- */
217
218   if (!(a->bulk->prim & BCP_CIPHER))
219     a->c = 0;
220   else {
221     if ((p = key_getattr(kf, k, "cipher")) == 0) p = "blowfish-cbc";
222     if ((a->c = gcipher_byname(p)) == 0) {
223       a_format(e, "unknown-cipher", "%s", p, A_END);
224       goto done;
225     }
226   }
227
228   /* --- Block cipher for miscellaneous use --- */
229
230   if (!(a->bulk->prim & BCP_BLKC))
231     a->b = 0;
232   else {
233     if ((p = key_getattr(kf, k, "blkc")) == 0) {
234       dstr_reset(&dd);
235       dstr_puts(&dd, a->c ? a->c->name : "rijndael-");
236       if ((q = strrchr(dd.buf, '-')) != 0) *q = 0;
237       p = dd.buf;
238     }
239     dstr_reset(&d);
240     dstr_putf(&d, "%s-ecb", p);
241     if ((a->b = gcipher_byname(d.buf)) == 0) {
242       a_format(e, "unknown-blkc", "%s", p, A_END);
243       goto done;
244     }
245   }
246
247   /* --- Message authentication for bulk data --- */
248
249   if (!(a->bulk->prim & BCP_MAC)) {
250     a->m = 0;
251     a->tagsz = 0;
252   } else {
253     if ((p = key_getattr(kf, k, "mac")) != 0) {
254       dstr_reset(&d);
255       dstr_puts(&d, p);
256       if ((q = strchr(d.buf, '/')) != 0)
257         *q++ = 0;
258       if ((a->m = gmac_byname(d.buf)) == 0) {
259         a_format(e, "unknown-mac", "%s", d.buf, A_END);
260         goto done;
261       }
262       if (!q)
263         a->tagsz = a->m->hashsz;
264       else {
265         unsigned long n = strtoul(q, &qq, 0);
266         if (*qq)  {
267           a_format(e, "bad-tag-length-string", "%s", q, A_END);
268           goto done;
269         }
270         if (n%8 || n/8 > a->m->hashsz) {
271           a_format(e, "bad-tag-length", "%lu", n, A_END);
272           goto done;
273         }
274         a->tagsz = n/8;
275       }
276     } else {
277       dstr_reset(&d);
278       dstr_putf(&d, "%s-hmac", a->h->name);
279       if ((a->m = gmac_byname(d.buf)) == 0) {
280         a_format(e, "no-hmac-for-hash", "%s", a->h->name, A_END);
281         goto done;
282       }
283       a->tagsz = a->h->hashsz/2;
284     }
285   }
286
287   /* --- All done --- */
288
289   rc = 0;
290 done:
291   dstr_destroy(&d);
292   dstr_destroy(&dd);
293   return (rc);
294 }
295
296 /* --- @algs_check@ --- *
297  *
298  * Arguments:   @algswitch *a@ = a choice of algorithms
299  *              @dstr *e@ = where to write error tokens
300  *              @const group *g@ = the group we're working in
301  *
302  * Returns:     Zero if OK; nonzero on error.
303  *
304  * Use:         Checks an algorithm choice for sensibleness.  This also
305  *              derives some useful information from the choices, and you
306  *              must call this before committing the algorithm selection
307  *              for use by @keyset@ functions.
308  */
309
310 static int algs_check(algswitch *a, dstr *e, const group *g)
311 {
312   /* --- Check the bulk crypto transform --- */
313
314   if (a->bulk->check(a, e)) return (-1);
315
316   /* --- Derive the key sizes --- *
317    *
318    * Must ensure that we have non-empty keys.  This isn't ideal, but it
319    * provides a handy sanity check.  Also must be based on a 64- or 128-bit
320    * block cipher or we can't do the data expiry properly.
321    */
322
323   a->hashsz = a->h->hashsz;
324   if (a->c && (a->cksz = keysz(a->hashsz, a->c->keysz)) == 0) {
325     a_format(e, "cipher", "%s", a->c->name,
326              "no-key-size", "%lu", (unsigned long)a->hashsz,
327              A_END);
328     return (-1);
329   }
330   if (a->m && (a->mksz = keysz(a->hashsz, a->m->keysz)) == 0) {
331     a_format(e, "mac", "%s", a->m->name,
332              "no-key-size", "%lu", (unsigned long)a->hashsz,
333              A_END);
334     return (-1);
335   }
336   if (a->b && (a->bksz = keysz(a->hashsz, a->b->keysz)) == 0) {
337     a_format(e, "blkc", "%.*s", strlen(a->b->name) - 4, a->b->name,
338              "no-key-size", "%lu", (unsigned long)a->hashsz,
339              A_END);
340     return (-1);
341   }
342
343   /* --- Derive the data limit --- */
344
345   if (a->c && a->c->blksz < 16) a->expsz = MEG(64);
346   else a->expsz = MEG(2048);
347
348   /* --- Ensure the MGF accepts hashes as keys --- */
349
350   if (keysz(a->hashsz, a->mgf->keysz) != a->hashsz) {
351     a_format(e, "mgf", "%s", a->mgf->name,
352              "restrictive-key-schedule",
353              A_END);
354     return (-1);
355   }
356
357   /* --- All ship-shape and Bristol-fashion --- */
358
359   return (0);
360 }
361
362 /* --- @km_samealgsp@ --- *
363  *
364  * Arguments:   @const kdata *kdx, *kdy@ = two key data objects
365  *
366  * Returns:     Nonzero if their two algorithm selections are the same.
367  *
368  * Use:         Checks sameness of algorithm selections: used to ensure that
369  *              peers are using sensible algorithms.
370  */
371
372 int km_samealgsp(const kdata *kdx, const kdata *kdy)
373 {
374   const algswitch *a = &kdx->algs, *aa = &kdy->algs;
375
376   return (group_samep(kdx->g, kdy->g) &&
377           a->bulk == aa->bulk &&
378           a->c == aa->c && a->b == aa->b &&
379           a->mgf == aa->mgf && a->h == aa->h &&
380           a->m == aa->m && a->tagsz == aa->tagsz);
381 }
382
383 /*----- Key data and key nodes --------------------------------------------*/
384
385 typedef struct keyhalf {
386   const char *kind;
387   int (*load)(const kgops *, key_data *, kdata *, dstr *, dstr *);
388   const char *kr;
389   key_file *kf;
390   fwatch w;
391   sym_table tab;
392 } keyhalf;
393
394 /* --- @kh_loadpub@, @kh_loadpriv@ --- *
395  *
396  * Arguments:   @const kgops *ko@ = key-group operations for key type
397  *              @key_data *d@ = key data object as stored in keyring
398  *              @kdata *kd@ = our key-data object to fill in
399  *              @dstr *t@ = the key tag name
400  *              @dstr *e@ = a string to write error tokens to
401  *
402  * Returns:     Zero on success, @-1@ on error.
403  *
404  * Use:         These functions handle the main difference between public and
405  *              private key halves.  They are responsible for setting @g@,
406  *              @kpriv@ and @kpub@ appropriately in all keys, handling the
407  *              mismatch between the largely half-indifferent calling code
408  *              and the group-specific loading functions.
409  *
410  *              The function @kh_loadpriv@ is also responsible for checking
411  *              the group for goodness.  We don't bother checking public
412  *              keys, because each public key we actually end up using must
413  *              share a group with a private key which we'll already have
414  *              checked.
415  */
416
417 static int kh_loadpub(const kgops *ko, key_data *d, kdata *kd,
418                       dstr *t, dstr *e)
419 {
420   int rc;
421
422   if ((rc = ko->loadpub(d, kd, t, e)) != 0)
423     goto fail_0;
424   if (group_check(kd->g, kd->kpub)) {
425     a_format(e, "bad-public-group-element", A_END);
426     goto fail_1;
427   }
428   kd->kpriv = 0;
429   return (0);
430
431 fail_1:
432   G_DESTROY(kd->g, kd->kpub);
433   G_DESTROYGROUP(kd->g);
434 fail_0:
435   return (-1);
436 }
437
438 static int kh_loadpriv(const kgops *ko, key_data *d, kdata *kd,
439                        dstr *t, dstr *e)
440 {
441   int rc;
442   const char *err;
443
444   if ((rc = ko->loadpriv(d, kd, t, e)) != 0)
445     goto fail_0;
446   if ((err = G_CHECK(kd->g, &rand_global)) != 0) {
447     a_format(e, "bad-group", "%s", err, A_END);
448     goto fail_1;
449   }
450   return (0);
451
452 fail_1:
453   mp_drop(kd->kpriv);
454   G_DESTROY(kd->g, kd->kpub);
455   G_DESTROYGROUP(kd->g);
456 fail_0:
457   return (-1);
458 }
459
460 static struct keyhalf
461   priv = { "private", kh_loadpriv },
462   pub = { "public", kh_loadpub };
463
464 /* --- @keymoan@ --- *
465  *
466  * Arguments:   @const char *file@ = name of the file
467  *              @int line@ = line number in file
468  *              @const char *msg@ = error message
469  *              @void *p@ = argument pointer (indicates which keyring)
470  *
471  * Returns:     ---
472  *
473  * Use:         Reports an error message about loading a key file.
474  */
475
476 static void keymoan(const char *file, int line, const char *msg, void *p)
477 {
478   keyhalf *kh = p;
479
480   if (!line) {
481     a_warn("KEYMGMT", "%s-keyring", kh->kind, "%s", file,
482            "io-error", "?ERRNO", A_END);
483   } else {
484     a_warn("KEYMGMT", "%s-keyring", kh->kind, "%s", file, "line", "%d", line,
485            "%s", msg, A_END);
486   }
487 }
488
489 /* --- @kh_reopen@ --- *
490  *
491  * Arguments:   @keyhalf *kh@ = pointer to keyhalf structure
492  *
493  * Returns:     Zero on success, @-1@ on error.
494  *
495  * Use:         Reopens the key file for the appropriate key half.  If this
496  *              fails, everything is left as it was; if it succeeds, then the
497  *              old file is closed (if it was non-null) and the new one put
498  *              in its place.
499  */
500
501 static int kh_reopen(keyhalf *kh)
502 {
503   key_file *kf = CREATE(key_file);
504
505   if (key_open(kf, kh->kr, KOPEN_READ, keymoan, kh)) {
506     a_warn("KEYMGMT", "%s-keyring", kh->kind, "%s", kh->kr,
507            "io-error", "?ERRNO", A_END);
508     DESTROY(kf);
509     return (-1);
510   } else {
511     if (kh->kf) {
512       key_close(kh->kf);
513       DESTROY(kh->kf);
514     }
515     kh->kf = kf;
516     return (0);
517   }
518 }
519
520 /* --- @kh_init@ --- *
521  *
522  * Arguments:   @keyhalf *kh@ = pointer to keyhalf structure to set up
523  *              @const char *kr@ = name of the keyring file
524  *
525  * Returns:     ---
526  *
527  * Use:         Initialize a keyhalf structure, maintaining the private or
528  *              public keys.  Intended to be called during initialization:
529  *              exits if there's some kind of problem.
530  */
531
532 static void kh_init(keyhalf *kh, const char *kr)
533 {
534   kh->kr = kr;
535   fwatch_init(&kh->w, kr);
536   sym_create(&kh->tab);
537   kh->kf = 0;
538
539   if (kh_reopen(kh))
540     die(EXIT_FAILURE, "failed to load %s keyring `%s'", kh->kind, kr);
541 }
542
543 /* --- @kh_load@ --- *
544  *
545  * Arguments:   @keyhalf *kh@ = pointer to keyhalf
546  *              @const char *tag@ = key tag to be loaded
547  *              @int complainp@ = whether to complain about missing keys
548  *
549  * Returns:     Pointer to a @kdata@ structure if successful, or null on
550  *              failure.
551  *
552  * Use:         Attempts to load a key from the current key file.  This
553  *              function always reads data from the file: it's used when
554  *              there's a cache miss from @kh_find@, and when refreshing the
555  *              known keys in @kh_refresh@.  The returned kdata has a
556  *              reference count of exactly 1, and has no home knode.
557  */
558
559 static kdata *kh_load(keyhalf *kh, const char *tag, int complainp)
560 {
561   dstr t = DSTR_INIT;
562   dstr e = DSTR_INIT;
563   key *k;
564   key_data **d;
565   kdata *kd;
566   const char *ty;
567   const kgops **ko;
568
569   /* --- Find the key and grab its tag --- */
570
571   if (key_qtag(kh->kf, tag, &t, &k, &d)) {
572     if (complainp) {
573       a_warn("KEYMGMT", "%s-keyring", kh->kind, "%s", kh->kr,
574              "key-not-found", "%s", tag, A_END);
575     }
576     goto fail_0;
577   }
578
579   /* --- Find the key's group type and the appropriate operations --- *
580    *
581    * There are several places to look for the key type.  The most obvious is
582    * the `kx-group' key attribute.  But there's also the key type itself, for
583    * compatibility reasons.
584    */
585
586   ty = key_getattr(kh->kf, k, "kx-group");
587   if (!ty && strncmp(k->type, "tripe-", 6) == 0) ty = k->type + 6;
588   if (!ty) ty = "dh";
589
590   for (ko = kgtab; *ko; ko++)
591     if (strcmp((*ko)->ty, ty) == 0) goto foundko;
592   a_warn("KEYMGMT", "%s-keyring", kh->kind,
593          "%s", kh->kr, "key", "%s", t.buf,
594          "unknown-group-type", "%s", ty, A_END);
595   goto fail_0;
596
597 foundko:
598   kd = CREATE(kdata);
599   if (kh->load(*ko, *d, kd, &t, &e)) {
600     a_warn("KEYMGMT", "%s-keyring", kh->kind,
601            "%s", kh->kr, "key" "%s", t.buf,
602            "*%s", e.buf, A_END);
603     goto fail_1;
604   }
605
606   if (algs_get(&kd->algs, &e, kh->kf, k) ||
607       (kd->kpriv && algs_check(&kd->algs, &e, kd->g))) {
608     a_warn("KEYMGMT", "%s-keyring", kh->kind,
609            "%s", kh->kr, "key", "%s", t.buf,
610            "*%s", e.buf, A_END);
611     goto fail_2;
612   }
613
614   kd->tag = xstrdup(t.buf);
615   kd->indexsz = mp_octets(kd->g->r);
616   kd->ref = 1;
617   kd->kn = 0;
618   kd->t_exp = k->exp;
619
620   IF_TRACING(T_KEYMGMT, {
621     trace(T_KEYMGMT, "keymgmt: loaded %s key `%s'", kh->kind, t.buf);
622     IF_TRACING(T_CRYPTO, {
623       trace(T_CRYPTO, "crypto: r = %s", mpstr(kd->g->r));
624       trace(T_CRYPTO, "crypto: h = %s", mpstr(kd->g->h));
625       if (kd->kpriv)
626         trace(T_CRYPTO, "crypto: x = %s", mpstr(kd->kpriv));
627       trace(T_CRYPTO, "crypto: cipher = %s", kd->algs.c->name);
628       trace(T_CRYPTO, "crypto: mgf = %s", kd->algs.mgf->name);
629       trace(T_CRYPTO, "crypto: hash = %s", kd->algs.h->name);
630       trace(T_CRYPTO, "crypto: mac = %s/%lu",
631             kd->algs.m->name, (unsigned long)kd->algs.tagsz * 8);
632     })
633   })
634
635   goto done;
636
637 fail_2:
638   if (kd->kpriv) mp_drop(kd->kpriv);
639   G_DESTROY(kd->g, kd->kpub);
640   G_DESTROYGROUP(kd->g);
641 fail_1:
642   DESTROY(kd);
643 fail_0:
644   kd = 0;
645 done:
646   dstr_destroy(&t);
647   dstr_destroy(&e);
648   return (kd);
649 }
650
651 /* --- @kh_find@ --- *
652  *
653  * Arguments:   @keyhalf *kh@ = pointer to the keyhalf
654  *              @const char *tag@ = key to be obtained
655  *              @int complainp@ = whether to complain about missing keys
656  *
657  * Returns:     A pointer to the kdata, or null on error.
658  *
659  * Use:         Obtains kdata, maybe from the cache.  This won't update a
660  *              stale cache entry, though @kh_refresh@ ought to have done
661  *              that already.  The returned kdata object may be shared with
662  *              other users.  (One of this function's responsibilities, over
663  *              @kh_load@, is to set the home knode of a freshly loaded
664  *              kdata.)
665  */
666
667 static kdata *kh_find(keyhalf *kh, const char *tag, int complainp)
668 {
669   knode *kn;
670   kdata *kd;
671   unsigned f;
672
673   kn = sym_find(&kh->tab, tag, -1, sizeof(knode), &f);
674
675   if (f) {
676     if (kn->f & KNF_BROKEN) {
677       T( if (complainp)
678            trace(T_KEYMGMT, "keymgmt: key `%s' marked as broken", tag); )
679       return (0);
680     }
681
682     kd = kn->kd;
683     if (kd) kd->ref++;
684     T( trace(T_KEYMGMT, "keymgmt: %scache hit for key `%s'",
685              kd ? "" : "negative ", tag); )
686     return (kd);
687   } else {
688     kd = kh_load(kh, tag, complainp);
689     kn->kd = kd;
690     kn->kh = kh;
691     kn->f = 0;
692     if (!kd)
693       kn->f |= KNF_BROKEN;
694     else {
695       kd->kn = kn;
696       kd->ref++;
697     }
698     return (kd);
699   }
700 }
701
702 /* --- @kh_refresh@ --- *
703  *
704  * Arguments:   @keyhalf *kh@ = pointer to the keyhalf
705  *
706  * Returns:     Zero if nothing needs to be done; nonzero if peers should
707  *              refresh their keys.
708  *
709  * Use:         Refreshes cached keys from files.
710  *
711  *              Each active knode is examined to see if a new key is
712  *              available: the return value is nonzero if any new keys are.
713  *              A key is considered new if its algorithms, public key, or
714  *              expiry time are/is different.
715  *
716  *              Stub knodes (with no kdata attached) are removed, so that a
717  *              later retry can succeed if the file has been fixed.  (This
718  *              doesn't count as a change, since no peers should be relying
719  *              on a nonexistent key.)
720  */
721
722 static int kh_refresh(keyhalf *kh)
723 {
724   knode *kn;
725   kdata *kd;
726   sym_iter i;
727   int changep = 0;
728
729   if (!fwatch_update(&kh->w, kh->kr) || kh_reopen(kh))
730     return (0);
731
732   T( trace(T_KEYMGMT, "keymgmt: rescan %s keyring `%s'", kh->kind, kh->kr); )
733   for (sym_mkiter(&i, &kh->tab); (kn = sym_next(&i)) != 0; ) {
734     if (!kn->kd) {
735       T( trace(T_KEYMGMT, "keymgmt: discard stub entry for key `%s'",
736                SYM_NAME(kn)); )
737       sym_remove(&kh->tab, kn);
738       continue;
739     }
740     if ((kd = kh_load(kh, SYM_NAME(kn), 1)) == 0) {
741       if (!(kn->f & KNF_BROKEN)) {
742         T( trace(T_KEYMGMT, "keymgmt: failed to load new key `%s': "
743                  "marking it as broken",
744                  SYM_NAME(kn)); )
745         kn->f |= KNF_BROKEN;
746       }
747       continue;
748     }
749     kn->f &= ~KNF_BROKEN;
750     if (kd->t_exp == kn->kd->t_exp &&
751         km_samealgsp(kd, kn->kd) &&
752         G_EQ(kd->g, kd->kpub, kn->kd->kpub)) {
753       T( trace(T_KEYMGMT, "keymgmt: key `%s' unchanged", SYM_NAME(kn)); )
754       continue;
755     }
756     T( trace(T_KEYMGMT, "keymgmt: loaded new version of key `%s'",
757              SYM_NAME(kn)); )
758     km_unref(kn->kd);
759     kd->kn = kn;
760     kn->kd = kd;
761     changep = 1;
762   }
763
764   return (changep);
765 }
766
767 /*----- Main code ---------------------------------------------------------*/
768
769 const char *tag_priv;
770 kdata *master;
771
772 /* --- @km_init@ --- *
773  *
774  * Arguments:   @const char *privkr@ = private keyring file
775  *              @const char *pubkr@ = public keyring file
776  *              @const char *ptag@ = default private-key tag
777  *
778  * Returns:     ---
779  *
780  * Use:         Initializes the key-management machinery, loading the
781  *              keyrings and so on.
782  */
783
784 void km_init(const char *privkr, const char *pubkr, const char *ptag)
785 {
786   const gchash *const *hh;
787
788   for (hh = ghashtab; *hh; hh++) {
789     if ((*hh)->hashsz > MAXHASHSZ) {
790       die(EXIT_FAILURE, "INTERNAL ERROR: %s hash length %lu > MAXHASHSZ %d",
791           (*hh)->name, (unsigned long)(*hh)->hashsz, MAXHASHSZ);
792     }
793   }
794
795   kh_init(&priv, privkr);
796   kh_init(&pub, pubkr);
797
798   tag_priv = ptag;
799   if ((master = km_findpriv(ptag)) == 0) exit(EXIT_FAILURE);
800 }
801
802 /* --- @km_reload@ --- *
803  *
804  * Arguments:   ---
805  *
806  * Returns:     Zero if OK, nonzero to force reloading of keys.
807  *
808  * Use:         Checks the keyrings to see if they need reloading.
809  */
810
811 int km_reload(void)
812 {
813   int changep = 0;
814   kdata *kd;
815
816   if (kh_refresh(&priv)) {
817     changep = 1;
818     kd = master->kn->kd;
819     if (kd != master) {
820       km_unref(master);
821       km_ref(kd);
822       master = kd;
823     }
824   }
825   if (kh_refresh(&pub))
826     changep = 1;
827   return (changep);
828 }
829
830 /* --- @km_findpub@, @km_findpriv@ --- *
831  *
832  * Arguments:   @const char *tag@ = key tag to load
833  *
834  * Returns:     Pointer to the kdata object if successful, or null on error.
835  *
836  * Use:         Fetches a public or private key from the keyring.
837  */
838
839 kdata *km_findpub(const char *tag) { return (kh_find(&pub, tag, 1)); }
840
841 kdata *km_findpriv(const char *tag)
842 {
843   kdata *kd;
844
845   /* Unpleasantness for the sake of compatibility. */
846   if (!tag && (kd = kh_find(&priv, "tripe", 0)) != 0) return (kd);
847   else return (kh_find(&priv, tag ? tag : "tripe-dh", 1));
848 }
849
850 /* --- @km_tag@ --- *
851  *
852  * Arguments:   @kdata *kd@ - pointer to the kdata object
853  *
854  * Returns:     A pointer to the short tag by which the kdata was loaded.
855  */
856
857 const char *km_tag(kdata *kd) { return (SYM_NAME(kd->kn)); }
858
859 /* --- @km_ref@ --- *
860  *
861  * Arguments:   @kdata *kd@ = pointer to the kdata object
862  *
863  * Returns:     ---
864  *
865  * Use:         Claim a new reference to a kdata object.
866  */
867
868 void km_ref(kdata *kd) { kd->ref++; }
869
870 /* --- @km_unref@ --- *
871  *
872  * Arguments:   @kdata *kd@ = pointer to the kdata object
873  *
874  * Returns:     ---
875  *
876  * Use:         Releases a reference to a kdata object.
877  */
878
879 void km_unref(kdata *kd)
880 {
881   if (--kd->ref) return;
882   if (kd->kpriv) mp_drop(kd->kpriv);
883   G_DESTROY(kd->g, kd->kpub);
884   xfree(kd->tag);
885   G_DESTROYGROUP(kd->g);
886 }
887
888 /*----- That's all, folks -------------------------------------------------*/