math/Makefile.am, symm/Makefile.am: Use `--no-install' on oddball tests.

[catacomb] / progs / cc-kem.c

diff --git a/progs/cc-kem.c b/progs/cc-kem.c
index 4a2cf19..1e99e05 100644 (file)
--- a/progs/cc-kem.c
+++ b/progs/cc-kem.c
@@ -43,6 +43,8 @@
 #include "ec-keys.h"
 #include "dh.h"
 #include "rsa.h"
+#include "x25519.h"
+#include "x448.h"
 
 #include "rmd160.h"
 #include "blowfish-cbc.h"
@@ -602,6 +604,80 @@ static const kemops ec_decops = {
   ec_decinit, dh_decdoit, dh_enccheck, dh_encdestroy
 };
 
+/* --- X25519 and similar schemes --- */
+
+#define XDHS(_)                                                                \
+  _(x25519, X25519)                                                    \
+  _(x448, X448)
+
+#define XDHDEF(xdh, XDH)                                               \
+                                                                       \
+  static kem *xdh##_encinit(key *k, void *kd) { return (CREATE(kem)); }        \
+  static void xdh##_encdestroy(kem *k) { DESTROY(k); }                 \
+                                                                       \
+  static const char *xdh##_enccheck(kem *k)                            \
+  {                                                                    \
+    xdh##_pub *kd = k->kd;                                             \
+                                                                       \
+    if (kd->pub.sz != XDH##_PUBSZ)                                     \
+      return ("incorrect " #XDH "public key length");                  \
+    return (0);                                                                \
+  }                                                                    \
+                                                                       \
+  static int xdh##_encdoit(kem *k, dstr *d, ghash *h)                  \
+  {                                                                    \
+    octet t[XDH##_KEYSZ], z[XDH##_OUTSZ];                              \
+    xdh##_pub *kd = k->kd;                                             \
+                                                                       \
+    rand_get(RAND_GLOBAL, t, sizeof(t));                               \
+    dstr_ensure(d, XDH##_PUBSZ);                                       \
+    xdh((octet *)d->buf, t, xdh##_base);                               \
+    xdh(z, t, kd->pub.k);                                              \
+    d->len += XDH##_PUBSZ;                                             \
+    GH_HASH(h, d->buf, XDH##_PUBSZ);                                   \
+    GH_HASH(h, z, XDH##_OUTSZ);                                                \
+    return (0);                                                                \
+  }                                                                    \
+                                                                       \
+  static const char *xdh##_deccheck(kem *k)                            \
+  {                                                                    \
+    xdh##_priv *kd = k->kd;                                            \
+                                                                       \
+    if (kd->priv.sz != XDH##_KEYSZ)                                    \
+      return ("incorrect " #XDH " private key length");                        \
+    if (kd->pub.sz != XDH##_PUBSZ)                                     \
+      return ("incorrect " #XDH " public key length");                 \
+    return (0);                                                                \
+  }                                                                    \
+                                                                       \
+  static int xdh##_decdoit(kem *k, dstr *d, ghash *h)                  \
+  {                                                                    \
+    octet z[XDH##_OUTSZ];                                              \
+    xdh##_priv *kd = k->kd;                                            \
+    int rc = -1;                                                       \
+                                                                       \
+    if (d->len != XDH##_PUBSZ) goto done;                              \
+    xdh(z, kd->priv.k, (const octet *)d->buf);                         \
+    GH_HASH(h, d->buf, XDH##_PUBSZ);                                   \
+    GH_HASH(h, z, XDH##_OUTSZ);                                                \
+    rc = 0;                                                            \
+  done:                                                                        \
+    return (rc);                                                       \
+  }                                                                    \
+                                                                       \
+  static const kemops xdh##_encops = {                                 \
+    xdh##_pubfetch, sizeof(xdh##_pub),                                 \
+    xdh##_encinit, xdh##_encdoit, xdh##_enccheck, xdh##_encdestroy     \
+  };                                                                   \
+                                                                       \
+  static const kemops xdh##_decops = {                                 \
+    xdh##_privfetch, sizeof(xdh##_priv),                               \
+    xdh##_encinit, xdh##_decdoit, xdh##_deccheck, xdh##_encdestroy     \
+  };
+
+XDHS(XDHDEF)
+#undef XDHDEF
+
 /* --- Symmetric --- */
 
 typedef struct symm_ctx {
@@ -670,6 +746,10 @@ const struct kemtab kemtab[] = {
   { "dh",      &dh_encops,     &dh_decops },
   { "bindh",   &bindh_encops,  &bindh_decops },
   { "ec",      &ec_encops,     &ec_decops },
+#define XDHTAB(xdh, XDH)                                               \
+  { #xdh,      &xdh##_encops,  &xdh##_decops },
+  XDHS(XDHTAB)
+#undef XDHTAB
   { "symm",    &symm_encops,   &symm_decops },
   { 0,         0,              0 }
 };
@@ -780,16 +860,6 @@ k_found:;
        halg, t.buf);
   }
 
-  dstr_reset(&d);
-  if ((q = key_getattr(0, k, "kdf")) == 0) {
-    dstr_putf(&d, "%s-mgf", kk->hc->name);
-    q = d.buf;
-  }
-  if ((kk->cxc = gcipher_byname(q)) == 0) {
-    die(EXIT_FAILURE, "encryption scheme (KDF) `%s' not found in key `%s'",
-       q, t.buf);
-  }
-
   if (!balg)
     bt = bulktab;
   else {
@@ -807,6 +877,16 @@ k_found:;
   *bc = bo->init(k, balg, kk->hc->name);
   (*bc)->ops = bo;
 
+  dstr_reset(&d);
+  if ((q = key_getattr(0, k, "kdf")) == 0) {
+    dstr_putf(&d, "%s-mgf", kk->hc->name);
+    q = d.buf;
+  }
+  if ((kk->cxc = gcipher_byname(q)) == 0) {
+    die(EXIT_FAILURE, "encryption scheme (KDF) `%s' not found in key `%s'",
+       q, t.buf);
+  }
+
   /* --- Tidy up --- */
 
   dstr_destroy(&d);