chiark - git - mdw - catacomb/blob - progs/cc-sig.c

   1 /* -*-c-*-
   2  *
   3  * Catcrypt signatures
   4  *
   5  * (c) 2004 Straylight/Edgeware
   6  */
   7
   8 /*----- Licensing notice --------------------------------------------------*
   9  *
  10  * This file is part of Catacomb.
  11  *
  12  * Catacomb is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU Library General Public License as
  14  * published by the Free Software Foundation; either version 2 of the
  15  * License, or (at your option) any later version.
  16  *
  17  * Catacomb 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 Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public
  23  * License along with Catacomb; if not, write to the Free
  24  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25  * MA 02111-1307, USA.
  26  */
  27
  28 /*----- Header files ------------------------------------------------------*/
  29
  30 #define _FILE_OFFSET_BITS 64
  31
  32 #include <stdlib.h>
  33
  34 #include <mLib/report.h>
  35
  36 #include "rand.h"
  37 #include "sha.h"
  38 #include "has160.h"
  39
  40 #include "ec.h"
  41 #include "ec-keys.h"
  42 #include "dh.h"
  43 #include "gdsa.h"
  44 #include "gkcdsa.h"
  45 #include "rsa.h"
  46
  47 #include "cc.h"
  48
  49 /*----- Main code ---------------------------------------------------------*/
  50
  51 /* --- RSA PKCS1 --- */
  52
  53 typedef struct rsap1_sigctx {
  54   sig s;
  55   rsa_privctx rp;
  56   pkcs1 p1;
  57 } rsap1_sigctx;
  58
  59 static sig *rsap1_siginit(key *k, void *kd, const gchash *hc)
  60 {
  61   rsap1_sigctx *rs = CREATE(rsap1_sigctx);
  62   rsa_privcreate(&rs->rp, kd, &rand_global);
  63   rs->p1.r = &rand_global;
  64   rs->p1.ep = hc->name;
  65   rs->p1.epsz = strlen(hc->name) + 1;
  66   rs->s.h = 0;
  67   return (&rs->s);
  68 }
  69
  70 static int rsap1_sigdoit(sig *s, dstr *d)
  71 {
  72   rsap1_sigctx *rs = (rsap1_sigctx *)s;
  73   size_t n;
  74   mp *m = rsa_sign(&rs->rp, MP_NEW,
  75                    GH_DONE(s->h, 0), GH_CLASS(s->h)->hashsz,
  76                    pkcs1_sigencode, &rs->p1);
  77   if (!m) return (-1);
  78   n = mp_octets(rs->rp.rp->n); dstr_ensure(d, n); mp_storeb(m, d->buf, n);
  79   d->len += n; mp_drop(m);
  80   return (0);
  81 }
  82
  83 static const char *rsa_lengthcheck(mp *n)
  84 {
  85   if (mp_bits(n) < 1024) return ("key too short");
  86   return (0);
  87 }
  88
  89 static const char *rsap1_sigcheck(sig *s)
  90 {
  91   rsap1_sigctx *rs = (rsap1_sigctx *)s;
  92   const char *e;
  93   if ((e = rsa_lengthcheck(rs->rp.rp->n)) != 0) return (e);
  94   return (0);
  95 }
  96
  97 static void rsap1_sigdestroy(sig *s)
  98 {
  99   rsap1_sigctx *rs = (rsap1_sigctx *)s;
 100   rsa_privdestroy(&rs->rp);
 101   DESTROY(rs);
 102 }
 103
 104 static const sigops rsap1_sig = {
 105   rsa_privfetch, sizeof(rsa_priv),
 106   rsap1_siginit, rsap1_sigdoit, rsap1_sigcheck, rsap1_sigdestroy
 107 };
 108
 109 typedef struct rsap1_vrfctx {
 110   sig s;
 111   rsa_pubctx rp;
 112   pkcs1 p1;
 113 } rsap1_vrfctx;
 114
 115 static sig *rsap1_vrfinit(key *k, void *kd, const gchash *hc)
 116 {
 117   rsap1_vrfctx *rv = CREATE(rsap1_vrfctx);
 118   rsa_pubcreate(&rv->rp, kd);
 119   rv->p1.r = &rand_global;
 120   rv->p1.ep = hc->name;
 121   rv->p1.epsz = strlen(hc->name) + 1;
 122   rv->s.h = 0;
 123   return (&rv->s);
 124 }
 125
 126 static int rsap1_vrfdoit(sig *s, dstr *d)
 127 {
 128   rsap1_vrfctx *rv = (rsap1_vrfctx *)s;
 129   mp *m = mp_loadb(MP_NEW, d->buf, d->len);
 130   int rc = rsa_verify(&rv->rp, m,
 131                       GH_DONE(s->h, 0), GH_CLASS(s->h)->hashsz,
 132                       0, pkcs1_sigdecode, &rv->p1);
 133   mp_drop(m);
 134   return (rc);
 135 }
 136
 137 static const char *rsap1_vrfcheck(sig *s)
 138 {
 139   rsap1_vrfctx *rv = (rsap1_vrfctx *)s;
 140   const char *e;
 141   if ((e = rsa_lengthcheck(rv->rp.rp->n)) != 0) return (e);
 142   return (0);
 143 }
 144
 145 static void rsap1_vrfdestroy(sig *s)
 146 {
 147   rsap1_vrfctx *rv = (rsap1_vrfctx *)s;
 148   rsa_pubdestroy(&rv->rp);
 149   DESTROY(rv);
 150 }
 151
 152 static const sigops rsap1_vrf = {
 153   rsa_pubfetch, sizeof(rsa_pub),
 154   rsap1_vrfinit, rsap1_vrfdoit, rsap1_vrfcheck, rsap1_vrfdestroy
 155 };
 156
 157 /* --- RSA PSS --- */
 158
 159 static const gccipher *getmgf(key *k, const gchash *hc)
 160 {
 161   dstr d = DSTR_INIT;
 162   const gccipher *gc;
 163   const char *mm;
 164
 165   if ((mm = key_getattr(0, k, "mgf")) == 0) {
 166     dstr_putf(&d, "%s-mgf", hc->name);
 167     mm = d.buf;
 168   }
 169   if ((gc = gcipher_byname(mm)) == 0)
 170     die(EXIT_FAILURE, "unknown encryption scheme `%s'", mm);
 171   dstr_destroy(&d);
 172   return (gc);
 173 }
 174
 175 typedef struct rsapss_sigctx {
 176   sig s;
 177   rsa_privctx rp;
 178   pss p;
 179 } rsapss_sigctx;
 180
 181 static sig *rsapss_siginit(key *k, void *kd, const gchash *hc)
 182 {
 183   rsapss_sigctx *rs = CREATE(rsapss_sigctx);
 184   rsa_privcreate(&rs->rp, kd, &rand_global);
 185   rs->p.r = &rand_global;
 186   rs->p.cc = getmgf(k, hc);
 187   rs->p.ch = hc;
 188   rs->p.ssz = hc->hashsz;
 189   return (&rs->s);
 190 }
 191
 192 static int rsapss_sigdoit(sig *s, dstr *d)
 193 {
 194   rsapss_sigctx *rs = (rsapss_sigctx *)s;
 195   size_t n;
 196   mp *m = rsa_sign(&rs->rp, MP_NEW,
 197                    GH_DONE(s->h, 0), GH_CLASS(s->h)->hashsz,
 198                    pss_encode, &rs->p);
 199   if (!m) return (-1);
 200   n = mp_octets(rs->rp.rp->n); dstr_ensure(d, n); mp_storeb(m, d->buf, n);
 201   d->len += n;  mp_drop(m);
 202   return (0);
 203 }
 204
 205 static const char *rsapss_sigcheck(sig *s)
 206 {
 207   rsapss_sigctx *rs = (rsapss_sigctx *)s;
 208   const char *e;
 209   if ((e = rsa_lengthcheck(rs->rp.rp->n)) != 0) return (e);
 210   return (0);
 211 }
 212
 213 static void rsapss_sigdestroy(sig *s)
 214 {
 215   rsapss_sigctx *rs = (rsapss_sigctx *)s;
 216   rsa_privdestroy(&rs->rp);
 217   DESTROY(rs);
 218 }
 219
 220 static const sigops rsapss_sig = {
 221   rsa_privfetch, sizeof(rsa_priv),
 222   rsapss_siginit, rsapss_sigdoit, rsapss_sigcheck, rsapss_sigdestroy
 223 };
 224
 225 typedef struct rsapss_vrfctx {
 226   sig s;
 227   rsa_pubctx rp;
 228   pss p;
 229 } rsapss_vrfctx;
 230
 231 static sig *rsapss_vrfinit(key *k, void *kd, const gchash *hc)
 232 {
 233   rsapss_vrfctx *rv = CREATE(rsapss_vrfctx);
 234   rsa_pubcreate(&rv->rp, kd);
 235   rv->p.r = &rand_global;
 236   rv->p.cc = getmgf(k, hc);
 237   rv->p.ch = hc;
 238   rv->p.ssz = hc->hashsz;
 239   return (&rv->s);
 240 }
 241
 242 static int rsapss_vrfdoit(sig *s, dstr *d)
 243 {
 244   rsapss_vrfctx *rv = (rsapss_vrfctx *)s;
 245   mp *m = mp_loadb(MP_NEW, d->buf, d->len);
 246   int rc = rsa_verify(&rv->rp, m,
 247                       GH_DONE(s->h, 0), GH_CLASS(s->h)->hashsz,
 248                       0, pss_decode, &rv->p);
 249   mp_drop(m);
 250   return (rc);
 251 }
 252
 253 static const char *rsapss_vrfcheck(sig *s)
 254 {
 255   rsapss_vrfctx *rv = (rsapss_vrfctx *)s;
 256   const char *e;
 257   if ((e = rsa_lengthcheck(rv->rp.rp->n)) != 0) return (e);
 258   return (0);
 259 }
 260
 261 static void rsapss_vrfdestroy(sig *s)
 262 {
 263   rsapss_vrfctx *rv = (rsapss_vrfctx *)s;
 264   rsa_pubdestroy(&rv->rp);
 265   DESTROY(rv);
 266 }
 267
 268 static const sigops rsapss_vrf = {
 269   rsa_pubfetch, sizeof(rsa_pub),
 270   rsapss_vrfinit, rsapss_vrfdoit, rsapss_vrfcheck, rsapss_vrfdestroy
 271 };
 272
 273 /* --- DSA and ECDSA --- */
 274
 275 typedef struct dsa_sigctx {
 276   sig s;
 277   gdsa g;
 278 } dsa_sigctx;
 279
 280 static void dsa_initcommon(dsa_sigctx *ds, const gchash *hc,
 281                            const char *ktag)
 282 {
 283   ds->g.r = &rand_global;
 284   ds->g.h = hc;
 285   ds->g.u = MP_NEW;
 286   ds->s.h = 0;
 287 }
 288
 289 static dsa_sigctx *dsa_doinit(key *k, const gprime_param *gp,
 290                               mp *y, const gchash *hc,
 291                               group *(*makegroup)(const gprime_param *),
 292                               const char *what)
 293 {
 294   dsa_sigctx *ds = CREATE(dsa_sigctx);
 295   dstr t = DSTR_INIT;
 296
 297   key_fulltag(k, &t);
 298   if ((ds->g.g = makegroup(gp)) == 0)
 299     die(EXIT_FAILURE, "bad %s group in key `%s'", what, t.buf);
 300   ds->g.p = G_CREATE(ds->g.g);
 301   if (G_FROMINT(ds->g.g, ds->g.p, y))
 302     die(EXIT_FAILURE, "bad public key in key `%s'", t.buf);
 303   dsa_initcommon(ds, hc, t.buf);
 304   dstr_destroy(&t);
 305   return (ds);
 306 }
 307
 308 static dsa_sigctx *ecdsa_doinit(key *k, const char *cstr,
 309                                 ec *y, const gchash *hc)
 310 {
 311   dsa_sigctx *ds = CREATE(dsa_sigctx);
 312   ec_info ei;
 313   const char *e;
 314   dstr t = DSTR_INIT;
 315
 316   key_fulltag(k, &t);
 317   if ((e = ec_getinfo(&ei, cstr)) != 0)
 318     die(EXIT_FAILURE, "bad curve in key `%s': %s", t.buf, e);
 319   ds->g.g = group_ec(&ei);
 320   ds->g.p = G_CREATE(ds->g.g);
 321   if (G_FROMEC(ds->g.g, ds->g.p, y))
 322     die(EXIT_FAILURE, "bad public key in key `%s'", t.buf);
 323   dsa_initcommon(ds, hc, t.buf);
 324   dstr_destroy(&t);
 325   return (ds);
 326 }
 327
 328 static sig *dsa_siginit(key *k, void *kd, const gchash *hc)
 329 {
 330   dh_priv *dp = kd;
 331   dsa_sigctx *ds = dsa_doinit(k, &dp->dp, dp->y, hc, group_prime, "prime");
 332   ds->g.u = MP_COPY(dp->x);
 333   return (&ds->s);
 334 }
 335
 336 static sig *bindsa_siginit(key *k, void *kd, const gchash *hc)
 337 {
 338   dh_priv *dp = kd;
 339   dsa_sigctx *ds = dsa_doinit(k, &dp->dp, dp->y, hc, group_binary, "binary");
 340   ds->g.u = MP_COPY(dp->x);
 341   return (&ds->s);
 342 }
 343
 344 static sig *ecdsa_siginit(key *k, void *kd, const gchash *hc)
 345 {
 346   ec_priv *ep = kd;
 347   dsa_sigctx *ds = ecdsa_doinit(k, ep->cstr, &ep->p, hc);
 348   ds->g.u = MP_COPY(ep->x);
 349   return (&ds->s);
 350 }
 351
 352 static int dsa_sigdoit(sig *s, dstr *d)
 353 {
 354   dsa_sigctx *ds = (dsa_sigctx *)s;
 355   gdsa_sig ss = GDSA_SIG_INIT;
 356   size_t n = mp_octets(ds->g.g->r);
 357
 358   gdsa_sign(&ds->g, &ss, GH_DONE(ds->s.h, 0), 0);
 359   dstr_ensure(d, 2 * n);
 360   mp_storeb(ss.r, d->buf, n);
 361   mp_storeb(ss.s, d->buf + n, n);
 362   d->len += 2 * n;
 363   mp_drop(ss.r); mp_drop(ss.s);
 364   return (0);
 365 }
 366
 367 static const char *dsa_sigcheck(sig *s)
 368 {
 369   dsa_sigctx *ds = (dsa_sigctx *)s;
 370   const char *e;
 371   if ((e = G_CHECK(ds->g.g, &rand_global)) != 0)
 372     return (0);
 373   if (group_check(ds->g.g, ds->g.p))
 374     return ("public key not in subgroup");
 375   return (0);
 376 }
 377
 378 static void dsa_sigdestroy(sig *s)
 379 {
 380   dsa_sigctx *ds = (dsa_sigctx *)s;
 381   G_DESTROY(ds->g.g, ds->g.p);
 382   mp_drop(ds->g.u);
 383   G_DESTROYGROUP(ds->g.g);
 384   DESTROY(ds);
 385 }
 386
 387 static const sigops dsa_sig = {
 388   dh_privfetch, sizeof(dh_priv),
 389   dsa_siginit, dsa_sigdoit, dsa_sigcheck, dsa_sigdestroy
 390 };
 391
 392 static const sigops bindsa_sig = {
 393   dh_privfetch, sizeof(dh_priv),
 394   bindsa_siginit, dsa_sigdoit, dsa_sigcheck, dsa_sigdestroy
 395 };
 396
 397 static const sigops ecdsa_sig = {
 398   ec_privfetch, sizeof(ec_priv),
 399   ecdsa_siginit, dsa_sigdoit, dsa_sigcheck, dsa_sigdestroy
 400 };
 401
 402 static sig *dsa_vrfinit(key *k, void *kd, const gchash *hc)
 403 {
 404   dh_pub *dp = kd;
 405   dsa_sigctx *ds = dsa_doinit(k, &dp->dp, dp->y, hc, group_prime, "prime");
 406   return (&ds->s);
 407 }
 408
 409 static sig *bindsa_vrfinit(key *k, void *kd, const gchash *hc)
 410 {
 411   dh_pub *dp = kd;
 412   dsa_sigctx *ds = dsa_doinit(k, &dp->dp, dp->y, hc, group_binary, "binary");
 413   return (&ds->s);
 414 }
 415
 416 static sig *ecdsa_vrfinit(key *k, void *kd, const gchash *hc)
 417 {
 418   ec_pub *ep = kd;
 419   dsa_sigctx *ds = ecdsa_doinit(k, ep->cstr, &ep->p, hc);
 420   return (&ds->s);
 421 }
 422
 423 static int dsa_vrfdoit(sig *s, dstr *d)
 424 {
 425   dsa_sigctx *ds = (dsa_sigctx *)s;
 426   gdsa_sig ss;
 427   size_t n = d->len/2;
 428   int rc;
 429
 430   ss.r = mp_loadb(MP_NEW, d->buf, n);
 431   ss.s = mp_loadb(MP_NEW, d->buf + n, d->len - n);
 432   rc = gdsa_verify(&ds->g, &ss, GH_DONE(ds->s.h, 0));
 433   mp_drop(ss.r); mp_drop(ss.s);
 434   return (rc);
 435 }
 436
 437 static const sigops dsa_vrf = {
 438   dh_pubfetch, sizeof(dh_pub),
 439   dsa_vrfinit, dsa_vrfdoit, dsa_sigcheck, dsa_sigdestroy
 440 };
 441
 442 static const sigops bindsa_vrf = {
 443   dh_pubfetch, sizeof(dh_pub),
 444   bindsa_vrfinit, dsa_vrfdoit, dsa_sigcheck, dsa_sigdestroy
 445 };
 446
 447 static const sigops ecdsa_vrf = {
 448   ec_pubfetch, sizeof(ec_pub),
 449   ecdsa_vrfinit, dsa_vrfdoit, dsa_sigcheck, dsa_sigdestroy
 450 };
 451
 452 /* --- KCDSA and ECKCDSA --- */
 453
 454 static void kcdsa_privkey(dsa_sigctx *ds, mp *x)
 455   { ds->g.u = mp_modinv(MP_NEW, x, ds->g.g->r); }
 456
 457 static void kcdsa_sethash(dsa_sigctx *ds, const gchash *hc)
 458   { ds->s.h = gkcdsa_beginhash(&ds->g); }
 459
 460 static sig *kcdsa_siginit(key *k, void *kd, const gchash *hc)
 461 {
 462   dh_priv *dp = kd;
 463   dsa_sigctx *ds = dsa_doinit(k, &dp->dp, dp->y, hc, group_prime, "prime");
 464   kcdsa_privkey(ds, dp->x);
 465   kcdsa_sethash(ds, hc);
 466   return (&ds->s);
 467 }
 468
 469 static sig *binkcdsa_siginit(key *k, void *kd, const gchash *hc)
 470 {
 471   dh_priv *dp = kd;
 472   dsa_sigctx *ds = dsa_doinit(k, &dp->dp, dp->y, hc, group_binary, "binary");
 473   kcdsa_privkey(ds, dp->x);
 474   kcdsa_sethash(ds, hc);
 475   return (&ds->s);
 476 }
 477
 478 static sig *eckcdsa_siginit(key *k, void *kd, const gchash *hc)
 479 {
 480   ec_priv *ep = kd;
 481   dsa_sigctx *ds = ecdsa_doinit(k, ep->cstr, &ep->p, hc);
 482   kcdsa_privkey(ds, ep->x);
 483   kcdsa_sethash(ds, hc);
 484   return (&ds->s);
 485 }
 486
 487 static int kcdsa_sigdoit(sig *s, dstr *d)
 488 {
 489   dsa_sigctx *ds = (dsa_sigctx *)s;
 490   gkcdsa_sig ss = GKCDSA_SIG_INIT;
 491   size_t hsz = ds->g.h->hashsz, n = mp_octets(ds->g.g->r);
 492
 493   gkcdsa_sign(&ds->g, &ss, GH_DONE(ds->s.h, 0), 0);
 494   dstr_ensure(d, hsz + n);
 495   memcpy(d->buf, ss.r, hsz);
 496   mp_storeb(ss.s, d->buf + hsz, n);
 497   d->len += hsz + n;
 498   xfree(ss.r); mp_drop(ss.s);
 499   return (0);
 500 }
 501
 502 static const sigops kcdsa_sig = {
 503   dh_privfetch, sizeof(dh_priv),
 504   kcdsa_siginit, kcdsa_sigdoit, dsa_sigcheck, dsa_sigdestroy
 505 };
 506
 507 static const sigops binkcdsa_sig = {
 508   dh_privfetch, sizeof(dh_priv),
 509   binkcdsa_siginit, kcdsa_sigdoit, dsa_sigcheck, dsa_sigdestroy
 510 };
 511
 512 static const sigops eckcdsa_sig = {
 513   ec_privfetch, sizeof(ec_priv),
 514   eckcdsa_siginit, kcdsa_sigdoit, dsa_sigcheck, dsa_sigdestroy
 515 };
 516
 517 static sig *kcdsa_vrfinit(key *k, void *kd, const gchash *hc)
 518 {
 519   dh_pub *dp = kd;
 520   dsa_sigctx *ds = dsa_doinit(k, &dp->dp, dp->y, hc, group_prime, "prime");
 521   kcdsa_sethash(ds, hc);
 522   return (&ds->s);
 523 }
 524
 525 static sig *binkcdsa_vrfinit(key *k, void *kd, const gchash *hc)
 526 {
 527   dh_pub *dp = kd;
 528   dsa_sigctx *ds = dsa_doinit(k, &dp->dp, dp->y, hc, group_binary, "binary");
 529   kcdsa_sethash(ds, hc);
 530   return (&ds->s);
 531 }
 532
 533 static sig *eckcdsa_vrfinit(key *k, void *kd, const gchash *hc)
 534 {
 535   ec_pub *ep = kd;
 536   dsa_sigctx *ds = ecdsa_doinit(k, ep->cstr, &ep->p, hc);
 537   kcdsa_sethash(ds, hc);
 538   return (&ds->s);
 539 }
 540
 541 static int kcdsa_vrfdoit(sig *s, dstr *d)
 542 {
 543   dsa_sigctx *ds = (dsa_sigctx *)s;
 544   gkcdsa_sig ss;
 545   size_t hsz = ds->g.h->hashsz, n = d->len - hsz;
 546   int rc;
 547
 548   if (d->len < hsz)
 549     return (-1);
 550   ss.r = (octet *)d->buf;
 551   ss.s = mp_loadb(MP_NEW, d->buf + hsz, n);
 552   rc = gkcdsa_verify(&ds->g, &ss, GH_DONE(ds->s.h, 0));
 553   mp_drop(ss.s);
 554   return (rc);
 555 }
 556
 557 static const sigops kcdsa_vrf = {
 558   dh_pubfetch, sizeof(dh_pub),
 559   kcdsa_vrfinit, kcdsa_vrfdoit, dsa_sigcheck, dsa_sigdestroy
 560 };
 561
 562 static const sigops binkcdsa_vrf = {
 563   dh_pubfetch, sizeof(dh_pub),
 564   binkcdsa_vrfinit, kcdsa_vrfdoit, dsa_sigcheck, dsa_sigdestroy
 565 };
 566
 567 static const sigops eckcdsa_vrf = {
 568   ec_pubfetch, sizeof(ec_pub),
 569   eckcdsa_vrfinit, kcdsa_vrfdoit, dsa_sigcheck, dsa_sigdestroy
 570 };
 571
 572 /* --- Symmetric message authentication --- */
 573
 574 typedef struct mac_ctx {
 575   sig s;
 576   const gcmac *mc;
 577   gmac *m;
 578   key_packdef kp;
 579   key_bin kb;
 580 } mac_ctx;
 581
 582 static sig *mac_init(key *k, void *kd, const gchash *hc)
 583 {
 584   mac_ctx *m;
 585   dstr d = DSTR_INIT;
 586   int err;
 587   const char *mm;
 588
 589   m = CREATE(mac_ctx);
 590
 591   key_fulltag(k, &d);
 592   m->kp.e = KENC_BINARY;
 593   m->kp.p = &m->kb;
 594   m->kp.kd = 0;
 595
 596   if ((mm = key_getattr(0 /*yik*/, k, "mac")) == 0) {
 597     dstr_putf(&d, "%s-hmac", hc->name);
 598     mm = d.buf;
 599   }
 600   if ((m->mc = gmac_byname(mm)) == 0)
 601     die(EXIT_FAILURE, "unknown message authentication scheme `%s'", mm);
 602   dstr_reset(&d);
 603
 604   if ((err = key_unpack(&m->kp, kd, &d)) != 0) {
 605     die(EXIT_FAILURE, "failed to unpack symmetric key `%s': %s",
 606         d.buf, key_strerror(err));
 607   }
 608   dstr_destroy(&d);
 609
 610   if (keysz(m->kb.sz, m->mc->keysz) != m->kb.sz) {
 611     die(EXIT_FAILURE, "bad key size %lu for `%s'",
 612         (unsigned long)m->kb.sz, m->mc->name);
 613   }
 614   m->m = GM_KEY(m->mc, m->kb.k, m->kb.sz);
 615   m->s.h = GM_INIT(m->m);
 616   return (&m->s);
 617 }
 618
 619 static int mac_sigdoit(sig *s, dstr *d)
 620 {
 621   mac_ctx *m = (mac_ctx *)s;
 622
 623   dstr_ensure(d, m->mc->hashsz);
 624   GH_DONE(m->s.h, d->buf);
 625   d->len += m->mc->hashsz;
 626   return (0);
 627 }
 628
 629 static int mac_vrfdoit(sig *s, dstr *d)
 630 {
 631   mac_ctx *m = (mac_ctx *)s;
 632   const octet *t;
 633
 634   t = GH_DONE(m->s.h, 0);
 635   if (d->len != m->mc->hashsz || memcmp(d->buf, t, d->len) != 0)
 636     return (-1);
 637   return (0);
 638 }
 639
 640 static const char *mac_check(sig *s) { return (0); }
 641
 642 static void mac_destroy(sig *s)
 643 {
 644   mac_ctx *m = (mac_ctx *)s;
 645   GM_DESTROY(m->m);
 646   key_unpackdone(&m->kp);
 647 }
 648
 649 static const sigops mac_sig = {
 650   0, 0,
 651   mac_init, mac_sigdoit, mac_check, mac_destroy
 652 };
 653
 654 static const sigops mac_vrf = {
 655   0, 0,
 656   mac_init, mac_vrfdoit, mac_check, mac_destroy
 657 };
 658
 659 /* --- The switch table --- */
 660
 661 const struct sigtab sigtab[] = {
 662   { "rsapkcs1", &rsap1_sig,     &rsap1_vrf,     &sha },
 663   { "rsapss",   &rsapss_sig,    &rsapss_vrf,    &sha },
 664   { "dsa",      &dsa_sig,       &dsa_vrf,       &sha },
 665   { "bindsa",   &bindsa_sig,    &bindsa_vrf,    &sha },
 666   { "ecdsa",    &ecdsa_sig,     &ecdsa_vrf,     &sha },
 667   { "kcdsa",    &kcdsa_sig,     &kcdsa_vrf,     &has160 },
 668   { "binkcdsa", &binkcdsa_sig,  &binkcdsa_vrf,  &has160 },
 669   { "eckcdsa",  &eckcdsa_sig,   &eckcdsa_vrf,   &has160 },
 670   { "mac",      &mac_sig,       &mac_vrf,       &rmd160 },
 671   { 0,          0,              0 }
 672 };
 673
 674 /* --- @getsig@ --- *
 675  *
 676  * Arguments:   @key *k@ = the key to load
 677  *              @const char *app@ = application name
 678  *              @int wantpriv@ = nonzero if we want to sign
 679  *
 680  * Returns:     A signature-making thing.
 681  *
 682  * Use:         Loads a key and starts hashing.
 683  */
 684
 685 sig *getsig(key *k, const char *app, int wantpriv)
 686 {
 687   const char *salg, *halg = 0;
 688   dstr d = DSTR_INIT;
 689   dstr t = DSTR_INIT;
 690   char *p = 0;
 691   const char *q;
 692   sig *s;
 693   size_t n;
 694   const struct sigtab *st;
 695   const sigops *so;
 696   const gchash *ch;
 697   void *kd;
 698   int e;
 699   key_packdef *kp;
 700
 701   /* --- Setup stuff --- */
 702
 703   key_fulltag(k, &t);
 704
 705   /* --- Get the signature algorithm --- *
 706    *
 707    * Take the attribute if it's there; otherwise use the key type.
 708    */
 709
 710   n = strlen(app);
 711   if ((q = key_getattr(0, k, "sig")) != 0) {
 712     dstr_puts(&d, q);
 713     p = d.buf;
 714   } else if (strncmp(k->type, app, n) == 0 && k->type[n] == '-') {
 715     dstr_puts(&d, k->type);
 716     p = d.buf + n + 1;
 717   } else
 718     die(EXIT_FAILURE, "no signature algorithm for key `%s'", t.buf);
 719
 720   /* --- Grab the hash algorithm --- *
 721    *
 722    * Grab it from the signature algorithm if it's there.  But override that
 723    * from the attribute.
 724    */
 725
 726   salg = p;
 727   if ((p = strchr(p, '/')) != 0) {
 728     *p++ = 0;
 729     halg = p;
 730   }
 731   if ((q = key_getattr(0, k, "hash")) != 0)
 732     halg = q;
 733
 734   /* --- Look up the algorithms in the table --- */
 735
 736   for (st = sigtab; st->name; st++) {
 737     if (strcmp(st->name, salg) == 0)
 738       goto s_found;
 739   }
 740   die(EXIT_FAILURE, "signature algorithm `%s' not found in key `%s'",
 741       salg, t.buf);
 742 s_found:;
 743   if (!halg)
 744     ch = st->ch;
 745   else {
 746     if ((ch = ghash_byname(halg)) == 0) {
 747       die(EXIT_FAILURE, "hash algorithm `%s' not found in key `%s'",
 748           halg, t.buf);
 749     }
 750   }
 751   so = wantpriv ? st->signops : st->verifyops;
 752
 753   /* --- Load the key --- */
 754
 755   if (!so->kf) {
 756     kd = k->k;
 757     key_incref(kd);
 758     kp = 0;
 759   } else {
 760     kd = xmalloc(so->kdsz);
 761     kp = key_fetchinit(so->kf, 0, kd);
 762     if ((e = key_fetch(kp, k)) != 0) {
 763       die(EXIT_FAILURE, "error fetching key `%s': %s",
 764           t.buf, key_strerror(e));
 765     }
 766   }
 767   s = so->init(k, kd, ch);
 768   if (!s->h)
 769     s->h = GH_INIT(ch);
 770   s->kp = kp;
 771   s->ops = so;
 772   s->kd = kd;
 773   s->ch = ch;
 774
 775   /* --- Free stuff up --- */
 776
 777   dstr_destroy(&d);
 778   dstr_destroy(&t);
 779   return (s);
 780 }
 781
 782 /* --- @freesig@ --- *
 783  *
 784  * Arguments:   @sig *s@ = signature-making thing
 785  *
 786  * Returns:     ---
 787  *
 788  * Use:         Frees up a signature-making thing
 789  */
 790
 791 void freesig(sig *s)
 792 {
 793   GH_DESTROY(s->h);
 794   if (!s->ops->kf)
 795     key_drop(s->kd);
 796   else {
 797     key_fetchdone(s->kp);
 798     xfree(s->kd);
 799   }
 800   s->ops->destroy(s);
 801 }
 802
 803 /*----- That's all, folks -------------------------------------------------*/