+/*----- Bulk crypto -------------------------------------------------------*/
+
+/* --- NaCl `secretbox' --- */
+
+typedef struct naclbox_encctx {
+ bulk b;
+ const gccipher *cc;
+ gcipher *c;
+} naclbox_encctx;
+
+static bulk *naclbox_init(key *k, const char *calg, const char *halg)
+{
+ naclbox_encctx *ctx = CREATE(naclbox_encctx);
+ dstr t = DSTR_INIT;
+ const char *q;
+
+ key_fulltag(k, &t);
+
+ if ((q = key_getattr(0, k, "cipher")) != 0) calg = q;
+ if (!calg || strcmp(calg, "salsa20") == 0) ctx->cc = &salsa20;
+ else if (strcmp(calg, "salsa20/12") == 0) ctx->cc = &salsa2012;
+ else if (strcmp(calg, "salsa20/8") == 0) ctx->cc = &salsa208;
+ else if (strcmp(calg, "chacha20") == 0) ctx->cc = &chacha20;
+ else if (strcmp(calg, "chacha12") == 0) ctx->cc = &chacha12;
+ else if (strcmp(calg, "chacha8") == 0) ctx->cc = &chacha8;
+ else {
+ die(EXIT_FAILURE,
+ "unknown or inappropriate encryption scheme `%s' in key `%s'",
+ calg, t.buf);
+ }
+
+ dstr_destroy(&t);
+ return (&ctx->b);
+}
+
+static int naclbox_setup(bulk *b, gcipher *cx)
+{
+ naclbox_encctx *ctx = (naclbox_encctx *)b;
+ octet k[SALSA20_KEYSZ];
+
+ GC_ENCRYPT(cx, 0, k, sizeof(k));
+ ctx->c = GC_INIT(ctx->cc, k, sizeof(k));
+ return (0);
+}
+
+static size_t naclbox_overhead(bulk *b) { return (POLY1305_TAGSZ); }
+
+static void naclbox_destroy(bulk *b)
+{
+ naclbox_encctx *ctx = (naclbox_encctx *)b;
+
+ GC_DESTROY(ctx->c);
+ DESTROY(ctx);
+}
+
+static const char *naclbox_encdoit(bulk *b, uint32 seq, buf *bb,
+ const void *p, size_t sz)
+{
+ naclbox_encctx *ctx = (naclbox_encctx *)b;
+ octet t[32];
+ poly1305_key ak;
+ poly1305_ctx a;
+ octet *tag, *ct;
+
+ STORE32(t, seq); STORE32(t + 4, 0); GC_SETIV(ctx->c, t);
+ GC_ENCRYPT(ctx->c, 0, t, POLY1305_KEYSZ + POLY1305_MASKSZ);
+ poly1305_keyinit(&ak, t, POLY1305_KEYSZ);
+ poly1305_macinit(&a, &ak, t + POLY1305_KEYSZ);
+
+ tag = buf_get(bb, POLY1305_TAGSZ); assert(tag);
+ ct = buf_get(bb, sz); assert(ct);
+ GC_ENCRYPT(ctx->c, p, ct, sz);
+ poly1305_hash(&a, ct, sz);
+ poly1305_done(&a, tag);
+ return (0);
+}
+
+static const char *naclbox_decdoit(bulk *b, uint32 seq, buf *bb,
+ const void *p, size_t sz)
+{
+ naclbox_encctx *ctx = (naclbox_encctx *)b;
+ buf bin;
+ octet t[32];
+ poly1305_key ak;
+ poly1305_ctx a;
+ octet *tag, *ct, *pt;
+
+ STORE32(t, seq); STORE32(t + 4, 0); GC_SETIV(ctx->c, t);
+ GC_ENCRYPT(ctx->c, 0, t, POLY1305_KEYSZ + POLY1305_MASKSZ);
+ poly1305_keyinit(&ak, t, POLY1305_KEYSZ);
+ poly1305_macinit(&a, &ak, t + POLY1305_KEYSZ);
+
+ buf_init(&bin, (/*unconst*/ void *)p, sz);
+ if ((tag = buf_get(&bin, POLY1305_TAGSZ)) == 0) return ("no tag");
+ ct = BCUR(&bin); sz = BLEFT(&bin);
+ poly1305_hash(&a, ct, sz);
+ poly1305_done(&a, t);
+ if (!ct_memeq(t, tag, POLY1305_TAGSZ)) return ("authentication failure");
+ pt = buf_get(bb, sz); assert(pt);
+ GC_DECRYPT(ctx->c, ct, pt, sz);
+ return (0);
+}
+
+static const bulkops naclbox_encops = {
+ naclbox_init, naclbox_setup, naclbox_overhead,
+ naclbox_encdoit, naclbox_destroy
+}, naclbox_decops = {
+ naclbox_init, naclbox_setup, naclbox_overhead,
+ naclbox_decdoit, naclbox_destroy
+};
+
+/* --- Generic composition --- */
+
+typedef struct gencomp_encctx {
+ bulk b;
+ const gccipher *cc;
+ const gcmac *mc;
+ gcipher *c, *cx;
+ gmac *m;
+ octet *t; size_t tsz;
+} gencomp_encctx;
+
+static bulk *gencomp_init(key *k, const char *calg, const char *halg)
+{
+ gencomp_encctx *ctx = CREATE(gencomp_encctx);
+ const char *q;
+ dstr d = DSTR_INIT, t = DSTR_INIT;
+
+ key_fulltag(k, &t);
+
+ if ((q = key_getattr(0, k, "cipher")) != 0) calg = q;
+ if (!calg) ctx->cc = &blowfish_cbc;
+ else if ((ctx->cc = gcipher_byname(calg)) == 0) {
+ die(EXIT_FAILURE, "encryption scheme `%s' not found in key `%s'",
+ calg, t.buf);
+ }
+
+ dstr_reset(&d);
+ if ((q = key_getattr(0, k, "mac")) == 0) {
+ dstr_putf(&d, "%s-hmac", halg);
+ q = d.buf;
+ }
+ if ((ctx->mc = gmac_byname(q)) == 0) {
+ die(EXIT_FAILURE,
+ "message authentication code `%s' not found in key `%s'",
+ q, t.buf);
+ }
+
+ return (&ctx->b);
+}
+
+static int gencomp_setup(bulk *b, gcipher *cx)
+{
+ gencomp_encctx *ctx = (gencomp_encctx *)b;
+ size_t cn, mn, n;
+ octet *kd;
+
+ ctx->cx = cx;
+ n = ctx->cc->blksz;
+ cn = keysz(0, ctx->cc->keysz); if (cn > n) n = cn;
+ mn = keysz(0, ctx->mc->keysz); if (mn > n) n = mn;
+ ctx->t = kd = xmalloc(n); ctx->tsz = n;
+ GC_ENCRYPT(cx, 0, kd, cn);
+ ctx->c = GC_INIT(ctx->cc, kd, cn);
+ GC_ENCRYPT(cx, 0, kd, mn);
+ ctx->m = GM_KEY(ctx->mc, kd, mn);
+ return (0);
+}
+
+static size_t gencomp_overhead(bulk *b)
+{
+ gencomp_encctx *ctx = (gencomp_encctx *)b;
+ return (ctx->cc->blksz + ctx->mc->hashsz); }
+
+static void gencomp_destroy(bulk *b)
+{
+ gencomp_encctx *ctx = (gencomp_encctx *)b;
+
+ GC_DESTROY(ctx->c);
+ GC_DESTROY(ctx->m);
+ xfree(ctx->t);
+ DESTROY(ctx);
+}
+
+static const char *gencomp_encdoit(bulk *b, uint32 seq, buf *bb,
+ const void *p, size_t sz)
+{
+ gencomp_encctx *ctx = (gencomp_encctx *)b;
+ octet *tag, *ct;
+ ghash *h = GM_INIT(ctx->m);
+
+ GH_HASHU32(h, seq);
+ if (ctx->cc->blksz) {
+ GC_ENCRYPT(ctx->cx, 0, ctx->t, ctx->cc->blksz);
+ GC_SETIV(ctx->c, ctx->t);
+ }
+ tag = buf_get(bb, ctx->mc->hashsz); assert(tag);
+ ct = buf_get(bb, sz); assert(ct);
+ GC_ENCRYPT(ctx->c, p, ct, sz);
+ GH_HASH(h, ct, sz);
+ GH_DONE(h, tag);
+ GH_DESTROY(h);
+ return (0);
+}
+
+static const char *gencomp_decdoit(bulk *b, uint32 seq, buf *bb,
+ const void *p, size_t sz)
+{
+ gencomp_encctx *ctx = (gencomp_encctx *)b;
+ buf bin;
+ const octet *tag, *ct;
+ octet *pt;
+ ghash *h;
+ int ok;
+
+ buf_init(&bin, (/*unconst*/ void *)p, sz);
+ if ((tag = buf_get(&bin, ctx->mc->hashsz)) == 0) return ("no tag");
+ ct = BCUR(&bin); sz = BLEFT(&bin);
+ pt = buf_get(bb, sz); assert(pt);
+
+ h = GM_INIT(ctx->m);
+ GH_HASHU32(h, seq);
+ GH_HASH(h, ct, sz);
+ ok = ct_memeq(tag, GH_DONE(h, 0), ctx->mc->hashsz);
+ GH_DESTROY(h);
+ if (!ok) return ("authentication failure");
+
+ if (ctx->cc->blksz) {
+ GC_ENCRYPT(ctx->cx, 0, ctx->t, ctx->cc->blksz);
+ GC_SETIV(ctx->c, ctx->t);
+ }
+ GC_DECRYPT(ctx->c, ct, pt, sz);
+ return (0);
+}
+
+static const bulkops gencomp_encops = {
+ gencomp_init, gencomp_setup, gencomp_overhead,
+ gencomp_encdoit, gencomp_destroy
+}, gencomp_decops = {
+ gencomp_init, gencomp_setup, gencomp_overhead,
+ gencomp_decdoit, gencomp_destroy
+};
+
+const struct bulktab bulktab[] = {
+ { "gencomp", &gencomp_encops, &gencomp_decops },
+ { "naclbox", &naclbox_encops, &naclbox_decops },
+ { 0, 0, 0 }
+};
+