chiark - git - mdw - catacomb/blob - cc-kem.c

   1 /* -*-c-*-
   2  *
   3  * $Id$
   4  *
   5  * Catcrypt key-encapsulation
   6  *
   7  * (c) 2004 Straylight/Edgeware
   8  */
   9
  10 /*----- Licensing notice --------------------------------------------------*
  11  *
  12  * This file is part of Catacomb.
  13  *
  14  * Catacomb is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU Library General Public License as
  16  * published by the Free Software Foundation; either version 2 of the
  17  * License, or (at your option) any later version.
  18  *
  19  * Catacomb is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Library General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Library General Public
  25  * License along with Catacomb; if not, write to the Free
  26  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  27  * MA 02111-1307, USA.
  28  */
  29
  30 /*----- Header files ------------------------------------------------------*/
  31
  32 #include <stdlib.h>
  33
  34 #include <mLib/alloc.h>
  35 #include <mLib/dstr.h>
  36 #include <mLib/report.h>
  37 #include <mLib/sub.h>
  38
  39 #include "mprand.h"
  40 #include "rand.h"
  41
  42 #include "ec.h"
  43 #include "ec-keys.h"
  44 #include "dh.h"
  45 #include "rsa.h"
  46
  47 #include "rmd160.h"
  48 #include "blowfish-cbc.h"
  49
  50 #include "cc.h"
  51
  52 /*----- Key encapsulation -------------------------------------------------*/
  53
  54 /* --- RSA --- */
  55
  56 typedef struct rsa_encctx {
  57   kem k;
  58   rsa_pubctx rp;
  59 } rsa_encctx;
  60
  61 static kem *rsa_encinit(key *k, void *kd)
  62 {
  63   rsa_encctx *re = CREATE(rsa_encctx);
  64   rsa_pubcreate(&re->rp, kd);
  65   return (&re->k);
  66 }
  67
  68 static int rsa_encdoit(kem *k, dstr *d, ghash *h)
  69 {
  70   rsa_encctx *re = (rsa_encctx *)k;
  71   mp *x = mprand_range(MP_NEW, re->rp.rp->n, &rand_global, 0);
  72   mp *y = rsa_pubop(&re->rp, MP_NEW, x);
  73   size_t n = mp_octets(re->rp.rp->n);
  74   dstr_ensure(d, n);
  75   mp_storeb(x, d->buf, n);
  76   GH_HASH(h, d->buf, n);
  77   mp_storeb(y, d->buf, n);
  78   d->len += n;
  79   mp_drop(x);
  80   mp_drop(y);
  81   return (0);
  82 }
  83
  84 static const char *rsa_lengthcheck(mp *n)
  85 {
  86   if (mp_bits(n) < 1020) return ("key too short");
  87   return (0);
  88 }
  89
  90 static const char *rsa_enccheck(kem *k)
  91 {
  92   rsa_encctx *re = (rsa_encctx *)k;
  93   const char *e;
  94   if ((e = rsa_lengthcheck(re->rp.rp->n)) != 0) return (e);
  95   return (0);
  96 }
  97
  98 static void rsa_encdestroy(kem *k)
  99 {
 100   rsa_encctx *re = (rsa_encctx *)k;
 101   rsa_pubdestroy(&re->rp);
 102   DESTROY(re);
 103 }
 104
 105 static const kemops rsa_encops = {
 106   rsa_pubfetch, sizeof(rsa_pub),
 107   rsa_encinit, rsa_encdoit, rsa_enccheck, rsa_encdestroy
 108 };
 109
 110 typedef struct rsa_decctx {
 111   kem k;
 112   rsa_privctx rp;
 113 } rsa_decctx;
 114
 115 static kem *rsa_decinit(key *k, void *kd)
 116 {
 117   rsa_decctx *rd = CREATE(rsa_decctx);
 118   rsa_privcreate(&rd->rp, kd, &rand_global);
 119   return (&rd->k);
 120 }
 121
 122 static int rsa_decdoit(kem *k, dstr *d, ghash *h)
 123 {
 124   rsa_decctx *rd = (rsa_decctx *)k;
 125   mp *x = mp_loadb(MP_NEW, d->buf, d->len);
 126   size_t n;
 127   char *p;
 128
 129   if (MP_CMP(x, >=, rd->rp.rp->n)) {
 130     mp_drop(x);
 131     return (-1);
 132   }
 133   n = mp_octets(rd->rp.rp->n);
 134   p = xmalloc(n);
 135   x = rsa_privop(&rd->rp, x, x);
 136   mp_storeb(x, p, n);
 137   GH_HASH(h, p, n);
 138   mp_drop(x);
 139   xfree(p);
 140   return (0);
 141 }
 142
 143 static const char *rsa_deccheck(kem *k)
 144 {
 145   rsa_decctx *rd = (rsa_decctx *)k;
 146   const char *e;
 147   if ((e = rsa_lengthcheck(rd->rp.rp->n)) != 0) return (e);
 148   return (0);
 149 }
 150
 151 static void rsa_decdestroy(kem *k)
 152 {
 153   rsa_decctx *rd = (rsa_decctx *)k;
 154   rsa_privdestroy(&rd->rp);
 155   DESTROY(rd);
 156 }
 157
 158 static const kemops rsa_decops = {
 159   rsa_privfetch, sizeof(rsa_priv),
 160   rsa_decinit, rsa_decdoit, rsa_deccheck, rsa_decdestroy
 161 };
 162
 163 /* --- DH and EC --- */
 164
 165 typedef struct dh_encctx {
 166   kem k;
 167   group *g;
 168   mp *x;
 169   ge *y;
 170 } dh_encctx;
 171
 172 static dh_encctx *dh_doinit(key *k, const gprime_param *gp, mp *y,
 173                             group *(*makegroup)(const gprime_param *),
 174                             const char *what)
 175 {
 176   dh_encctx *de = CREATE(dh_encctx);
 177   dstr t = DSTR_INIT;
 178
 179   key_fulltag(k, &t);
 180   if ((de->g = makegroup(gp)) == 0)
 181     die(EXIT_FAILURE, "bad %s group in key `%s'", what, t.buf);
 182   de->x = MP_NEW;
 183   de->y = G_CREATE(de->g);
 184   if (G_FROMINT(de->g, de->y, y))
 185     die(EXIT_FAILURE, "bad public key `%s'", t.buf);
 186   dstr_destroy(&t);
 187   return (de);
 188 }
 189
 190 static dh_encctx *ec_doinit(key *k, const char *cstr, const ec *y)
 191 {
 192   dh_encctx *de = CREATE(dh_encctx);
 193   ec_info ei;
 194   const char *e;
 195   dstr t = DSTR_INIT;
 196
 197   key_fulltag(k, &t);
 198   if ((e = ec_getinfo(&ei, cstr)) != 0 ||
 199       (de->g = group_ec(&ei)) == 0)
 200     die(EXIT_FAILURE, "bad elliptic curve spec in key `%s': %s", t.buf, e);
 201   de->x = MP_NEW;
 202   de->y = G_CREATE(de->g);
 203   if (G_FROMEC(de->g, de->y, y))
 204     die(EXIT_FAILURE, "bad public curve point `%s'", t.buf);
 205   dstr_destroy(&t);
 206   return (de);
 207 }
 208
 209 static kem *dh_encinit(key *k, void *kd)
 210 {
 211   dh_pub *dp = kd;
 212   dh_encctx *de = dh_doinit(k, &dp->dp, dp->y, group_prime, "prime");
 213   return (&de->k);
 214 }
 215
 216 static kem *bindh_encinit(key *k, void *kd)
 217 {
 218   dh_pub *dp = kd;
 219   dh_encctx *de = dh_doinit(k, &dp->dp, dp->y, group_binary, "binary");
 220   return (&de->k);
 221 }
 222
 223 static kem *ec_encinit(key *k, void *kd)
 224 {
 225   ec_pub *ep = kd;
 226   dh_encctx *de = ec_doinit(k, ep->cstr, &ep->p);
 227   return (&de->k);
 228 }
 229
 230 static int dh_encdoit(kem *k, dstr *d, ghash *h)
 231 {
 232   dh_encctx *de = (dh_encctx *)k;
 233   mp *r = mprand_range(MP_NEW, de->g->r, &rand_global, 0);
 234   ge *x = G_CREATE(de->g);
 235   ge *y = G_CREATE(de->g);
 236   size_t n = de->g->noctets;
 237   buf b;
 238
 239   G_EXP(de->g, x, de->g->g, r);
 240   G_EXP(de->g, y, de->y, r);
 241   dstr_ensure(d, n);
 242   buf_init(&b, d->buf, n);
 243   G_TORAW(de->g, &b, y);
 244   GH_HASH(h, BBASE(&b), BLEN(&b));
 245   buf_init(&b, d->buf, n);
 246   G_TORAW(de->g, &b, x);
 247   GH_HASH(h, BBASE(&b), BLEN(&b));
 248   d->len += BLEN(&b);
 249   mp_drop(r);
 250   G_DESTROY(de->g, x);
 251   G_DESTROY(de->g, y);
 252   return (0);
 253 }
 254
 255 static const char *dh_enccheck(kem *k)
 256 {
 257   dh_encctx *de = (dh_encctx *)k;
 258   const char *e;
 259   if ((e = G_CHECK(de->g, &rand_global)) != 0)
 260     return (0);
 261   if (group_check(de->g, de->y))
 262     return ("public key not in subgroup");
 263   return (0);
 264 }
 265
 266 static void dh_encdestroy(kem *k)
 267 {
 268   dh_encctx *de = (dh_encctx *)k;
 269   G_DESTROY(de->g, de->y);
 270   mp_drop(de->x);
 271   G_DESTROYGROUP(de->g);
 272 }
 273
 274 static const kemops dh_encops = {
 275   dh_pubfetch, sizeof(dh_pub),
 276   dh_encinit, dh_encdoit, dh_enccheck, dh_encdestroy
 277 };
 278
 279 static const kemops bindh_encops = {
 280   dh_pubfetch, sizeof(dh_pub),
 281   bindh_encinit, dh_encdoit, dh_enccheck, dh_encdestroy
 282 };
 283
 284 static const kemops ec_encops = {
 285   ec_pubfetch, sizeof(ec_pub),
 286   ec_encinit, dh_encdoit, dh_enccheck, dh_encdestroy
 287 };
 288
 289 static kem *dh_decinit(key *k, void *kd)
 290 {
 291   dh_priv *dp = kd;
 292   dh_encctx *de = dh_doinit(k, &dp->dp, dp->y, group_prime, "prime");
 293   de->x = MP_COPY(dp->x);
 294   return (&de->k);
 295 }
 296
 297 static kem *bindh_decinit(key *k, void *kd)
 298 {
 299   dh_priv *dp = kd;
 300   dh_encctx *de = dh_doinit(k, &dp->dp, dp->y, group_binary, "binary");
 301   de->x = MP_COPY(dp->x);
 302   return (&de->k);
 303 }
 304
 305 static kem *ec_decinit(key *k, void *kd)
 306 {
 307   ec_priv *ep = kd;
 308   dh_encctx *de = ec_doinit(k, ep->cstr, &ep->p);
 309   de->x = MP_COPY(ep->x);
 310   return (&de->k);
 311 }
 312
 313 static int dh_decdoit(kem *k, dstr *d, ghash *h)
 314 {
 315   dh_encctx *de = (dh_encctx *)k;
 316   ge *x = G_CREATE(de->g);
 317   size_t n = de->g->noctets;
 318   void *p = xmalloc(n);
 319   buf b;
 320   int rc = -1;
 321
 322   buf_init(&b, d->buf, d->len);
 323   if (G_FROMRAW(de->g, &b, x) || group_check(de->g, x))
 324     goto done;
 325   G_EXP(de->g, x, x, de->x);
 326   buf_init(&b, p, n);
 327   G_TORAW(de->g, &b, x);
 328   GH_HASH(h, BBASE(&b), BLEN(&b));
 329   GH_HASH(h, d->buf, d->len);
 330   rc = 0;
 331 done:
 332   G_DESTROY(de->g, x);
 333   xfree(p);
 334   return (rc);
 335 }
 336
 337 static const kemops dh_decops = {
 338   dh_privfetch, sizeof(dh_priv),
 339   dh_decinit, dh_decdoit, dh_enccheck, dh_encdestroy
 340 };
 341
 342 static const kemops bindh_decops = {
 343   dh_privfetch, sizeof(dh_priv),
 344   bindh_decinit, dh_decdoit, dh_enccheck, dh_encdestroy
 345 };
 346
 347 static const kemops ec_decops = {
 348   ec_privfetch, sizeof(ec_priv),
 349   ec_decinit, dh_decdoit, dh_enccheck, dh_encdestroy
 350 };
 351
 352 /* --- The switch table --- */
 353
 354 const struct kemtab kemtab[] = {
 355   { "rsa",      &rsa_encops,    &rsa_decops },
 356   { "dh",       &dh_encops,     &dh_decops },
 357   { "bindh",    &bindh_encops,  &bindh_decops },
 358   { "ec",       &ec_encops,     &ec_decops },
 359   { 0,          0,              0 }
 360 };
 361
 362 /* --- @getkem@ --- *
 363  *
 364  * Arguments:   @key *k@ = the key to load
 365  *              @const char *app@ = application name
 366  *              @int wantpriv@ = nonzero if we want to decrypt
 367  *
 368  * Returns:     A key-encapsulating thing.
 369  *
 370  * Use:         Loads a key.
 371  */
 372
 373 kem *getkem(key *k, const char *app, int wantpriv)
 374 {
 375   const char *kalg, *halg = 0, *calg = 0;
 376   dstr d = DSTR_INIT;
 377   dstr t = DSTR_INIT;
 378   size_t n;
 379   char *p = 0;
 380   const char *q;
 381   kem *kk;
 382   const struct kemtab *kt;
 383   const kemops *ko;
 384   void *kd;
 385   int e;
 386   key_packdef *kp;
 387
 388   /* --- Setup stuff --- */
 389
 390   key_fulltag(k, &t);
 391
 392   /* --- Get the KEM name --- *
 393    *
 394    * Take the attribute if it's there; otherwise use the key type.
 395    */
 396
 397   n = strlen(app);
 398   if ((q = key_getattr(0, k, "kem")) != 0) {
 399     dstr_puts(&d, q);
 400     p = d.buf;
 401   } else if (strncmp(k->type, app, n) == 0 && k->type[n] == '-') {
 402     dstr_puts(&d, k->type);
 403     p = d.buf + n + 1;
 404   } else
 405     die(EXIT_FAILURE, "no KEM for key `%s'", t.buf);
 406   kalg = p;
 407
 408   /* --- Grab the encryption scheme --- *
 409    *
 410    * Grab it from the KEM if it's there, but override it from the attribute.
 411    */
 412
 413   if (p && (p = strchr(p, '/')) != 0) {
 414     *p++ = 0;
 415     calg = p;
 416   }
 417   if ((q = key_getattr(0, k, "cipher")) != 0)
 418     calg = q;
 419
 420   /* --- Grab the hash function --- */
 421
 422   if (p && (p = strchr(p, '/')) != 0) {
 423     *p++ = 0;
 424     halg = p;
 425   }
 426   if ((q = key_getattr(0, k, "hash")) != 0)
 427     halg = q;
 428
 429   /* --- Instantiate the KEM --- */
 430
 431   for (kt = kemtab; kt->name; kt++) {
 432     if (strcmp(kt->name, kalg) == 0)
 433       goto k_found;
 434   }
 435   die(EXIT_FAILURE, "key encapsulation mechanism `%s' not found in key `%s'",
 436       kalg, t.buf);
 437 k_found:;
 438   ko = wantpriv ? kt->decops : kt->encops;
 439   kd = xmalloc(ko->kdsz);
 440   kp = key_fetchinit(ko->kf, 0, kd);
 441   if ((e = key_fetch(kp, k)) != 0)
 442     die(EXIT_FAILURE, "error fetching key `%s': %s", t.buf, key_strerror(e));
 443   kk = ko->init(k, kd);
 444   kk->kp = kp;
 445   kk->ops = ko;
 446   kk->kd = kd;
 447
 448   /* --- Set up the algorithms --- */
 449
 450   if (!halg)
 451     kk->h = &rmd160;
 452   else if ((kk->h = ghash_byname(halg)) == 0) {
 453     die(EXIT_FAILURE, "hash algorithm `%s' not found in key `%s'",
 454         halg, t.buf);
 455   }
 456
 457   if (!calg)
 458     kk->c = &blowfish_cbc;
 459   else if ((kk->c = gcipher_byname(calg)) == 0) {
 460     die(EXIT_FAILURE, "encryption scheme `%s' not found in key `%s'",
 461         calg, t.buf);
 462   }
 463
 464   dstr_reset(&d);
 465   if ((q = key_getattr(0, k, "kdf")) == 0) {
 466     dstr_putf(&d, "%s-mgf", kk->h->name);
 467     q = d.buf;
 468   }
 469   if ((kk->cx = gcipher_byname(q)) == 0) {
 470     die(EXIT_FAILURE, "encryption scheme (KDF) `%s' not found in key `%s'",
 471         q, t.buf);
 472   }
 473
 474   dstr_reset(&d);
 475   if ((q = key_getattr(0, k, "mac")) == 0) {
 476     dstr_putf(&d, "%s-hmac", kk->h->name);
 477     q = d.buf;
 478   }
 479   if ((kk->m = gmac_byname(q)) == 0) {
 480     die(EXIT_FAILURE,
 481         "message authentication code `%s' not found in key `%s'",
 482         q, t.buf);
 483   }
 484
 485   /* --- Tidy up --- */
 486
 487   dstr_destroy(&d);
 488   dstr_destroy(&t);
 489   return (kk);
 490 }
 491
 492 /* --- @setupkem@ --- *
 493  *
 494  * Arguments:   @kem *k@ = key-encapsulation thing
 495  *              @dstr *d@ = key-encapsulation data
 496  *              @gcipher **cx@ = key-expansion function (for IVs)
 497  *              @gcipher **c@ = where to put initialized encryption scheme
 498  *              @gmac **m@ = where to put initialized MAC
 499  *
 500  * Returns:     Zero on success, nonzero on failure.
 501  *
 502  * Use:         Initializes all the various symmetric things from a KEM.
 503  */
 504
 505 int setupkem(kem *k, dstr *d, gcipher **cx, gcipher **c, gmac **m)
 506 {
 507   octet *kd;
 508   size_t n, cn, mn;
 509   ghash *h;
 510   int rc = -1;
 511
 512   h = GH_INIT(k->h);
 513   if (k->ops->doit(k, d, h))
 514     goto done;
 515   n = keysz(GH_CLASS(h)->hashsz, k->cx->keysz);
 516   if (!n)
 517     goto done;
 518   kd = GH_DONE(h, 0);
 519   *cx = GC_INIT(k->cx, kd, n);
 520
 521   cn = keysz(0, k->c->keysz); n = cn;
 522   mn = keysz(0, k->m->keysz); if (mn > n) n = mn;
 523   kd = xmalloc(n);
 524   GC_ENCRYPT(*cx, 0, kd, cn);
 525   *c = GC_INIT(k->c, kd, cn);
 526   GC_ENCRYPT(*cx, 0, kd, mn);
 527   *m = GM_KEY(k->m, kd, mn);
 528   xfree(kd);
 529
 530   rc = 0;
 531 done:
 532   GH_DESTROY(h);
 533   return (rc);
 534 }
 535
 536 /* --- @freekem@ --- *
 537  *
 538  * Arguments:   @kem *k@ = key-encapsulation thing
 539  *
 540  * Returns:     ---
 541  *
 542  * Use:         Frees up a key-encapsulation thing.
 543  */
 544
 545 void freekem(kem *k)
 546 {
 547   key_fetchdone(k->kp);
 548   xfree(k->kd);
 549   k->ops->destroy(k);
 550 }
 551
 552 /*----- That's all, folks -------------------------------------------------*/