chiark - git - mdw - tripe/blob - server/bulkcrypto.c

   1 /* -*-c-*-
   2  *
   3  * Bulk crypto transformations
   4  *
   5  * (c) 2014 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 it under
  13  * the terms of the GNU General Public License as published by the Free
  14  * Software Foundation; either version 3 of the License, or (at your
  15  * option) any later version.
  16  *
  17  * TrIPE is distributed in the hope that it will be useful, but WITHOUT
  18  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20  * for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with TrIPE.  If not, see <https://www.gnu.org/licenses/>.
  24  */
  25
  26 /*----- Header files ------------------------------------------------------*/
  27
  28 #include "tripe.h"
  29
  30 /*----- Utilities ---------------------------------------------------------*/
  31
  32 #define SEQSZ 4                         /* Size of sequence number packet */
  33
  34 #define TRACE_IV(qiv, ivsz) do { IF_TRACING(T_KEYSET, {                 \
  35   trace_block(T_CRYPTO, "crypto: initialization vector",                \
  36               (qiv), (ivsz));                                           \
  37 }) } while (0)
  38
  39 #define TRACE_CT(qpk, sz) do { IF_TRACING(T_KEYSET, {                   \
  40   trace_block(T_CRYPTO, "crypto: encrypted packet", (qpk), (sz));       \
  41 }) } while (0)
  42
  43 #define TRACE_MAC(qmac, tagsz) do { IF_TRACING(T_KEYSET, {              \
  44   trace_block(T_CRYPTO, "crypto: computed MAC", (qmac), (tagsz));       \
  45 }) } while (0)
  46
  47 #define TRACE_MACERR(pmac, tagsz) do { IF_TRACING(T_KEYSET, {           \
  48   trace(T_KEYSET, "keyset: incorrect MAC: decryption failed");          \
  49   trace_block(T_CRYPTO, "crypto: provided MAC", (pmac), (tagsz));       \
  50 }) } while (0)
  51
  52 /* --- @derivekey@ --- *
  53  *
  54  * Arguments:   @octet *k@ = pointer to an output buffer of at least
  55  *                      @MAXHASHSZ@ bytes
  56  *              @size_t ksz@ = actual size wanted (for tracing)
  57  *              @const deriveargs@ = derivation parameters, as passed into
  58  *                      @genkeys@
  59  *              @int dir@ = direction for the key (@DIR_IN@ or @DIR_OUT@)
  60  *              @const char *what@ = label for the key (input to derivation)
  61  *
  62  * Returns:     ---
  63  *
  64  * Use:         Derives a session key, for use on incoming or outgoing data.
  65  */
  66
  67 static void derivekey(octet *k, size_t ksz, const deriveargs *a,
  68                       int dir, const char *what)
  69 {
  70   const gchash *hc = a->hc;
  71   ghash *h;
  72
  73   assert(ksz <= hc->hashsz);
  74   assert(hc->hashsz <= MAXHASHSZ);
  75   h = GH_INIT(hc);
  76   GH_HASH(h, a->what, strlen(a->what)); GH_HASH(h, what, strlen(what) + 1);
  77   switch (dir) {
  78     case DIR_IN:
  79       if (a->x) GH_HASH(h, a->k, a->x);
  80       if (a->y != a->x) GH_HASH(h, a->k + a->x, a->y - a->x);
  81       break;
  82     case DIR_OUT:
  83       if (a->y != a->x) GH_HASH(h, a->k + a->x, a->y - a->x);
  84       if (a->x) GH_HASH(h, a->k, a->x);
  85       break;
  86     default:
  87       abort();
  88   }
  89   GH_HASH(h, a->k + a->y, a->z - a->y);
  90   GH_DONE(h, k);
  91   GH_DESTROY(h);
  92   IF_TRACING(T_KEYSET, { IF_TRACING(T_CRYPTO, {
  93     char _buf[32];
  94     sprintf(_buf, "crypto: %s key %s", dir ? "outgoing" : "incoming", what);
  95     trace_block(T_CRYPTO, _buf, k, ksz);
  96   }) })
  97 }
  98
  99 /*----- Common functionality for generic-composition transforms -----------*/
 100
 101 #define CHECK_MAC(h, pmac, tagsz) do {                                  \
 102   ghash *_h = (h);                                                      \
 103   const octet *_pmac = (pmac);                                          \
 104   size_t _tagsz = (tagsz);                                              \
 105   octet *_mac = GH_DONE(_h, 0);                                         \
 106   int _eq = ct_memeq(_mac, _pmac, _tagsz);                              \
 107   TRACE_MAC(_mac, _tagsz);                                              \
 108   GH_DESTROY(_h);                                                       \
 109   if (!_eq) {                                                           \
 110     TRACE_MACERR(_pmac, _tagsz);                                        \
 111     return (KSERR_DECRYPT);                                             \
 112   }                                                                     \
 113 } while (0)
 114
 115 typedef struct gencomp_algs {
 116   const gccipher *c; size_t cksz;
 117   const gcmac *m; size_t mksz; size_t tagsz;
 118 } gencomp_algs;
 119
 120 typedef struct gencomp_chal {
 121   bulkchal _b;
 122   gmac *m;
 123 } gencomp_chal;
 124
 125 static int gencomp_getalgs(gencomp_algs *a, const algswitch *asw,
 126                            dstr *e, key_file *kf, key *k)
 127 {
 128   const char *p;
 129   char *q, *qq;
 130   unsigned long n;
 131   dstr d = DSTR_INIT;
 132   int rc = -1;
 133
 134   /* --- Symmetric encryption --- */
 135
 136   if ((p = key_getattr(kf, k, "cipher")) == 0) p = "blowfish-cbc";
 137   if ((a->c = gcipher_byname(p)) == 0) {
 138     a_format(e, "unknown-cipher", "%s", p, A_END);
 139     goto done;
 140   }
 141
 142   /* --- Message authentication --- */
 143
 144   if ((p = key_getattr(kf, k, "mac")) != 0) {
 145     dstr_reset(&d);
 146     dstr_puts(&d, p);
 147     if ((q = strrchr(d.buf, '/')) != 0)
 148       *q++ = 0;
 149     if ((a->m = gmac_byname(d.buf)) == 0) {
 150       a_format(e, "unknown-mac", "%s", d.buf, A_END);
 151       goto done;
 152     }
 153     if (!q)
 154       a->tagsz = a->m->hashsz;
 155     else {
 156       n = strtoul(q, &qq, 0);
 157       if (*qq)  {
 158         a_format(e, "bad-tag-length-string", "%s", q, A_END);
 159         goto done;
 160       }
 161       if (n%8 || n/8 > a->m->hashsz) {
 162         a_format(e, "bad-tag-length", "%lu", n, A_END);
 163         goto done;
 164       }
 165       a->tagsz = n/8;
 166     }
 167   } else {
 168     dstr_reset(&d);
 169     dstr_putf(&d, "%s-hmac", asw->h->name);
 170     if ((a->m = gmac_byname(d.buf)) == 0) {
 171       a_format(e, "no-hmac-for-hash", "%s", asw->h->name, A_END);
 172       goto done;
 173     }
 174     a->tagsz = asw->h->hashsz/2;
 175   }
 176
 177   rc = 0;
 178 done:
 179   dstr_destroy(&d);
 180   return (rc);
 181 }
 182
 183 #ifndef NTRACE
 184 static void gencomp_tracealgs(const gencomp_algs *a)
 185 {
 186   trace(T_CRYPTO, "crypto: cipher = %s", a->c->name);
 187   trace(T_CRYPTO, "crypto: mac = %s/%lu",
 188         a->m->name, (unsigned long)a->tagsz * 8);
 189 }
 190 #endif
 191
 192 static int gencomp_checkalgs(gencomp_algs *a, const algswitch *asw, dstr *e)
 193 {
 194   /* --- Derive the key sizes --- *
 195    *
 196    * Must ensure that we have non-empty keys.  This isn't ideal, but it
 197    * provides a handy sanity check.  Also must be based on a 64- or 128-bit
 198    * block cipher or we can't do the data expiry properly.
 199    */
 200
 201   if ((a->cksz = keysz(asw->hashsz, a->c->keysz)) == 0) {
 202     a_format(e, "cipher", "%s", a->c->name,
 203              "no-key-size", "%lu", (unsigned long)asw->hashsz,
 204              A_END);
 205     return (-1);
 206   }
 207   if ((a->mksz = keysz(asw->hashsz, a->m->keysz)) == 0) {
 208     a_format(e, "mac", "%s", a->m->name,
 209              "no-key-size", "%lu", (unsigned long)asw->hashsz,
 210              A_END);
 211     return (-1);
 212   }
 213
 214   return (0);
 215 }
 216
 217 static void gencomp_alginfo(const gencomp_algs *a, admin *adm)
 218 {
 219   a_info(adm,
 220          "cipher=%s", a->c->name,
 221          "cipher-keysz=%lu", (unsigned long)a->cksz,
 222          "cipher-blksz=%lu", (unsigned long)a->c->blksz,
 223          A_END);
 224   a_info(adm,
 225          "mac=%s", a->m->name,
 226          "mac-keysz=%lu", (unsigned long)a->mksz,
 227          "mac-tagsz=%lu", (unsigned long)a->tagsz,
 228          A_END);
 229 }
 230
 231 static int gencomp_samealgsp(const gencomp_algs *a, const gencomp_algs *aa)
 232 {
 233   return (a->c == aa->c &&
 234           a->m == aa->m && a->tagsz == aa->tagsz);
 235 }
 236
 237 static size_t gencomp_expsz(const gencomp_algs *a)
 238   { return (a->c->blksz < 16 ? MEG(64) : MEG(2048)); }
 239
 240 static bulkchal *gencomp_genchal(const gencomp_algs *a)
 241 {
 242   gencomp_chal *gc = CREATE(gencomp_chal);
 243
 244   rand_get(RAND_GLOBAL, buf_t, a->mksz);
 245   gc->m = GM_KEY(a->m, buf_t, a->mksz);
 246   gc->_b.tagsz = a->tagsz;
 247   IF_TRACING(T_CHAL, {
 248     trace(T_CHAL, "chal: generated new challenge key");
 249     trace_block(T_CRYPTO, "chal: new key", buf_t, a->mksz);
 250   })
 251   return (&gc->_b);
 252 }
 253
 254 static int gencomp_chaltag(bulkchal *bc, const void *m, size_t msz,
 255                            uint32 seq, void *t)
 256 {
 257   gencomp_chal *gc = (gencomp_chal *)bc;
 258   ghash *h = GM_INIT(gc->m);
 259
 260   GH_HASHU32(h, seq); if (msz) GH_HASH(h, m, msz);
 261   memcpy(t, GH_DONE(h, 0), bc->tagsz);
 262   GH_DESTROY(h);
 263   return (0);
 264 }
 265
 266 static int gencomp_chalvrf(bulkchal *bc, const void *m, size_t msz,
 267                            uint32 seq, const void *t)
 268 {
 269   gencomp_chal *gc = (gencomp_chal *)bc;
 270   ghash *h = GM_INIT(gc->m);
 271   int ok;
 272
 273   GH_HASHU32(h, seq); if (msz) GH_HASH(h, m, msz);
 274   ok = ct_memeq(GH_DONE(h, 0), t, gc->_b.tagsz);
 275   GH_DESTROY(h);
 276   return (ok ? 0 : -1);
 277 }
 278
 279 static void gencomp_freechal(bulkchal *bc)
 280   { gencomp_chal *gc = (gencomp_chal *)bc; GM_DESTROY(gc->m); DESTROY(gc); }
 281
 282 /*----- The original transform --------------------------------------------*
 283  *
 284  * We generate a random initialization vector (if the cipher needs one).  We
 285  * encrypt the input message with the cipher, and format the type, sequence
 286  * number, IV, and ciphertext as follows.
 287  *
 288  *              +------+ +------+---...---+------...------+
 289  *              | type | | seq  |   iv    |   ciphertext  |
 290  *              +------+ +------+---...---+------...------+
 291  *                 32       32     blksz         sz
 292  *
 293  * All of this is fed into the MAC to compute a tag.  The type is not
 294  * transmitted: the other end knows what type of message it expects, and the
 295  * type is only here to prevent us from being confused because some other
 296  * kind of ciphertext has been substituted.  The tag is prepended to the
 297  * remainder, to yield the finished cryptogram, as follows.
 298  *
 299  *              +---...---+------+---...---+------...------+
 300  *              |   tag   | seq  |   iv    |   ciphertext  |
 301  *              +---...---+------+---...---+------...------+
 302  *                 tagsz     32     blksz         sz
 303  *
 304  * Decryption: checks the overall size, verifies the tag, then decrypts the
 305  * ciphertext and extracts the sequence number.
 306  */
 307
 308 typedef struct v0_algs {
 309   bulkalgs _b;
 310   gencomp_algs ga;
 311 } v0_algs;
 312
 313 typedef struct v0_ctx {
 314   bulkctx _b;
 315   size_t tagsz;
 316   struct {
 317     gcipher *c;
 318     gmac *m;
 319   } d[NDIR];
 320 } v0_ctx;
 321
 322 static bulkalgs *v0_getalgs(const algswitch *asw, dstr *e,
 323                             key_file *kf, key *k)
 324 {
 325   v0_algs *a = CREATE(v0_algs);
 326   if (gencomp_getalgs(&a->ga, asw, e, kf, k)) { DESTROY(a); return (0); }
 327   return (&a->_b);
 328 }
 329
 330 #ifndef NTRACE
 331 static void v0_tracealgs(const bulkalgs *aa)
 332   { const v0_algs *a = (const v0_algs *)aa; gencomp_tracealgs(&a->ga); }
 333 #endif
 334
 335 static int v0_checkalgs(bulkalgs *aa, const algswitch *asw, dstr *e)
 336 {
 337   v0_algs *a = (v0_algs *)aa;
 338   if (gencomp_checkalgs(&a->ga, asw, e)) return (-1);
 339   return (0);
 340 }
 341
 342 static int v0_samealgsp(const bulkalgs *aa, const bulkalgs *bb)
 343 {
 344   const v0_algs *a = (const v0_algs *)aa, *b = (const v0_algs *)bb;
 345   return (gencomp_samealgsp(&a->ga, &b->ga));
 346 }
 347
 348 static void v0_alginfo(const bulkalgs *aa, admin *adm)
 349   { const v0_algs *a = (const v0_algs *)aa; gencomp_alginfo(&a->ga, adm); }
 350
 351 static size_t v0_overhead(const bulkalgs *aa)
 352 {
 353   const v0_algs *a = (const v0_algs *)aa;
 354   return (a->ga.tagsz + SEQSZ + a->ga.c->blksz);
 355 }
 356
 357 static size_t v0_expsz(const bulkalgs *aa)
 358   { const v0_algs *a = (const v0_algs *)aa; return (gencomp_expsz(&a->ga)); }
 359
 360 static bulkctx *v0_genkeys(const bulkalgs *aa, const deriveargs *da)
 361 {
 362   const v0_algs *a = (const v0_algs *)aa;
 363   v0_ctx *bc = CREATE(v0_ctx);
 364   octet k[MAXHASHSZ];
 365   int i;
 366
 367   bc->tagsz = a->ga.tagsz;
 368   for (i = 0; i < NDIR; i++) {
 369     if (!(da->f&(1 << i))) { bc->d[i].c = 0; bc->d[i].m = 0; continue; }
 370     derivekey(k, a->ga.cksz, da, i, "encryption");
 371     bc->d[i].c = GC_INIT(a->ga.c, k, a->ga.cksz);
 372     derivekey(k, a->ga.mksz, da, i, "integrity");
 373     bc->d[i].m = GM_KEY(a->ga.m, k, a->ga.mksz);
 374   }
 375   return (&bc->_b);
 376 }
 377
 378 static bulkchal *v0_genchal(const bulkalgs *aa)
 379 {
 380   const v0_algs *a = (const v0_algs *)aa;
 381   return (gencomp_genchal(&a->ga));
 382 }
 383 #define v0_chaltag gencomp_chaltag
 384 #define v0_chalvrf gencomp_chalvrf
 385 #define v0_freechal gencomp_freechal
 386
 387 static void v0_freealgs(bulkalgs *aa)
 388   { v0_algs *a = (v0_algs *)aa; DESTROY(a); }
 389
 390 static void v0_freectx(bulkctx *bbc)
 391 {
 392   v0_ctx *bc = (v0_ctx *)bbc;
 393   int i;
 394
 395   for (i = 0; i < NDIR; i++) {
 396     if (bc->d[i].c) GC_DESTROY(bc->d[i].c);
 397     if (bc->d[i].m) GM_DESTROY(bc->d[i].m);
 398   }
 399   DESTROY(bc);
 400 }
 401
 402 static int v0_encrypt(bulkctx *bbc, unsigned ty,
 403                       buf *b, buf *bb, uint32 seq)
 404 {
 405   v0_ctx *bc = (v0_ctx *)bbc;
 406   ghash *h;
 407   gcipher *c = bc->d[DIR_OUT].c;
 408   const octet *p = BCUR(b);
 409   size_t sz = BLEFT(b);
 410   octet *qmac, *qseq, *qiv, *qpk;
 411   size_t ivsz;
 412   size_t tagsz = bc->tagsz;
 413   octet t[4];
 414
 415   assert(c);
 416   ivsz = GC_CLASS(c)->blksz;
 417
 418   /* --- Determine the ciphertext layout --- */
 419
 420   if (buf_ensure(bb, tagsz + SEQSZ + ivsz + sz)) return (0);
 421   qmac = BCUR(bb); qseq = qmac + tagsz; qiv = qseq + SEQSZ; qpk = qiv + ivsz;
 422   BSTEP(bb, tagsz + SEQSZ + ivsz + sz);
 423
 424   /* --- Store the type --- *
 425    *
 426    * This isn't transmitted, but it's covered by the MAC.
 427    */
 428
 429   STORE32(t, ty);
 430
 431   /* --- Store the sequence number --- */
 432
 433   STORE32(qseq, seq);
 434
 435   /* --- Establish an initialization vector if necessary --- */
 436
 437   if (ivsz) {
 438     rand_get(RAND_GLOBAL, qiv, ivsz);
 439     GC_SETIV(c, qiv);
 440     TRACE_IV(qiv, ivsz);
 441   }
 442
 443   /* --- Encrypt the packet --- */
 444
 445   GC_ENCRYPT(c, p, qpk, sz);
 446   TRACE_CT(qpk, sz);
 447
 448   /* --- Compute a MAC over type, sequence number, IV, and ciphertext --- */
 449
 450   if (tagsz) {
 451     h = GM_INIT(bc->d[DIR_OUT].m);
 452     GH_HASH(h, t, sizeof(t));
 453     GH_HASH(h, qseq, SEQSZ + ivsz + sz);
 454     memcpy(qmac, GH_DONE(h, 0), tagsz);
 455     GH_DESTROY(h);
 456     TRACE_MAC(qmac, tagsz);
 457   }
 458
 459   /* --- We're done --- */
 460
 461   return (0);
 462 }
 463
 464 static int v0_decrypt(bulkctx *bbc, unsigned ty,
 465                       buf *b, buf *bb, uint32 *seq)
 466 {
 467   v0_ctx *bc = (v0_ctx *)bbc;
 468   const octet *pmac, *piv, *pseq, *ppk;
 469   size_t psz = BLEFT(b);
 470   size_t sz;
 471   octet *q = BCUR(bb);
 472   ghash *h;
 473   gcipher *c = bc->d[DIR_IN].c;
 474   size_t ivsz;
 475   size_t tagsz = bc->tagsz;
 476   octet t[4];
 477
 478   assert(c);
 479   ivsz = GC_CLASS(c)->blksz;
 480
 481   /* --- Break up the packet into its components --- */
 482
 483   if (psz < ivsz + SEQSZ + tagsz) {
 484     T( trace(T_KEYSET, "keyset: block too small for keyset"); )
 485     return (KSERR_MALFORMED);
 486   }
 487   sz = psz - ivsz - SEQSZ - tagsz;
 488   pmac = BCUR(b); pseq = pmac + tagsz; piv = pseq + SEQSZ; ppk = piv + ivsz;
 489   STORE32(t, ty);
 490
 491   /* --- Verify the MAC on the packet --- */
 492
 493   if (tagsz) {
 494     h = GM_INIT(bc->d[DIR_IN].m);
 495     GH_HASH(h, t, sizeof(t));
 496     GH_HASH(h, pseq, SEQSZ + ivsz + sz);
 497     CHECK_MAC(h, pmac, tagsz);
 498   }
 499
 500   /* --- Decrypt the packet --- */
 501
 502   if (ivsz) {
 503     TRACE_IV(piv, ivsz);
 504     GC_SETIV(c, piv);
 505   }
 506   GC_DECRYPT(c, ppk, q, sz);
 507
 508   /* --- Finished --- */
 509
 510   *seq = LOAD32(pseq);
 511   BSTEP(bb, sz);
 512   return (0);
 513 }
 514
 515 /*----- The implicit-IV transform -----------------------------------------*
 516  *
 517  * The v0 transform makes everything explicit.  There's an IV because the
 518  * cipher needs an IV; there's a sequence number because replay prevention
 519  * needs a sequence number.
 520  *
 521  * This new transform works rather differently.  We make use of a block
 522  * cipher to encrypt the sequence number, and use that as the IV.  We
 523  * transmit the sequence number in the clear, as before.  This reduces
 524  * overhead; and it's not a significant privacy leak because the adversary
 525  * can see the order in which the messages are transmitted -- i.e., the
 526  * sequence numbers are almost completely predictable anyway.
 527  *
 528  * So, a MAC is computed over
 529  *
 530  *              +------+ +------+------...------+
 531  *              | type | | seq  |   ciphertext  |
 532  *              +------+ +------+------...------+
 533  *                 32       32         sz
 534  *
 535  * and we actually transmit the following as the cryptogram.
 536  *
 537  *              +---...---+------+------...------+
 538  *              |   tag   | seq  |   ciphertext  |
 539  *              +---...---+------+------...------+
 540  *                 tagsz     32         sz
 541  */
 542
 543 typedef struct iiv_algs {
 544   bulkalgs _b;
 545   gencomp_algs ga;
 546   const gccipher *b; size_t bksz;
 547 } iiv_algs;
 548
 549 typedef struct iiv_ctx {
 550   bulkctx _b;
 551   size_t tagsz;
 552   struct {
 553     gcipher *c, *b;
 554     gmac *m;
 555   } d[NDIR];
 556 } iiv_ctx;
 557
 558
 559 static bulkalgs *iiv_getalgs(const algswitch *asw, dstr *e,
 560                             key_file *kf, key *k)
 561 {
 562   iiv_algs *a = CREATE(iiv_algs);
 563   dstr d = DSTR_INIT, dd = DSTR_INIT;
 564   const char *p;
 565   char *q;
 566
 567   if (gencomp_getalgs(&a->ga, asw, e, kf, k)) goto fail;
 568
 569   if ((p = key_getattr(kf, k, "blkc")) == 0) {
 570     dstr_puts(&dd, a->ga.c->name);
 571     if ((q = strrchr(dd.buf, '-')) != 0) *q = 0;
 572     p = dd.buf;
 573   }
 574   dstr_putf(&d, "%s-ecb", p);
 575   if ((a->b = gcipher_byname(d.buf)) == 0) {
 576     a_format(e, "unknown-blkc", "%s", p, A_END);
 577     goto fail;
 578   }
 579
 580   dstr_destroy(&d); dstr_destroy(&dd);
 581   return (&a->_b);
 582 fail:
 583   dstr_destroy(&d); dstr_destroy(&dd);
 584   DESTROY(a);
 585   return (0);
 586 }
 587
 588 #ifndef NTRACE
 589 static void iiv_tracealgs(const bulkalgs *aa)
 590 {
 591   const iiv_algs *a = (const iiv_algs *)aa;
 592
 593   gencomp_tracealgs(&a->ga);
 594   trace(T_CRYPTO,
 595         "crypto: blkc = %.*s", (int)strlen(a->b->name) - 4, a->b->name);
 596 }
 597 #endif
 598
 599 static int iiv_checkalgs(bulkalgs *aa, const algswitch *asw, dstr *e)
 600 {
 601   iiv_algs *a = (iiv_algs *)aa;
 602
 603   if (gencomp_checkalgs(&a->ga, asw, e)) return (-1);
 604
 605   if ((a->bksz = keysz(asw->hashsz, a->b->keysz)) == 0) {
 606     a_format(e, "blkc", "%.*s", strlen(a->b->name) - 4, a->b->name,
 607              "no-key-size", "%lu", (unsigned long)asw->hashsz,
 608              A_END);
 609     return (-1);
 610   }
 611   if (a->b->blksz < a->ga.c->blksz) {
 612     a_format(e, "blkc", "%.*s", strlen(a->b->name) - 4, a->b->name,
 613              "blksz-insufficient", A_END);
 614     return (-1);
 615   }
 616   return (0);
 617 }
 618
 619 static int iiv_samealgsp(const bulkalgs *aa, const bulkalgs *bb)
 620 {
 621   const iiv_algs *a = (const iiv_algs *)aa, *b = (const iiv_algs *)bb;
 622   return (gencomp_samealgsp(&a->ga, &b->ga) && a->b == b->b);
 623 }
 624
 625 static void iiv_alginfo(const bulkalgs *aa, admin *adm)
 626 {
 627   const iiv_algs *a = (const iiv_algs *)aa;
 628   gencomp_alginfo(&a->ga, adm);
 629   a_info(adm,
 630          "blkc=%.*s", strlen(a->b->name) - 4, a->b->name,
 631          "blkc-keysz=%lu", (unsigned long)a->bksz,
 632          "blkc-blksz=%lu", (unsigned long)a->b->blksz,
 633          A_END);
 634 }
 635
 636 static size_t iiv_overhead(const bulkalgs *aa)
 637   { const iiv_algs *a = (const iiv_algs *)aa; return (a->ga.tagsz + SEQSZ); }
 638
 639 static size_t iiv_expsz(const bulkalgs *aa)
 640 {
 641   const iiv_algs *a = (const iiv_algs *)aa;
 642   return (gencomp_expsz(&a->ga));
 643 }
 644
 645 static bulkctx *iiv_genkeys(const bulkalgs *aa, const deriveargs *da)
 646 {
 647   const iiv_algs *a = (const iiv_algs *)aa;
 648   iiv_ctx *bc = CREATE(iiv_ctx);
 649   octet k[MAXHASHSZ];
 650   int i;
 651
 652   bc->tagsz = a->ga.tagsz;
 653   for (i = 0; i < NDIR; i++) {
 654     if (!(da->f&(1 << i)))
 655       { bc->d[i].c = 0; bc->d[i].b = 0; bc->d[i].m = 0; continue; }
 656     derivekey(k, a->ga.cksz, da, i, "encryption");
 657     bc->d[i].c = GC_INIT(a->ga.c, k, a->ga.cksz);
 658     derivekey(k, a->bksz, da, i, "blkc");
 659     bc->d[i].b = GC_INIT(a->b, k, a->bksz);
 660     derivekey(k, a->ga.mksz, da, i, "integrity");
 661     bc->d[i].m = GM_KEY(a->ga.m, k, a->ga.mksz);
 662   }
 663   return (&bc->_b);
 664 }
 665
 666 static bulkchal *iiv_genchal(const bulkalgs *aa)
 667 {
 668   const iiv_algs *a = (const iiv_algs *)aa;
 669   return (gencomp_genchal(&a->ga));
 670 }
 671 #define iiv_chaltag gencomp_chaltag
 672 #define iiv_chalvrf gencomp_chalvrf
 673 #define iiv_freechal gencomp_freechal
 674
 675 static void iiv_freealgs(bulkalgs *aa)
 676   { iiv_algs *a = (iiv_algs *)aa; DESTROY(a); }
 677
 678 static void iiv_freectx(bulkctx *bbc)
 679 {
 680   iiv_ctx *bc = (iiv_ctx *)bbc;
 681   int i;
 682
 683   for (i = 0; i < NDIR; i++) {
 684     if (bc->d[i].c) GC_DESTROY(bc->d[i].c);
 685     if (bc->d[i].b) GC_DESTROY(bc->d[i].b);
 686     if (bc->d[i].m) GM_DESTROY(bc->d[i].m);
 687   }
 688   DESTROY(bc);
 689 }
 690
 691 #define TRACE_PRESEQ(qseq, ivsz) do { IF_TRACING(T_KEYSET, {            \
 692   trace_block(T_CRYPTO, "crypto: IV derivation input", (qseq), (ivsz)); \
 693 }) } while (0)
 694
 695 static int iiv_encrypt(bulkctx *bbc, unsigned ty,
 696                        buf *b, buf *bb, uint32 seq)
 697 {
 698   iiv_ctx *bc = (iiv_ctx *)bbc;
 699   ghash *h;
 700   gcipher *c = bc->d[DIR_OUT].c, *blkc = bc->d[DIR_OUT].b;
 701   const octet *p = BCUR(b);
 702   size_t sz = BLEFT(b);
 703   octet *qmac, *qseq, *qpk;
 704   size_t ivsz, blkcsz;
 705   size_t tagsz = bc->tagsz;
 706   octet t[4];
 707
 708   assert(c); assert(blkc);
 709   ivsz = GC_CLASS(c)->blksz;
 710   blkcsz = GC_CLASS(blkc)->blksz;
 711
 712   /* --- Determine the ciphertext layout --- */
 713
 714   if (buf_ensure(bb, tagsz + SEQSZ + sz)) return (0);
 715   qmac = BCUR(bb); qseq = qmac + tagsz; qpk = qseq + SEQSZ;
 716   BSTEP(bb, tagsz + SEQSZ + sz);
 717
 718   /* --- Store the type --- *
 719    *
 720    * This isn't transmitted, but it's covered by the MAC.
 721    */
 722
 723   STORE32(t, ty);
 724
 725   /* --- Store the sequence number --- */
 726
 727   STORE32(qseq, seq);
 728
 729   /* --- Establish an initialization vector if necessary --- */
 730
 731   if (ivsz) {
 732     memset(buf_u, 0, blkcsz - SEQSZ);
 733     memcpy(buf_u + blkcsz - SEQSZ, qseq, SEQSZ);
 734     TRACE_PRESEQ(buf_u, ivsz);
 735     GC_ENCRYPT(blkc, buf_u, buf_u, blkcsz);
 736     GC_SETIV(c, buf_u);
 737     TRACE_IV(buf_u, ivsz);
 738   }
 739
 740   /* --- Encrypt the packet --- */
 741
 742   GC_ENCRYPT(c, p, qpk, sz);
 743   TRACE_CT(qpk, sz);
 744
 745   /* --- Compute a MAC over type, sequence number, and ciphertext --- */
 746
 747   if (tagsz) {
 748     h = GM_INIT(bc->d[DIR_OUT].m);
 749     GH_HASH(h, t, sizeof(t));
 750     GH_HASH(h, qseq, SEQSZ + sz);
 751     memcpy(qmac, GH_DONE(h, 0), tagsz);
 752     GH_DESTROY(h);
 753     TRACE_MAC(qmac, tagsz);
 754   }
 755
 756   /* --- We're done --- */
 757
 758   return (0);
 759 }
 760
 761 static int iiv_decrypt(bulkctx *bbc, unsigned ty,
 762                        buf *b, buf *bb, uint32 *seq)
 763 {
 764   iiv_ctx *bc = (iiv_ctx *)bbc;
 765   const octet *pmac, *pseq, *ppk;
 766   size_t psz = BLEFT(b);
 767   size_t sz;
 768   octet *q = BCUR(bb);
 769   ghash *h;
 770   gcipher *c = bc->d[DIR_IN].c, *blkc = bc->d[DIR_IN].b;
 771   size_t ivsz, blkcsz;
 772   size_t tagsz = bc->tagsz;
 773   octet t[4];
 774
 775   assert(c); assert(blkc);
 776   ivsz = GC_CLASS(c)->blksz;
 777   blkcsz = GC_CLASS(blkc)->blksz;
 778
 779   /* --- Break up the packet into its components --- */
 780
 781   if (psz < SEQSZ + tagsz) {
 782     T( trace(T_KEYSET, "keyset: block too small for keyset"); )
 783     return (KSERR_MALFORMED);
 784   }
 785   sz = psz - SEQSZ - tagsz;
 786   pmac = BCUR(b); pseq = pmac + tagsz; ppk = pseq + SEQSZ;
 787   STORE32(t, ty);
 788
 789   /* --- Verify the MAC on the packet --- */
 790
 791   if (tagsz) {
 792     h = GM_INIT(bc->d[DIR_IN].m);
 793     GH_HASH(h, t, sizeof(t));
 794     GH_HASH(h, pseq, SEQSZ + sz);
 795     CHECK_MAC(h, pmac, tagsz);
 796   }
 797
 798   /* --- Decrypt the packet --- */
 799
 800   if (ivsz) {
 801     memset(buf_u, 0, blkcsz - SEQSZ);
 802     memcpy(buf_u + blkcsz - SEQSZ, pseq, SEQSZ);
 803     TRACE_PRESEQ(buf_u, ivsz);
 804     GC_ENCRYPT(blkc, buf_u, buf_u, blkcsz);
 805     GC_SETIV(c, buf_u);
 806     TRACE_IV(buf_u, ivsz);
 807   }
 808   GC_DECRYPT(c, ppk, q, sz);
 809
 810   /* --- Finished --- */
 811
 812   *seq = LOAD32(pseq);
 813   BSTEP(bb, sz);
 814   return (0);
 815 }
 816
 817 /*----- The AEAD transform ------------------------------------------------*
 818  *
 819  * This transform uses a general authenticated encryption scheme (the
 820  * additional data isn't necessary).  Good options include
 821  * `chacha20-poly1305' or `rijndael-ocb3'.
 822  *
 823  * To be acceptable, the scheme must accept at least a 64-bit nonce.  (All of
 824  * Catacomb's current AEAD schemes are suitable.)  The low 32 bits are the
 825  * sequence number, and the high 32 bits are the type, both big-endian.
 826  *
 827  *              +------+------+
 828  *              | seq  | type |
 829  *              +------+------+
 830  *                 32     32
 831  *
 832  * The ciphertext is formatted as
 833  *
 834  *              +---...---+------+------...------+
 835  *              |   tag   | seq  |   ciphertext  |
 836  *              +---...---+------+------...------+
 837  *                 tagsz     32         sz
 838  *
 839  */
 840
 841 #define AEAD_NONCEMAX 64
 842
 843 typedef struct aead_algs {
 844   bulkalgs _b;
 845   const gcaead *c;
 846   size_t ksz, nsz, tsz;
 847 } aead_algs;
 848
 849 typedef struct aead_ctx {
 850   bulkctx _b;
 851   struct { gaead_key *k; } d[NDIR];
 852   size_t nsz, tsz;
 853 } aead_ctx;
 854
 855 static bulkalgs *aead_getalgs(const algswitch *asw, dstr *e,
 856                               key_file *kf, key *k)
 857 {
 858   aead_algs *a = CREATE(aead_algs);
 859   const char *p;
 860   char *qq;
 861   gaead_key *kk = 0;
 862   size_t ksz;
 863   size_t csz = 0;
 864   unsigned long n;
 865
 866   /* --- Collect the selected cipher and check that it's supported --- */
 867
 868   p = key_getattr(kf, k, "cipher"); if (!p) p = "rijndael-ocb3";
 869   a->c = gaead_byname(p);
 870   if (!a->c) { a_format(e, "unknown-cipher", "%s", p, A_END); goto fail; }
 871   if (a->c->f&AEADF_NOAAD) {
 872     a_format(e, "unsuitable-aead-cipher", "%s", p, "no-aad", A_END);
 873     goto fail;
 874   }
 875   a->nsz = keysz_pad(8, a->c->noncesz);
 876   if (!a->nsz) {
 877     a_format(e, "unsuitable-aead-cipher", "%s", p, "nonce-too-small", A_END);
 878     goto fail;
 879   } else if (a->nsz > AEAD_NONCEMAX) {
 880     a_format(e, "unsuitable-aead-cipher", "%s", p, "nonce-too-large", A_END);
 881     goto fail;
 882   }
 883
 884   /* --- Collect the selected MAC, and check the tag length --- *
 885    *
 886    * Of course, there isn't a separate MAC, so only accept `aead'.
 887    */
 888
 889   p = key_getattr(kf, k, "tagsz");
 890   if (!p) {
 891     p = key_getattr(kf, k, "mac");
 892     if (strncmp(p, "aead", 4) != 0 || (p[4] && p[4] != '/')) {
 893       a_format(e, "unknown-mac", "%s", p, A_END);
 894       goto fail;
 895     }
 896     if (p[4] == '/') p += 5;
 897     else p = 0;
 898   }
 899   if (!p)
 900     a->tsz = keysz(0, a->c->tagsz);
 901   else {
 902     n = strtoul(p, &qq, 0);
 903     if (*qq) {
 904       a_format(e, "bad-tag-length-string", "%s", p, A_END);
 905       goto fail;
 906     }
 907     if (n%8 || (a->tsz = keysz(n/8, a->c->tagsz)) == 0)
 908       { a_format(e, "bad-tag-length", "%lu", n, A_END); goto fail; }
 909   }
 910
 911   /* --- Check that an empty message gives an empty ciphertext --- *
 912    *
 913    * This is necessary for producing challenges.  If the overhead is zero
 914    * then we're fine; otherwise, we have to check the hard way.
 915    */
 916
 917   if (a->c->ohd) {
 918     ksz = keysz(0, a->c->keysz);
 919     memset(buf_t, 0, ksz > a->nsz ? ksz : a->nsz);
 920     kk = GAEAD_KEY(a->c, buf_t, ksz);
 921     if (gaead_encrypt(kk, buf_t, a->nsz,
 922                       buf_t, ksz,
 923                       0, 0,
 924                       buf_t, &csz,
 925                       buf_t, a->tsz)) {
 926       a_format(e, "unsuitable-aead-cipher", "%s", a->c->name,
 927                "nonempty-ciphertext-for-empty-message", A_END);
 928       goto fail;
 929     }
 930     GAEAD_DESTROY(kk); kk = 0;
 931   }
 932
 933   return (&a->_b);
 934 fail:
 935   if (kk) GAEAD_DESTROY(kk);
 936   DESTROY(a);
 937   return (0);
 938 }
 939
 940 #ifndef NTRACE
 941 static void aead_tracealgs(const bulkalgs *aa)
 942 {
 943   const aead_algs *a = (const aead_algs *)aa;
 944
 945   trace(T_CRYPTO, "crypto: cipher = %s", a->c->name);
 946   trace(T_CRYPTO, "crypto: noncesz = %lu", (unsigned long)a->nsz);
 947   trace(T_CRYPTO, "crypto: tagsz = %lu", (unsigned long)a->tsz);
 948 }
 949 #endif
 950
 951 static int aead_checkalgs(bulkalgs *aa, const algswitch *asw, dstr *e)
 952 {
 953   aead_algs *a = (aead_algs *)aa;
 954
 955   if ((a->ksz = keysz(asw->hashsz, a->c->keysz)) == 0) {
 956     a_format(e, "cipher", "%s", a->c->name,
 957              "no-key-size", "%lu", (unsigned long)asw->hashsz,
 958              A_END);
 959     return (-1);
 960   }
 961   return (0);
 962 }
 963
 964 static int aead_samealgsp(const bulkalgs *aa, const bulkalgs *bb)
 965 {
 966   const aead_algs *a = (const aead_algs *)aa,
 967     *b = (const aead_algs *)bb;
 968   return (a->c == b->c && a->tsz == b->tsz);
 969 }
 970
 971 static void aead_alginfo(const bulkalgs *aa, admin *adm)
 972 {
 973   const aead_algs *a = (const aead_algs *)aa;
 974   a_info(adm, "cipher=%s", a->c->name,
 975          "cipher-keysz=%lu", (unsigned long)a->ksz,
 976          A_END);
 977   a_info(adm, "mac=aead", "mac-tagsz=%lu", (unsigned long)a->tsz, A_END);
 978 }
 979
 980 static size_t aead_overhead(const bulkalgs *aa)
 981 {
 982   const aead_algs *a = (const aead_algs *)aa;
 983   return (a->tsz + SEQSZ + a->c->ohd);
 984 }
 985
 986 static size_t aead_expsz(const bulkalgs *aa)
 987 {
 988   const aead_algs *a = (const aead_algs *)aa;
 989   return (a->c->blksz < 16 ? MEG(64) : MEG(2048));
 990 }
 991
 992 static bulkctx *aead_genkeys(const bulkalgs *aa, const deriveargs *da)
 993 {
 994   const aead_algs *a = (const aead_algs *)aa;
 995   aead_ctx *bc = CREATE(aead_ctx);
 996   octet k[MAXHASHSZ];
 997   int i;
 998
 999   for (i = 0; i < NDIR; i++) {
1000     if (!(da->f&(1 << i))) { bc->d[i].k = 0; continue; }
1001     derivekey(k, a->ksz, da, i, "encryption");
1002     bc->d[i].k = GAEAD_KEY(a->c, k, a->ksz);
1003   }
1004   bc->nsz = a->nsz; bc->tsz = a->tsz;
1005   return (&bc->_b);
1006 }
1007
1008 typedef struct aead_chal {
1009   bulkchal _b;
1010   gaead_key *k;
1011 } aead_chal;
1012
1013 static bulkchal *aead_genchal(const bulkalgs *aa)
1014 {
1015   const aead_algs *a = (const aead_algs *)aa;
1016   aead_chal *c = CREATE(aead_chal);
1017   rand_get(RAND_GLOBAL, buf_t, a->ksz);
1018   c->k = GAEAD_KEY(a->c, buf_t, a->ksz);
1019   IF_TRACING(T_CHAL, {
1020     trace(T_CHAL, "chal: generated new challenge key");
1021     trace_block(T_CRYPTO, "chal: new key", buf_t, a->ksz);
1022   })
1023   c->_b.tagsz = a->tsz;
1024   return (&c->_b);
1025 }
1026
1027 static int aead_chaltag(bulkchal *bc, const void *m, size_t msz,
1028                         uint32 seq, void *t)
1029 {
1030   aead_chal *c = (aead_chal *)bc;
1031   octet b[AEAD_NONCEMAX];
1032   size_t nsz = keysz_pad(4, c->k->ops->c->noncesz);
1033   size_t csz = 0;
1034   int rc;
1035
1036   assert(nsz); assert(nsz <= sizeof(b));
1037   memset(b, 0, nsz - 4); STORE32(b + nsz - 4, seq);
1038   rc = gaead_encrypt(c->k, b, nsz, m, msz, 0, 0,
1039                      buf_t, &csz, t, c->_b.tagsz);
1040   assert(!rc);
1041   return (0);
1042 }
1043
1044 static int aead_chalvrf(bulkchal *bc, const void *m, size_t msz,
1045                            uint32 seq, const void *t)
1046 {
1047   aead_chal *c = (aead_chal *)bc;
1048   octet b[AEAD_NONCEMAX];
1049   size_t nsz = keysz(4, c->k->ops->c->noncesz);
1050   size_t psz = 0;
1051   int rc;
1052
1053   assert(nsz); assert(nsz <= sizeof(b));
1054   memset(b, 0, nsz - 4); STORE32(b + nsz - 4, seq);
1055   rc = gaead_decrypt(c->k, b, nsz, m, msz, 0, 0,
1056                      buf_t, &psz, t, c->_b.tagsz);
1057   assert(rc >= 0);
1058   return (rc == 1 ? 0 : -1);
1059 }
1060
1061 static void aead_freechal(bulkchal *bc)
1062   { aead_chal *c = (aead_chal *)bc; GAEAD_DESTROY(c->k); DESTROY(c); }
1063
1064 static void aead_freealgs(bulkalgs *aa)
1065   { aead_algs *a = (aead_algs *)aa; DESTROY(a); }
1066
1067 static void aead_freectx(bulkctx *bbc)
1068 {
1069   aead_ctx *bc = (aead_ctx *)bbc;
1070   int i;
1071
1072   for (i = 0; i < NDIR; i++) { if (bc->d[i].k) GAEAD_DESTROY(bc->d[i].k); }
1073   DESTROY(bc);
1074 }
1075
1076 static int aead_encrypt(bulkctx *bbc, unsigned ty,
1077                         buf *b, buf *bb, uint32 seq)
1078 {
1079   aead_ctx *bc = (aead_ctx *)bbc;
1080   const octet *p = BCUR(b);
1081   gaead_key *k = bc->d[DIR_OUT].k;
1082   size_t sz = BLEFT(b);
1083   size_t csz = sz + k->ops->c->ohd;
1084   octet *qmac, *qseq, *qpk;
1085   octet n[AEAD_NONCEMAX];
1086   int rc;
1087
1088   assert(k);
1089
1090   if (buf_ensure(bb, bc->tsz + SEQSZ + csz)) return (0);
1091   qmac = BCUR(bb); qseq = qmac + bc->tsz; qpk = qseq + SEQSZ;
1092   STORE32(qseq, seq);
1093
1094   assert(bc->nsz <= sizeof(n));
1095   memcpy(n, qseq, SEQSZ); STORE32(n + SEQSZ, ty);
1096   if (bc->nsz > 8) memset(n + 8, 0, bc->nsz - 8);
1097   TRACE_IV(n, bc->nsz);
1098
1099   rc = gaead_encrypt(k, n, bc->nsz, 0, 0, p, sz, qpk, &csz, qmac, bc->tsz);
1100   assert(!rc);
1101   BSTEP(bb, bc->tsz + SEQSZ + csz);
1102   TRACE_CT(qpk, csz);
1103   TRACE_MAC(qmac, bc->tsz);
1104
1105   return (0);
1106 }
1107
1108 static int aead_decrypt(bulkctx *bbc, unsigned ty,
1109                        buf *b, buf *bb, uint32 *seq)
1110 {
1111   aead_ctx *bc = (aead_ctx *)bbc;
1112   gaead_key *k = bc->d[DIR_IN].k;
1113   const octet *pmac, *pseq, *ppk;
1114   size_t psz = BLEFT(b);
1115   size_t sz;
1116   octet *q = BCUR(bb);
1117   octet n[AEAD_NONCEMAX];
1118   int rc;
1119
1120   assert(k);
1121
1122   if (psz < bc->tsz + SEQSZ) {
1123     T( trace(T_KEYSET, "keyset: block too small for keyset"); )
1124     return (KSERR_MALFORMED);
1125   }
1126   sz = psz - bc->tsz - SEQSZ;
1127   pmac = BCUR(b); pseq = pmac + bc->tsz; ppk = pseq + SEQSZ;
1128
1129   assert(bc->nsz <= sizeof(n));
1130   memcpy(n, pseq, SEQSZ); STORE32(n + SEQSZ, ty);
1131   if (bc->nsz > 8) memset(n + 8, 0, bc->nsz - 8);
1132   TRACE_IV(n, bc->nsz);
1133
1134   rc = gaead_decrypt(k, n, bc->nsz, 0, 0, ppk, sz, q, &sz, pmac, bc->tsz);
1135   assert(rc >= 0);
1136   if (!rc) { TRACE_MACERR(pmac, bc->tsz); return (KSERR_DECRYPT); }
1137
1138   *seq = LOAD32(pseq);
1139   BSTEP(bb, sz);
1140   return (0);
1141 }
1142
1143 /*----- The NaCl box transform --------------------------------------------*
1144  *
1145  * This transform is very similar to the NaCl `crypto_secretbox' transform
1146  * described in Bernstein, `Cryptography in NaCl', with the difference that,
1147  * rather than using XSalsa20, we use either Salsa20/r or ChaChar, because we
1148  * have no need of XSalsa20's extended nonce.  The default cipher is Salsa20.
1149  *
1150  * Salsa20 and ChaCha accept a 64-bit nonce.  The low 32 bits are the
1151  * sequence number, and the high 32 bits are the type, both big-endian.
1152  *
1153  *              +------+------+
1154  *              | seq  | type |
1155  *              +------+------+
1156  *                 32     32
1157  *
1158  * A stream is generated by concatenating the raw output blocks generated
1159  * with this nonce and successive counter values starting from zero.  The
1160  * first 32 bytes of the stream are used as a key for Poly1305: the first 16
1161  * bytes are the universal hash key r, and the second 16 bytes are the mask
1162  * value s.
1163  *
1164  *              +------+------+ +------...------+
1165  *              |  r   |  s   | |   keystream   |
1166  *              +------+------+ +------...------+
1167  *                128    128           sz
1168  *
1169  * The remainder of the stream is XORed with the incoming plaintext to form a
1170  * ciphertext with the same length.  The ciphertext (only) is then tagged
1171  * using Poly1305.  The tag, sequence number, and ciphertext are concatenated
1172  * in this order, and transmitted.
1173  *
1174  *
1175  *              +---...---+------+------...------+
1176  *              |   tag   | seq  |   ciphertext  |
1177  *              +---...---+------+------...------+
1178  *                  128     32          sz
1179  *
1180  * Note that there is no need to authenticate the type separately, since it
1181  * was used to select the cipher nonce, and hence the Poly1305 key.  The
1182  * Poly1305 tag length is fixed.
1183  */
1184
1185 typedef struct naclbox_algs {
1186   aead_algs _b;
1187   const gccipher *c;
1188 } naclbox_algs;
1189
1190 static bulkalgs *naclbox_getalgs(const algswitch *asw, dstr *e,
1191                                  key_file *kf, key *k)
1192 {
1193   naclbox_algs *a = CREATE(naclbox_algs);
1194   const char *p;
1195   char *qq;
1196   unsigned long n;
1197
1198   /* --- Collect the selected cipher and check that it's supported --- */
1199
1200   p = key_getattr(kf, k, "cipher");
1201   if (!p || strcmp(p, "salsa20") == 0)
1202     { a->_b.c = &salsa20_naclbox; a->c = &salsa20; }
1203   else if (strcmp(p, "salsa20/12") == 0)
1204     { a->_b.c = &salsa2012_naclbox; a->c = &salsa2012; }
1205   else if (strcmp(p, "salsa20/8") == 0)
1206     { a->_b.c = &salsa208_naclbox; a->c = &salsa208; }
1207   else if (strcmp(p, "chacha20") == 0)
1208     { a->_b.c = &chacha20_naclbox; a->c = &chacha20; }
1209   else if (strcmp(p, "chacha12") == 0)
1210     { a->_b.c = &chacha12_naclbox; a->c = &chacha12; }
1211   else if (strcmp(p, "chacha8") == 0)
1212     { a->_b.c = &chacha8_naclbox; a->c = &chacha8; }
1213   else {
1214     a_format(e, "unknown-cipher", "%s", p, A_END);
1215     goto fail;
1216   }
1217   a->_b.nsz = 8;
1218
1219   /* --- Collect the selected MAC, and check the tag length --- */
1220
1221   p = key_getattr(kf, k, "mac");
1222   if (!p)
1223     ;
1224   else if (strncmp(p, "poly1305", 8) != 0 || (p[8] && p[8] != '/')) {
1225     a_format(e, "unknown-mac", "%s", p, A_END);
1226     goto fail;
1227   } else if (p[8] == '/') {
1228     n = strtoul(p + 9, &qq, 0);
1229     if (*qq) {
1230       a_format(e, "bad-tag-length-string", "%s", p + 9, A_END);
1231       goto fail;
1232     }
1233     if (n != 128) {
1234       a_format(e, "bad-tag-length", "%lu", n, A_END);
1235       goto fail;
1236     }
1237   }
1238   a->_b.tsz = 16;
1239
1240   return (&a->_b._b);
1241 fail:
1242   DESTROY(a);
1243   return (0);
1244 }
1245
1246 #ifndef NTRACE
1247 static void naclbox_tracealgs(const bulkalgs *aa)
1248 {
1249   const naclbox_algs *a = (const naclbox_algs *)aa;
1250
1251   trace(T_CRYPTO, "crypto: cipher = %s", a->c->name);
1252   trace(T_CRYPTO, "crypto: mac = poly1305/128");
1253 }
1254 #endif
1255
1256 #define naclbox_checkalgs aead_checkalgs
1257 #define naclbox_samealgsp aead_samealgsp
1258
1259 static void naclbox_alginfo(const bulkalgs *aa, admin *adm)
1260 {
1261   const naclbox_algs *a = (const naclbox_algs *)aa;
1262   a_info(adm, "cipher=%s", a->c->name, "cipher-keysz=32", A_END);
1263   a_info(adm, "mac=poly1305", "mac-tagsz=16", A_END);
1264 }
1265
1266 #define naclbox_overhead aead_overhead
1267 #define naclbox_expsz aead_expsz
1268 #define naclbox_genkeys aead_genkeys
1269
1270 typedef struct naclbox_chal {
1271   bulkchal _b;
1272   gcipher *c;
1273 } naclbox_chal;
1274
1275 static bulkchal *naclbox_genchal(const bulkalgs *aa)
1276 {
1277   const naclbox_algs *a = (const naclbox_algs *)aa;
1278   naclbox_chal *c = CREATE(naclbox_chal);
1279   rand_get(RAND_GLOBAL, buf_t, a->_b.ksz);
1280   c->c = GC_INIT(a->c, buf_t, a->_b.ksz);
1281   IF_TRACING(T_CHAL, {
1282     trace(T_CHAL, "chal: generated new challenge key");
1283     trace_block(T_CRYPTO, "chal: new key", buf_t, a->_b.ksz);
1284   })
1285   c->_b.tagsz = POLY1305_TAGSZ;
1286   return (&c->_b);
1287 }
1288
1289 static int naclbox_chaltag(bulkchal *bc, const void *m, size_t msz,
1290                            uint32 seq, void *t)
1291 {
1292   naclbox_chal *c = (naclbox_chal *)bc;
1293   poly1305_key pk;
1294   poly1305_ctx pm;
1295   octet b[POLY1305_KEYSZ + POLY1305_MASKSZ];
1296
1297   assert(SALSA20_NONCESZ <= sizeof(b));
1298   memset(b, 0, SALSA20_NONCESZ - 4); STORE32(b + SALSA20_NONCESZ - 4, seq);
1299   GC_SETIV(c->c, b); GC_ENCRYPT(c->c, 0, b, sizeof(b));
1300   poly1305_keyinit(&pk, b, POLY1305_KEYSZ);
1301   poly1305_macinit(&pm, &pk, b + POLY1305_KEYSZ);
1302   if (msz) poly1305_hash(&pm, m, msz);
1303   poly1305_done(&pm, t);
1304   return (0);
1305 }
1306
1307 static int naclbox_chalvrf(bulkchal *bc, const void *m, size_t msz,
1308                            uint32 seq, const void *t)
1309 {
1310   naclbox_chal *c = (naclbox_chal *)bc;
1311   poly1305_key pk;
1312   poly1305_ctx pm;
1313   octet b[POLY1305_KEYSZ + POLY1305_MASKSZ];
1314
1315   assert(SALSA20_NONCESZ <= sizeof(b));
1316   memset(b, 0, SALSA20_NONCESZ - 4); STORE32(b + SALSA20_NONCESZ - 4, seq);
1317   GC_SETIV(c->c, b); GC_ENCRYPT(c->c, 0, b, sizeof(b));
1318   poly1305_keyinit(&pk, b, POLY1305_KEYSZ);
1319   poly1305_macinit(&pm, &pk, b + POLY1305_KEYSZ);
1320   if (msz) poly1305_hash(&pm, m, msz);
1321   assert(POLY1305_TAGSZ <= sizeof(b)); poly1305_done(&pm, b);
1322   return (ct_memeq(t, b, POLY1305_TAGSZ) ? 0 : -1);
1323 }
1324
1325 static void naclbox_freechal(bulkchal *bc)
1326   { naclbox_chal *c = (naclbox_chal *)bc; GC_DESTROY(c->c); DESTROY(c); }
1327
1328 static void naclbox_freealgs(bulkalgs *aa)
1329   { naclbox_algs *a = (naclbox_algs *)aa; DESTROY(a); }
1330
1331 #define naclbox_freectx aead_freectx
1332 #define naclbox_encrypt aead_encrypt
1333 #define naclbox_decrypt aead_decrypt
1334
1335 /*----- Bulk crypto transform table ---------------------------------------*/
1336
1337 const bulkops bulktab[] = {
1338
1339 #define COMMA ,
1340
1341 #define BULK(name, pre)                                                 \
1342   { name, pre##_getalgs, T( pre##_tracealgs COMMA )                     \
1343     pre##_checkalgs, pre##_samealgsp,                                   \
1344     pre##_alginfo, pre##_overhead, pre##_expsz,                         \
1345     pre##_genkeys, pre##_genchal, pre##_freealgs,                       \
1346     pre##_encrypt, pre##_decrypt, pre##_freectx,                        \
1347     pre##_chaltag, pre##_chalvrf, pre##_freechal }
1348
1349   BULK("v0", v0),
1350   BULK("iiv", iiv),
1351   BULK("aead", aead),
1352   BULK("naclbox", naclbox),
1353
1354 #undef BULK
1355   { 0 }
1356 };
1357
1358 /*----- That's all, folks -------------------------------------------------*/