chiark / gitweb /
server/keymgmt.c: Detect if a private keys records a wrong public key.
[tripe] / server / keymgmt.c
CommitLineData
410c8acf 1/* -*-c-*-
2 *
410c8acf 3 * Key loading and storing
4 *
5 * (c) 2001 Straylight/Edgeware
6 */
7
e04c2d50 8/*----- Licensing notice --------------------------------------------------*
410c8acf 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.
e04c2d50 16 *
410c8acf 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.
e04c2d50 21 *
410c8acf 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
410c8acf 27/*----- Header files ------------------------------------------------------*/
28
29#include "tripe.h"
30
b5c45da1 31/*----- Algswitch stuff ---------------------------------------------------*/
32
33/* --- @algs_get@ --- *
34 *
35 * Arguments: @algswitch *a@ = where to put the algorithms
4998da61 36 * @dstr *e@ = where to write error tokens
4d36660a 37 * @key_file *kf@ = key file
b5c45da1 38 * @key *k@ = key to inspect
39 *
4d36660a 40 * Returns: Zero if OK; nonzero on error.
b5c45da1 41 *
42 * Use: Extracts an algorithm choice from a key.
43 */
44
4d36660a 45static int algs_get(algswitch *a, dstr *e, key_file *kf, key *k)
b5c45da1 46{
47 const char *p;
c70a7c5c 48 const bulkops *bops;
b87bffcb 49 dstr d = DSTR_INIT, dd = DSTR_INIT;
4d36660a 50 int rc = -1;
b5c45da1 51
4d36660a
MW
52 /* --- Hash function --- */
53
54 if ((p = key_getattr(kf, k, "hash")) == 0) p = "rmd160";
55 if ((a->h = ghash_byname(p)) == 0) {
56 a_format(e, "unknown-hash", "%s", p, A_END);
57 goto done;
58 }
b5c45da1 59
4d36660a 60 /* --- Symmetric encryption for key derivation --- */
b5c45da1 61
74ee77cb 62 if ((p = key_getattr(kf, k, "mgf")) == 0) {
b5c45da1 63 dstr_reset(&d);
74ee77cb 64 dstr_putf(&d, "%s-mgf", a->h->name);
b5c45da1 65 p = d.buf;
66 }
4d36660a
MW
67 if ((a->mgf = gcipher_byname(p)) == 0) {
68 a_format(e, "unknown-mgf-cipher", "%s", p, A_END);
69 goto done;
70 }
71
a93aacce 72 /* --- Bulk crypto transform --- */
b5c45da1 73
a93aacce 74 if ((p = key_getattr(kf, k, "bulk")) == 0) p = "v0";
c70a7c5c
MW
75 for (bops = bulktab; bops->name && strcmp(p, bops->name) != 0; bops++);
76 if (!bops->name) {
a93aacce
MW
77 a_format(e, "unknown-bulk-transform", "%s", p, A_END);
78 goto done;
79 }
c70a7c5c
MW
80 if ((a->bulk = bops->getalgs(a, e, kf, k)) == 0) goto done;
81 a->bulk->ops = bops;
b5c45da1 82
a93aacce
MW
83 /* --- All done --- */
84
4d36660a 85 rc = 0;
b5c45da1 86done:
87 dstr_destroy(&d);
b87bffcb 88 dstr_destroy(&dd);
4d36660a 89 return (rc);
b5c45da1 90}
91
92/* --- @algs_check@ --- *
93 *
94 * Arguments: @algswitch *a@ = a choice of algorithms
4d36660a 95 * @dstr *e@ = where to write error tokens
5b9f3d37 96 * @const dhgrp *grp@ = the group we're working in
b5c45da1 97 *
4d36660a 98 * Returns: Zero if OK; nonzero on error.
b5c45da1 99 *
100 * Use: Checks an algorithm choice for sensibleness. This also
101 * derives some useful information from the choices, and you
102 * must call this before committing the algorithm selection
103 * for use by @keyset@ functions.
104 */
105
5b9f3d37 106static int algs_check(algswitch *a, dstr *e, const dhgrp *grp)
b5c45da1 107{
b5c45da1 108 a->hashsz = a->h->hashsz;
b5c45da1 109
4d36660a
MW
110 if (keysz(a->hashsz, a->mgf->keysz) != a->hashsz) {
111 a_format(e, "mgf", "%s", a->mgf->name,
112 "restrictive-key-schedule",
113 A_END);
114 return (-1);
115 }
b5c45da1 116
c70a7c5c 117 if (a->bulk->ops->checkalgs(a->bulk, a, e)) return (-1);
b5c45da1 118
119 return (0);
120}
121
799e58b9 122/* --- @km_samealgsp@ --- *
b5c45da1 123 *
799e58b9 124 * Arguments: @const kdata *kdx, *kdy@ = two key data objects
b5c45da1 125 *
799e58b9 126 * Returns: Nonzero if their two algorithm selections are the same.
b5c45da1 127 *
128 * Use: Checks sameness of algorithm selections: used to ensure that
129 * peers are using sensible algorithms.
130 */
131
799e58b9 132int km_samealgsp(const kdata *kdx, const kdata *kdy)
b5c45da1 133{
799e58b9
MW
134 const algswitch *a = &kdx->algs, *aa = &kdy->algs;
135
5b9f3d37
MW
136 return (kdx->grp->ops == kdy->grp->ops &&
137 kdx->grp->ops->samegrpp(kdx->grp, kdy->grp) &&
799e58b9 138 a->mgf == aa->mgf && a->h == aa->h &&
c70a7c5c
MW
139 a->bulk->ops == aa->bulk->ops &&
140 a->bulk->ops->samealgsp(a->bulk, aa->bulk));
b5c45da1 141}
142
799e58b9
MW
143/*----- Key data and key nodes --------------------------------------------*/
144
145typedef struct keyhalf {
146 const char *kind;
5b9f3d37
MW
147 int (*load)(key_file *, key *, key_data *,
148 const dhops *, kdata *, dstr *, dstr *);
799e58b9
MW
149 const char *kr;
150 key_file *kf;
151 fwatch w;
152 sym_table tab;
153} keyhalf;
154
155/* --- @kh_loadpub@, @kh_loadpriv@ --- *
156 *
5b9f3d37
MW
157 * Arguments: @const dhops *dh@ = Diffie--Hellman operations for key type
158 * @key_file *kf@ = key file from which the key was loaded
159 * @key *k@ = the key object we're loading
160 * @key_data *d@ = the key data to load
799e58b9
MW
161 * @kdata *kd@ = our key-data object to fill in
162 * @dstr *t@ = the key tag name
163 * @dstr *e@ = a string to write error tokens to
164 *
165 * Returns: Zero on success, @-1@ on error.
166 *
167 * Use: These functions handle the main difference between public and
5b9f3d37
MW
168 * private key halves. They are responsible for setting @grp@,
169 * @k@ and @K@ appropriately in all keys, handling the mismatch
170 * between the largely half-indifferent calling code and the
171 * group-specific loading functions.
799e58b9
MW
172 *
173 * The function @kh_loadpriv@ is also responsible for checking
174 * the group for goodness. We don't bother checking public
175 * keys, because each public key we actually end up using must
176 * share a group with a private key which we'll already have
177 * checked.
178 */
179
5b9f3d37
MW
180static int kh_loadpub(key_file *kf, key *k, key_data *d,
181 const dhops *dh, kdata *kd, dstr *t, dstr *e)
799e58b9
MW
182{
183 int rc;
184
5b9f3d37 185 if ((rc = dh->ldpub(kf, k, d, kd, t, e)) != 0)
799e58b9 186 goto fail_0;
5b9f3d37
MW
187 kd->grp->ops = dh;
188 if (kd->grp->ops->checkge(kd->grp, kd->K)) {
73174919 189 a_format(e, "bad-public-group-element", A_END);
799e58b9
MW
190 goto fail_1;
191 }
799e58b9
MW
192 return (0);
193
194fail_1:
5b9f3d37
MW
195 kd->grp->ops->freege(kd->grp, kd->K);
196 kd->grp->ops->freegrp(kd->grp);
799e58b9
MW
197fail_0:
198 return (-1);
199}
200
5b9f3d37
MW
201static int kh_loadpriv(key_file *kf, key *k, key_data *d,
202 const dhops *dh, kdata *kd, dstr *t, dstr *e)
799e58b9
MW
203{
204 int rc;
205 const char *err;
f1d5c891
MW
206 dhge *K;
207 int ok;
799e58b9 208
5b9f3d37 209 if ((rc = dh->ldpriv(kf, k, d, kd, t, e)) != 0)
799e58b9 210 goto fail_0;
5b9f3d37
MW
211 kd->grp->ops = dh;
212 if ((err = kd->grp->ops->checkgrp(kd->grp)) != 0) {
799e58b9
MW
213 a_format(e, "bad-group", "%s", err, A_END);
214 goto fail_1;
215 }
f1d5c891
MW
216 K = kd->grp->ops->mul(kd->grp, kd->k, 0);
217 ok = kd->grp->ops->eq(kd->grp, kd->K, K);
218 kd->grp->ops->freege(kd->grp, K);
219 if (!ok) {
220 a_format(e, "incorrect-public-key", A_END);
221 goto fail_1;
222 }
799e58b9
MW
223 return (0);
224
225fail_1:
5b9f3d37
MW
226 kd->grp->ops->freesc(kd->grp, kd->k);
227 kd->grp->ops->freege(kd->grp, kd->K);
228 kd->grp->ops->freegrp(kd->grp);
799e58b9
MW
229fail_0:
230 return (-1);
231}
232
233static struct keyhalf
234 priv = { "private", kh_loadpriv },
235 pub = { "public", kh_loadpub };
410c8acf 236
237/* --- @keymoan@ --- *
238 *
56814747 239 * Arguments: @const char *file@ = name of the file
e04c2d50
MW
240 * @int line@ = line number in file
241 * @const char *msg@ = error message
4d36660a 242 * @void *p@ = argument pointer (indicates which keyring)
410c8acf 243 *
e04c2d50 244 * Returns: ---
410c8acf 245 *
e04c2d50 246 * Use: Reports an error message about loading a key file.
410c8acf 247 */
248
249static void keymoan(const char *file, int line, const char *msg, void *p)
f43df819 250{
799e58b9 251 keyhalf *kh = p;
4d36660a
MW
252
253 if (!line) {
799e58b9 254 a_warn("KEYMGMT", "%s-keyring", kh->kind, "%s", file,
4d36660a
MW
255 "io-error", "?ERRNO", A_END);
256 } else {
799e58b9 257 a_warn("KEYMGMT", "%s-keyring", kh->kind, "%s", file, "line", "%d", line,
4d36660a
MW
258 "%s", msg, A_END);
259 }
f43df819 260}
410c8acf 261
799e58b9 262/* --- @kh_reopen@ --- *
fc5f4823 263 *
799e58b9 264 * Arguments: @keyhalf *kh@ = pointer to keyhalf structure
fc5f4823 265 *
799e58b9 266 * Returns: Zero on success, @-1@ on error.
fc5f4823 267 *
799e58b9
MW
268 * Use: Reopens the key file for the appropriate key half. If this
269 * fails, everything is left as it was; if it succeeds, then the
270 * old file is closed (if it was non-null) and the new one put
271 * in its place.
fc5f4823
MW
272 */
273
799e58b9 274static int kh_reopen(keyhalf *kh)
fc5f4823 275{
799e58b9 276 key_file *kf = CREATE(key_file);
fc5f4823 277
799e58b9
MW
278 if (key_open(kf, kh->kr, KOPEN_READ, keymoan, kh)) {
279 a_warn("KEYMGMT", "%s-keyring", kh->kind, "%s", kh->kr,
7f81b1b4 280 "io-error", "?ERRNO", A_END);
799e58b9
MW
281 DESTROY(kf);
282 return (-1);
283 } else {
284 if (kh->kf) {
285 key_close(kh->kf);
286 DESTROY(kh->kf);
287 }
288 kh->kf = kf;
289 return (0);
290 }
291}
fc5f4823 292
799e58b9
MW
293/* --- @kh_init@ --- *
294 *
295 * Arguments: @keyhalf *kh@ = pointer to keyhalf structure to set up
296 * @const char *kr@ = name of the keyring file
297 *
298 * Returns: ---
299 *
300 * Use: Initialize a keyhalf structure, maintaining the private or
301 * public keys. Intended to be called during initialization:
302 * exits if there's some kind of problem.
303 */
fc5f4823 304
799e58b9
MW
305static void kh_init(keyhalf *kh, const char *kr)
306{
307 kh->kr = kr;
308 fwatch_init(&kh->w, kr);
309 sym_create(&kh->tab);
310 kh->kf = 0;
311
312 if (kh_reopen(kh))
313 die(EXIT_FAILURE, "failed to load %s keyring `%s'", kh->kind, kr);
fc5f4823
MW
314}
315
799e58b9 316/* --- @kh_load@ --- *
410c8acf 317 *
799e58b9
MW
318 * Arguments: @keyhalf *kh@ = pointer to keyhalf
319 * @const char *tag@ = key tag to be loaded
320 * @int complainp@ = whether to complain about missing keys
410c8acf 321 *
799e58b9
MW
322 * Returns: Pointer to a @kdata@ structure if successful, or null on
323 * failure.
410c8acf 324 *
799e58b9
MW
325 * Use: Attempts to load a key from the current key file. This
326 * function always reads data from the file: it's used when
327 * there's a cache miss from @kh_find@, and when refreshing the
328 * known keys in @kh_refresh@. The returned kdata has a
329 * reference count of exactly 1, and has no home knode.
410c8acf 330 */
331
799e58b9 332static kdata *kh_load(keyhalf *kh, const char *tag, int complainp)
410c8acf 333{
52c03a2a 334 dstr t = DSTR_INIT;
4d36660a 335 dstr e = DSTR_INIT;
799e58b9
MW
336 key *k;
337 key_data **d;
338 kdata *kd;
339 const char *ty;
5b9f3d37
MW
340 const dhops *dh;
341 T( const dhgrp *g; )
52c03a2a 342
799e58b9 343 /* --- Find the key and grab its tag --- */
52c03a2a 344
799e58b9
MW
345 if (key_qtag(kh->kf, tag, &t, &k, &d)) {
346 if (complainp) {
347 a_warn("KEYMGMT", "%s-keyring", kh->kind, "%s", kh->kr,
348 "key-not-found", "%s", tag, A_END);
349 }
350 goto fail_0;
52c03a2a 351 }
352
799e58b9
MW
353 /* --- Find the key's group type and the appropriate operations --- *
354 *
355 * There are several places to look for the key type. The most obvious is
356 * the `kx-group' key attribute. But there's also the key type itself, for
357 * compatibility reasons.
358 */
52c03a2a 359
799e58b9
MW
360 ty = key_getattr(kh->kf, k, "kx-group");
361 if (!ty && strncmp(k->type, "tripe-", 6) == 0) ty = k->type + 6;
362 if (!ty) ty = "dh";
52c03a2a 363
5b9f3d37
MW
364 for (dh = dhtab; dh->name; dh++)
365 if (strcmp(dh->name, ty) == 0) goto founddh;
799e58b9
MW
366 a_warn("KEYMGMT", "%s-keyring", kh->kind,
367 "%s", kh->kr, "key", "%s", t.buf,
368 "unknown-group-type", "%s", ty, A_END);
369 goto fail_0;
370
5b9f3d37 371founddh:
799e58b9 372 kd = CREATE(kdata);
5b9f3d37 373 if (kh->load(kh->kf, k, *d, dh, kd, &t, &e)) {
799e58b9 374 a_warn("KEYMGMT", "%s-keyring", kh->kind,
01d12d8f 375 "%s", kh->kr, "key", "%s", t.buf,
4d36660a 376 "*%s", e.buf, A_END);
799e58b9 377 goto fail_1;
52c03a2a 378 }
379
799e58b9 380 if (algs_get(&kd->algs, &e, kh->kf, k) ||
5b9f3d37 381 (kd->k && algs_check(&kd->algs, &e, kd->grp))) {
799e58b9
MW
382 a_warn("KEYMGMT", "%s-keyring", kh->kind,
383 "%s", kh->kr, "key", "%s", t.buf,
4d36660a 384 "*%s", e.buf, A_END);
799e58b9 385 goto fail_2;
410c8acf 386 }
52c03a2a 387
799e58b9 388 kd->tag = xstrdup(t.buf);
799e58b9
MW
389 kd->ref = 1;
390 kd->kn = 0;
391 kd->t_exp = k->exp;
52c03a2a 392
393 IF_TRACING(T_KEYMGMT, {
799e58b9 394 trace(T_KEYMGMT, "keymgmt: loaded %s key `%s'", kh->kind, t.buf);
52c03a2a 395 IF_TRACING(T_CRYPTO, {
5b9f3d37
MW
396 g = kd->grp;
397 g->ops->tracegrp(g);
398 if (kd->k)
399 trace(T_CRYPTO, "crypto: k = %s", g->ops->scstr(g, kd->k));
400 trace(T_CRYPTO, "crypto: K = %s", g->ops->gestr(g, kd->K));
c70a7c5c 401 kd->algs.bulk->ops->tracealgs(kd->algs.bulk);
52c03a2a 402 })
403 })
404
799e58b9 405 goto done;
52c03a2a 406
799e58b9 407fail_2:
5b9f3d37
MW
408 if (kd->k) kd->grp->ops->freesc(kd->grp, kd->k);
409 kd->grp->ops->freege(kd->grp, kd->K);
410 kd->grp->ops->freegrp(kd->grp);
799e58b9
MW
411fail_1:
412 DESTROY(kd);
413fail_0:
414 kd = 0;
415done:
52c03a2a 416 dstr_destroy(&t);
4d36660a 417 dstr_destroy(&e);
799e58b9 418 return (kd);
410c8acf 419}
420
799e58b9 421/* --- @kh_find@ --- *
410c8acf 422 *
799e58b9
MW
423 * Arguments: @keyhalf *kh@ = pointer to the keyhalf
424 * @const char *tag@ = key to be obtained
425 * @int complainp@ = whether to complain about missing keys
410c8acf 426 *
799e58b9 427 * Returns: A pointer to the kdata, or null on error.
410c8acf 428 *
799e58b9
MW
429 * Use: Obtains kdata, maybe from the cache. This won't update a
430 * stale cache entry, though @kh_refresh@ ought to have done
431 * that already. The returned kdata object may be shared with
432 * other users. (One of this function's responsibilities, over
433 * @kh_load@, is to set the home knode of a freshly loaded
434 * kdata.)
410c8acf 435 */
436
799e58b9 437static kdata *kh_find(keyhalf *kh, const char *tag, int complainp)
410c8acf 438{
799e58b9
MW
439 knode *kn;
440 kdata *kd;
441 unsigned f;
410c8acf 442
799e58b9
MW
443 kn = sym_find(&kh->tab, tag, -1, sizeof(knode), &f);
444
445 if (f) {
446 if (kn->f & KNF_BROKEN) {
447 T( if (complainp)
448 trace(T_KEYMGMT, "keymgmt: key `%s' marked as broken", tag); )
449 return (0);
450 }
451
452 kd = kn->kd;
453 if (kd) kd->ref++;
454 T( trace(T_KEYMGMT, "keymgmt: %scache hit for key `%s'",
455 kd ? "" : "negative ", tag); )
456 return (kd);
457 } else {
458 kd = kh_load(kh, tag, complainp);
459 kn->kd = kd;
460 kn->kh = kh;
461 kn->f = 0;
462 if (!kd)
463 kn->f |= KNF_BROKEN;
464 else {
465 kd->kn = kn;
466 kd->ref++;
467 }
468 return (kd);
410c8acf 469 }
410c8acf 470}
471
799e58b9 472/* --- @kh_refresh@ --- *
410c8acf 473 *
799e58b9 474 * Arguments: @keyhalf *kh@ = pointer to the keyhalf
410c8acf 475 *
799e58b9
MW
476 * Returns: Zero if nothing needs to be done; nonzero if peers should
477 * refresh their keys.
410c8acf 478 *
799e58b9
MW
479 * Use: Refreshes cached keys from files.
480 *
481 * Each active knode is examined to see if a new key is
482 * available: the return value is nonzero if any new keys are.
483 * A key is considered new if its algorithms, public key, or
484 * expiry time are/is different.
485 *
486 * Stub knodes (with no kdata attached) are removed, so that a
487 * later retry can succeed if the file has been fixed. (This
488 * doesn't count as a change, since no peers should be relying
489 * on a nonexistent key.)
410c8acf 490 */
491
799e58b9 492static int kh_refresh(keyhalf *kh)
410c8acf 493{
799e58b9
MW
494 knode *kn;
495 kdata *kd;
496 sym_iter i;
497 int changep = 0;
498
499 if (!fwatch_update(&kh->w, kh->kr) || kh_reopen(kh))
500 return (0);
501
502 T( trace(T_KEYMGMT, "keymgmt: rescan %s keyring `%s'", kh->kind, kh->kr); )
503 for (sym_mkiter(&i, &kh->tab); (kn = sym_next(&i)) != 0; ) {
504 if (!kn->kd) {
505 T( trace(T_KEYMGMT, "keymgmt: discard stub entry for key `%s'",
506 SYM_NAME(kn)); )
507 sym_remove(&kh->tab, kn);
508 continue;
509 }
510 if ((kd = kh_load(kh, SYM_NAME(kn), 1)) == 0) {
511 if (!(kn->f & KNF_BROKEN)) {
512 T( trace(T_KEYMGMT, "keymgmt: failed to load new key `%s': "
513 "marking it as broken",
514 SYM_NAME(kn)); )
515 kn->f |= KNF_BROKEN;
516 }
517 continue;
518 }
519 kn->f &= ~KNF_BROKEN;
520 if (kd->t_exp == kn->kd->t_exp &&
521 km_samealgsp(kd, kn->kd) &&
5b9f3d37 522 kd->grp->ops->eq(kd->grp, kd->K, kn->kd->K)) {
799e58b9
MW
523 T( trace(T_KEYMGMT, "keymgmt: key `%s' unchanged", SYM_NAME(kn)); )
524 continue;
525 }
526 T( trace(T_KEYMGMT, "keymgmt: loaded new version of key `%s'",
527 SYM_NAME(kn)); )
528 km_unref(kn->kd);
529 kd->kn = kn;
530 kn->kd = kd;
531 changep = 1;
532 }
410c8acf 533
799e58b9
MW
534 return (changep);
535}
410c8acf 536
799e58b9 537/*----- Main code ---------------------------------------------------------*/
410c8acf 538
799e58b9
MW
539const char *tag_priv;
540kdata *master;
410c8acf 541
410c8acf 542/* --- @km_init@ --- *
543 *
799e58b9
MW
544 * Arguments: @const char *privkr@ = private keyring file
545 * @const char *pubkr@ = public keyring file
546 * @const char *ptag@ = default private-key tag
410c8acf 547 *
548 * Returns: ---
549 *
799e58b9
MW
550 * Use: Initializes the key-management machinery, loading the
551 * keyrings and so on.
410c8acf 552 */
553
799e58b9 554void km_init(const char *privkr, const char *pubkr, const char *ptag)
410c8acf 555{
b5c45da1 556 const gchash *const *hh;
410c8acf 557
b5c45da1 558 for (hh = ghashtab; *hh; hh++) {
559 if ((*hh)->hashsz > MAXHASHSZ) {
560 die(EXIT_FAILURE, "INTERNAL ERROR: %s hash length %lu > MAXHASHSZ %d",
561 (*hh)->name, (unsigned long)(*hh)->hashsz, MAXHASHSZ);
562 }
563 }
564
799e58b9
MW
565 kh_init(&priv, privkr);
566 kh_init(&pub, pubkr);
567
568 tag_priv = ptag;
569 if ((master = km_findpriv(ptag)) == 0) exit(EXIT_FAILURE);
410c8acf 570}
571
799e58b9 572/* --- @km_reload@ --- *
410c8acf 573 *
799e58b9 574 * Arguments: ---
410c8acf 575 *
799e58b9 576 * Returns: Zero if OK, nonzero to force reloading of keys.
410c8acf 577 *
799e58b9 578 * Use: Checks the keyrings to see if they need reloading.
410c8acf 579 */
580
799e58b9 581int km_reload(void)
410c8acf 582{
799e58b9
MW
583 int changep = 0;
584 kdata *kd;
585
586 if (kh_refresh(&priv)) {
587 changep = 1;
588 kd = master->kn->kd;
35c8b547 589 if (kd != master) {
799e58b9
MW
590 km_unref(master);
591 km_ref(kd);
592 master = kd;
593 }
594 }
595 if (kh_refresh(&pub))
596 changep = 1;
597 return (changep);
598}
52c03a2a 599
799e58b9
MW
600/* --- @km_findpub@, @km_findpriv@ --- *
601 *
602 * Arguments: @const char *tag@ = key tag to load
603 *
604 * Returns: Pointer to the kdata object if successful, or null on error.
605 *
606 * Use: Fetches a public or private key from the keyring.
607 */
52c03a2a 608
799e58b9 609kdata *km_findpub(const char *tag) { return (kh_find(&pub, tag, 1)); }
410c8acf 610
799e58b9
MW
611kdata *km_findpriv(const char *tag)
612{
613 kdata *kd;
52c03a2a 614
799e58b9
MW
615 /* Unpleasantness for the sake of compatibility. */
616 if (!tag && (kd = kh_find(&priv, "tripe", 0)) != 0) return (kd);
617 else return (kh_find(&priv, tag ? tag : "tripe-dh", 1));
618}
52c03a2a 619
799e58b9
MW
620/* --- @km_tag@ --- *
621 *
622 * Arguments: @kdata *kd@ - pointer to the kdata object
623 *
624 * Returns: A pointer to the short tag by which the kdata was loaded.
625 */
52c03a2a 626
799e58b9 627const char *km_tag(kdata *kd) { return (SYM_NAME(kd->kn)); }
52c03a2a 628
799e58b9
MW
629/* --- @km_ref@ --- *
630 *
631 * Arguments: @kdata *kd@ = pointer to the kdata object
632 *
633 * Returns: ---
634 *
635 * Use: Claim a new reference to a kdata object.
636 */
52c03a2a 637
799e58b9 638void km_ref(kdata *kd) { kd->ref++; }
52c03a2a 639
799e58b9
MW
640/* --- @km_unref@ --- *
641 *
642 * Arguments: @kdata *kd@ = pointer to the kdata object
643 *
644 * Returns: ---
645 *
646 * Use: Releases a reference to a kdata object.
647 */
52c03a2a 648
799e58b9
MW
649void km_unref(kdata *kd)
650{
651 if (--kd->ref) return;
5b9f3d37
MW
652 if (kd->k) kd->grp->ops->freesc(kd->grp, kd->k);
653 kd->grp->ops->freege(kd->grp, kd->K);
654 kd->grp->ops->freegrp(kd->grp);
799e58b9 655 xfree(kd->tag);
5290b9d5 656 DESTROY(kd);
799e58b9
MW
657}
658
410c8acf 659/*----- That's all, folks -------------------------------------------------*/