chiark - git - mdw - catacomb/blob - pub/ed448.c

   1 /* -*-c-*-
   2  *
   3  * The Ed448 signature scheme
   4  *
   5  * (c) 2017 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 #include <string.h>
  31
  32 #include "fgoldi.h"
  33 #include "ed448.h"
  34 #include "scaf.h"
  35 #include "scmul.h"
  36 #include "sha3.h"
  37
  38 /*----- Key fetching ------------------------------------------------------*/
  39
  40 const key_fetchdef ed448_pubfetch[] = {
  41   { "pub",      offsetof(ed448_pub, pub),       KENC_BINARY,    0 },
  42   { 0,          0,                              0,              0 }
  43 };
  44
  45 static const key_fetchdef priv[] = {
  46   { "priv",     offsetof(ed448_priv, priv),     KENC_BINARY,    0 },
  47   { 0,          0,                              0,              0 }
  48 };
  49
  50 const key_fetchdef ed448_privfetch[] = {
  51   { "pub",      offsetof(ed448_priv, pub),      KENC_BINARY,    0 },
  52   { "private",  0,                              KENC_STRUCT,    priv },
  53   { 0,          0,                              0,              0 }
  54 };
  55
  56 /*----- A number of magic numbers -----------------------------------------*/
  57
  58 #if SCAF_IMPL == 32
  59 # define PIECEWD 24
  60   static const scaf_piece l[] = {
  61     0x5844f3, 0xc292ab, 0x552378, 0x8dc58f, 0x6cc272,
  62     0x369021, 0x49aed6, 0xc44edb, 0xca23e9, 0xffff7c,
  63     0xffffff, 0xffffff, 0xffffff, 0xffffff, 0xffffff,
  64     0xffffff, 0xffffff, 0xffffff, 0x003fff
  65   };
  66   static const scaf_piece mu[] = {
  67     0xe0d00a, 0x4a7bb0, 0x73d6d5, 0x0aadc8, 0xd723a7,
  68     0xe933d8, 0x9c96fd, 0x4b6512, 0x63bb12, 0x335dc1,
  69     0x000008, 0x000000, 0x000000, 0x000000, 0x000000,
  70     0x000000, 0x000000, 0x000000, 0x000000, 0x000400
  71  };
  72 #endif
  73
  74 #if SCAF_IMPL == 16
  75 # define PIECEWD 12
  76   static const scaf_piece l[] = {
  77     0x4f3, 0x584, 0x2ab, 0xc29, 0x378, 0x552, 0x58f, 0x8dc,
  78     0x272, 0x6cc, 0x021, 0x369, 0xed6, 0x49a, 0xedb, 0xc44,
  79     0x3e9, 0xca2, 0xf7c, 0xfff, 0xfff, 0xfff, 0xfff, 0xfff,
  80     0xfff, 0xfff, 0xfff, 0xfff, 0xfff, 0xfff, 0xfff, 0xfff,
  81     0xfff, 0xfff, 0xfff, 0xfff, 0xfff, 0x003
  82   };
  83   static const scaf_piece mu[] = {
  84     0x00a, 0xe0d, 0xbb0, 0x4a7, 0x6d5, 0x73d, 0xdc8, 0x0aa,
  85     0x3a7, 0xd72, 0x3d8, 0xe93, 0x6fd, 0x9c9, 0x512, 0x4b6,
  86     0xb12, 0x63b, 0xdc1, 0x335, 0x008, 0x000, 0x000, 0x000,
  87     0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
  88     0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x400
  89   };
  90 #endif
  91
  92 #define NPIECE SCAF_NPIECE(448, PIECEWD)
  93
  94 #if FGOLDI_IMPL == 28
  95 # define P p28
  96   static const fgoldi_piece bx_pieces[] = {
  97      118276190,  40534716,    9670182, -133293904,
  98       85017404,  -9262234,   68333083,  -96650682,
  99      -93461723,  15824511,   73756743,   57518561,
 100       94773951, -19783215,  107736334,   82941708
 101   }, by_pieces[] = {
 102       36764180,   8885695,  130592152,   20104429,
 103     -104530499,  30304196,  121295871,    5901357,
 104      125344798, -96893944,  -93097107,  -59366209,
 105        3626698,  38307682,   24032956,  110359655
 106   };
 107 #endif
 108 #if FGOLDI_IMPL == 12
 109 # define P p12
 110   static const fgoldi_piece bx_pieces[] = {
 111        94,   204,  -114,   523,   309,  -474,   313,  -511,    99, -1017,
 112       828,   276,  -822,   686,   -71,  -485,   299,   200,  -791,  -737,
 113       805,  -290,   -43,  -550,   121,    71,  -425,  -983,  -344,   439,
 114       703,   610,   555,   135,  -151,  -754,  -321,   397,  -420,   633
 115   }, by_pieces[] = {
 116     -1516,   784,   -28,  -425,    68,  -616,  -885,  -592,   788,   153,
 117      -579,  -944,   116,   415,   231,  1023,   941,  -594,    49,    45,
 118      -994,  -118,   271,  -496,  -739,   877,  -201,   -43,   147,  -453,
 119      1738,   885,  -960,   542,   292,  1724,  -277,  -797,   -46,   842
 120   };
 121 #endif
 122
 123 static const fgoldi_piece bz_pieces[NPIECE] = { 1, 0, /* ... */ };
 124 #define BX ((const fgoldi *)bx_pieces)
 125 #define BY ((const fgoldi *)by_pieces)
 126 #define BZ ((const fgoldi *)bz_pieces)
 127 #define D (-39081)
 128
 129 /*----- Point encoding and decoding ---------------------------------------*/
 130
 131 static void ptencode(octet q[57],
 132                      const fgoldi *X, const fgoldi *Y, const fgoldi *Z)
 133 {
 134   fgoldi x, y, t;
 135   octet b[56];
 136
 137   fgoldi_inv(&t, Z); fgoldi_mul(&x, X, &t); fgoldi_mul(&y, Y, &t);
 138   fgoldi_store(q, &y); fgoldi_store(b, &x); q[56] = (b[0]&1u) << 7;
 139 }
 140
 141 static int ptdecode(fgoldi *X, fgoldi *Y, fgoldi *Z, const octet q[57])
 142 {
 143   octet b[56];
 144   unsigned i, a;
 145   fgoldi t, u;
 146   uint32 m;
 147   int rc = 0;
 148
 149   /* Load the y-coordinate. */
 150   fgoldi_load(Y, q);
 151
 152   /* Check that the coordinate was in range.  If we store it, we'll get a
 153    * canonical version which we can compare against Q.  Also, check that the
 154    * extra bits in the top byte are zero.
 155    */
 156   fgoldi_store(b, Y);
 157   for (i = a = 0; i < 56; i++) a |= b[i] ^ q[i];
 158   a |= q[56]&0x7fu;
 159   a = ((a - 1) >> 8)&0x01u;             /* 0 |-> 1, non-0 |-> 0 */
 160   rc |= (int)a - 1;
 161
 162   /* Decompress the x-coordinate. */
 163   fgoldi_sqr(&t, Y); fgoldi_mulconst(&u, &t, D); t.P[0] -= 1; u.P[0] -= 1;
 164   rc |= fgoldi_quosqrt(X, &t, &u);
 165   fgoldi_store(b, X); m = -(uint32)(((q[56] >> 7) ^ b[0])&0x1u);
 166   fgoldi_condneg(X, X, m);
 167
 168   /* Set Z. */
 169   fgoldi_set(Z, 1);
 170
 171   /* And we're done. */
 172   return (rc);
 173 }
 174
 175 /*----- Edwards curve arithmetic ------------------------------------------*/
 176
 177 static void ptadd(fgoldi *X, fgoldi *Y, fgoldi *Z,
 178                   const fgoldi *X0, const fgoldi *Y0, const fgoldi *Z0,
 179                   const fgoldi *X1, const fgoldi *Y1, const fgoldi *Z1)
 180 {
 181   fgoldi t0, t1, t2, t3;
 182
 183   /* Bernstein and Lange, `Faster addition and doubling on elliptic curves',
 184    * 2007-09-06, https://cr.yp.to/newelliptic/newelliptic-20070906.pdf shows
 185    * the formulae as:
 186    *
 187    *    A = Z1 Z2;   B = A^2;   C = X1 X2;   D = Y1 Y2;
 188    *    E = d C D;   F = B - E;   G = B + E;
 189    *    X3 = A F ((X1 + Y1) (X2 + Y2) - C - D);
 190    *    Y3 = A G (D - C);   Z3 = c F G.
 191    *
 192    * But c = 1 here.
 193    */
 194
 195   fgoldi_mul(&t0, Z0, Z1);              /* t0 = A = Z0 Z1 */
 196   fgoldi_add(&t1, X0, Y0);              /* t1 = X0 + Y0 */
 197   fgoldi_add(&t2, X1, Y1);              /* t2 = X1 + Y1 */
 198   fgoldi_mul(&t1, &t1, &t2);            /* t1 = (X0 + Y0) (X1 + Y1) */
 199   fgoldi_mul(&t2, X0, X1);              /* t2 = C = X0 X1 */
 200   fgoldi_mul(&t3, Y0, Y1);              /* t3 = D = Y0 Y1 */
 201   fgoldi_sub(X, &t1, &t2);              /* X = (X0 + Y0) (X1 + Y1) - C */
 202   fgoldi_sub(X, X, &t3);                /* X = (X0 + Y0) (X1 + Y1) - C - D */
 203   fgoldi_sub(Y, &t3, &t2);              /* Y = D - C */
 204   fgoldi_mul(X, X, &t0);            /* X = A ((X0 + Y0) (X1 + Y1) - C - D) */
 205   fgoldi_mul(Y, Y, &t0);                /* Y = A (D - C) */
 206   fgoldi_sqr(&t0, &t0);                 /* t0 = B = A^2 */
 207   fgoldi_mul(&t1, &t2, &t3);            /* t1 = C D */
 208   fgoldi_mulconst(&t1, &t1, D);         /* t1 = E = d C D */
 209   fgoldi_sub(&t2, &t0, &t1);            /* t2 = F = B - E */
 210   fgoldi_add(&t1, &t0, &t1);            /* t1 = G = B + E */
 211   fgoldi_mul(X, X, &t2);          /* X = A F ((X0 + Y0) (X1 + Y1) - C - D) */
 212   fgoldi_mul(Y, Y, &t1);                /* Y = A G (D - C) */
 213   fgoldi_mul(Z, &t1, &t2);              /* Z = c F G */
 214 }
 215
 216 static void ptdbl(fgoldi *X, fgoldi *Y, fgoldi *Z,
 217                   const fgoldi *X0, const fgoldi *Y0, const fgoldi *Z0)
 218 {
 219   fgoldi t0, t1, t2;
 220
 221   /* Bernstein and Lange, `Faster addition and doubling on elliptic curves',
 222    * 2007-09-06, https://cr.yp.to/newelliptic/newelliptic-20070906.pdf shows
 223    * the formulae as:
 224    *
 225    *    B = (X1 + Y1)^2;   C = X1^2;   D = Y1^2;
 226    *    E = C + D;   H = (c Z1)^2;   J = E - 2 H;
 227    *    X3 = c (B - E) J;   Y3 = c E (C - D);   Z3 = E J
 228    *
 229    * But c = 1 here.
 230    */
 231
 232   fgoldi_add(&t0, X0, Y0);              /* t0 = X0 + Y0 */
 233   fgoldi_sqr(&t0, &t0);                 /* t0 = B = (X0 + Y0)^2 */
 234   fgoldi_sqr(&t1, X0);                  /* t1 = C = X0^2 */
 235   fgoldi_sqr(&t2, Y0);                  /* t2 = D = Y0^2 */
 236   fgoldi_add(Y, &t1, &t2);              /* Y = E = C + D */
 237   fgoldi_sub(&t1, &t1, &t2);            /* t1 = C - D */
 238   fgoldi_sub(X, &t0, Y);                /* X = c (B - E) */
 239   fgoldi_sqr(&t0, Z0);                  /* t0 = H = (c Z0)^2 */
 240   fgoldi_mulconst(&t0, &t0, 2);         /* t0 = 2 H */
 241   fgoldi_sub(&t0, Y, &t0);              /* t0 = J = E - 2 H */
 242   fgoldi_mul(X, X, &t0);                /* X = c (B - E) J */
 243   fgoldi_mul(Z, Y, &t0);                /* Z = E J */
 244   fgoldi_mul(Y, Y, &t1);                /* Y = c E (C - D) */
 245 }
 246
 247 static DEFINE_SCMUL(ptmul, fgoldi, 4, PIECEWD, NPIECE, ptadd, ptdbl)
 248 static DEFINE_SCSIMMUL(ptsimmul, fgoldi, 2, PIECEWD, NPIECE, ptadd, ptdbl)
 249
 250 /*----- Key derivation utilities ------------------------------------------*/
 251
 252 static void unpack_key(scaf_piece a[NPIECE], octet h1[57],
 253                        const octet *k, size_t ksz)
 254 {
 255   shake_ctx h;
 256   octet b[57];
 257
 258   shake256_init(&h); shake_hash(&h, k, ksz);
 259   shake_xof(&h); shake_get(&h, b, sizeof(b));
 260   b[0] &= 0xfcu; b[55] |= 0x80u; scaf_load(a, b, 56, NPIECE, PIECEWD);
 261   if (h1) shake_get(&h, h1, 57);
 262 }
 263
 264 #define PREFIX_BUFSZ 266
 265 static size_t prefix(octet b[PREFIX_BUFSZ],
 266                      int phflag, const octet *p, size_t psz)
 267 {
 268   memcpy(b, "SigEd448", 8);
 269   b[8] = phflag;
 270   assert(psz <= ED448_MAXPERSOSZ); b[9] = psz; memcpy(b + 10, p, psz);
 271   return (psz + 10);
 272 }
 273
 274 /*----- Main code ---------------------------------------------------------*/
 275
 276 /* --- @ed448_pubkey@ --- *
 277  *
 278  * Arguments:   @octet K[ED448_PUBSZ]@ = where to put the public key
 279  *              @const void *k@ = private key
 280  *              @size_t ksz@ = length of private key
 281  *
 282  * Returns:     ---
 283  *
 284  * Use:         Derives the public key from a private key.
 285  */
 286
 287 void ed448_pubkey(octet K[ED448_PUBSZ], const void *k, size_t ksz)
 288 {
 289   scaf_piece a[NPIECE];
 290   fgoldi AX, AY, AZ;
 291
 292   unpack_key(a, 0, k, ksz);
 293   ptmul(&AX, &AY, &AZ, a, BX, BY, BZ);
 294   ptencode(K, &AX, &AY, &AZ);
 295 }
 296
 297 /* --- @ed448_sign@ --- *
 298  *
 299  * Arguments:   @octet sig[ED448_SIGSZ]@ = where to put the signature
 300  *              @const void *k@ = private key
 301  *              @size_t ksz@ = length of private key
 302  *              @const octet K[ED448_PUBSZ]@ = public key
 303  *              @int phflag@ = whether the `message' has been hashed already
 304  *              @const void *p@ = personalization string
 305  *              @size_t psz@ = length of personalization string
 306  *              @const void *m@ = message to sign
 307  *              @size_t msz@ = length of message
 308  *
 309  * Returns:     ---
 310  *
 311  * Use:         Signs a message.
 312  */
 313
 314 void ed448_sign(octet sig[ED448_SIGSZ],
 315                 const void *k, size_t ksz, const octet K[ED448_PUBSZ],
 316                 int phflag, const void *p, size_t psz,
 317                 const void *m, size_t msz)
 318 {
 319   shake_ctx h;
 320   scaf_piece a[NPIECE], r[NPIECE], t[NPIECE], scratch[3*NPIECE];
 321   scaf_dblpiece tt[2*NPIECE];
 322   fgoldi RX, RY, RZ;
 323   octet h1[57], pb[PREFIX_BUFSZ], rb[114];
 324   unsigned i;
 325
 326   /* Get my private key. */
 327   unpack_key(a, h1, k, ksz);
 328
 329   /* Determine the prefix string. */
 330   psz = prefix(pb, phflag, p, psz);
 331
 332   /* Select the nonce and the vector part. */
 333   shake256_init(&h);
 334   shake_hash(&h, pb, psz);
 335   shake_hash(&h, h1, sizeof(h1));
 336   shake_hash(&h, m, msz);
 337   shake_done(&h, rb, 114);
 338   scaf_loaddbl(tt, rb, 114, 2*NPIECE, PIECEWD);
 339   scaf_reduce(r, tt, l, mu, NPIECE, PIECEWD, scratch);
 340   ptmul(&RX, &RY, &RZ, r, BX, BY, BZ);
 341   ptencode(sig, &RX, &RY, &RZ);
 342
 343   /* Calculate the scalar part. */
 344   shake256_init(&h);
 345   shake_hash(&h, pb, psz);
 346   shake_hash(&h, sig, 57);
 347   shake_hash(&h, K, 57);
 348   shake_hash(&h, m, msz);
 349   shake_done(&h, rb, 114);
 350   scaf_loaddbl(tt, rb, 114, 2*NPIECE, PIECEWD);
 351   scaf_reduce(t, tt, l, mu, NPIECE, PIECEWD, scratch);
 352   scaf_mul(tt, t, a, NPIECE);
 353   for (i = 0; i < NPIECE; i++) tt[i] += r[i];
 354   scaf_reduce(t, tt, l, mu, NPIECE, PIECEWD, scratch);
 355   scaf_store(sig + 57, 57, t, NPIECE, PIECEWD);
 356 }
 357
 358 /* --- @ed448_verify@ --- *
 359  *
 360  * Arguments:   @const octet K[ED448_PUBSZ]@ = public key
 361  *              @const void *m@ = message to sign
 362  *              @int phflag@ = whether the `message' has been hashed already
 363  *              @const void *p@ = personalization string
 364  *              @size_t psz@ = length of personalization string
 365  *              @size_t msz@ = length of message
 366  *              @const octet sig[ED448_SIGSZ]@ = signature
 367  *
 368  * Returns:     Zero if OK, negative on failure.
 369  *
 370  * Use:         Verify a signature.
 371  */
 372
 373 int ed448_verify(const octet K[ED448_PUBSZ],
 374                  int phflag, const void *p, size_t psz,
 375                  const void *m, size_t msz,
 376                  const octet sig[ED448_SIGSZ])
 377 {
 378   shake_ctx h;
 379   scaf_piece s[NPIECE], t[NPIECE], scratch[3*NPIECE];
 380   scaf_dblpiece tt[2*NPIECE];
 381   fgoldi AX, AY, AZ, RX, RY, RZ;
 382   octet b[PREFIX_BUFSZ];
 383
 384   /* Unpack the public key.  Negate it: we're meant to subtract the term
 385    * involving the public key point, and this is easier than negating the
 386    * scalar.
 387    */
 388   if (ptdecode(&AX, &AY, &AZ, K)) return (-1);
 389   fgoldi_neg(&AX, &AX);
 390
 391   /* Load the scalar and check that it's in range.  The easy way is to store
 392    * it again and see if the two match.
 393    */
 394   scaf_loaddbl(tt, sig + 57, 57, 2*NPIECE, PIECEWD);
 395   scaf_reduce(s, tt, l, mu, NPIECE, PIECEWD, scratch);
 396   scaf_store(b, 57, s, NPIECE, PIECEWD);
 397   if (memcmp(b, sig + 57, 57) != 0) return (-1);
 398
 399   /* Check the signature. */
 400   psz = prefix(b, phflag, p, psz);
 401   shake256_init(&h);
 402   shake_hash(&h, b, psz);
 403   shake_hash(&h, sig, 57);
 404   shake_hash(&h, K, ED448_PUBSZ);
 405   shake_hash(&h, m, msz);
 406   shake_done(&h, b, 114);
 407   scaf_loaddbl(tt, b, 114, 2*NPIECE, PIECEWD);
 408   scaf_reduce(t, tt, l, mu, NPIECE, PIECEWD, scratch);
 409   ptsimmul(&RX, &RY, &RZ, s, BX, BY, BZ, t, &AX, &AY, &AZ);
 410   ptencode(b, &RX, &RY, &RZ);
 411   if (memcmp(b, sig, 57) != 0) return (-1);
 412
 413   /* All is good. */
 414   return (0);
 415 }
 416
 417 /*----- Test rig ----------------------------------------------------------*/
 418
 419 #ifdef TEST_RIG
 420
 421 #include <stdio.h>
 422 #include <string.h>
 423
 424 #include <mLib/report.h>
 425 #include <mLib/testrig.h>
 426
 427 #include "ct.h"
 428
 429 static int vrf_pubkey(dstr dv[])
 430 {
 431   dstr dpub = DSTR_INIT;
 432   int ok = 1;
 433
 434   if (dv[1].len != ED448_PUBSZ) die(1, "bad pub length");
 435
 436   ct_poison(dv[0].buf, dv[0].len);
 437   dstr_ensure(&dpub, ED448_PUBSZ); dpub.len = ED448_PUBSZ;
 438   ed448_pubkey((octet *)dpub.buf, dv[0].buf, dv[0].len);
 439   ct_remedy(dpub.buf, dpub.len);
 440   if (memcmp(dpub.buf, dv[1].buf, ED448_PUBSZ) != 0) {
 441     ok = 0;
 442     fprintf(stderr, "failed!");
 443     fprintf(stderr, "\n\tpriv = "); type_hex.dump(&dv[0], stderr);
 444     fprintf(stderr, "\n\tcalc = "); type_hex.dump(&dpub, stderr);
 445     fprintf(stderr, "\n\twant = "); type_hex.dump(&dv[1], stderr);
 446     fprintf(stderr, "\n");
 447   }
 448
 449   dstr_destroy(&dpub);
 450   return (ok);
 451 }
 452
 453 static int vrf_sign(dstr *priv, int phflag, dstr *perso,
 454                     dstr *msg, dstr *want)
 455 {
 456   shake_ctx h;
 457   octet K[ED448_PUBSZ];
 458   dstr d = DSTR_INIT, dsig = DSTR_INIT, *m;
 459   int ok = 1;
 460
 461   if (want->len != ED448_SIGSZ) die(1, "bad result length");
 462
 463   ct_poison(priv->buf, priv->len);
 464   dstr_ensure(&dsig, ED448_SIGSZ); dsig.len = ED448_SIGSZ;
 465   if (phflag <= 0)
 466     m = msg;
 467   else {
 468     dstr_ensure(&d, 64); d.len = 64;
 469     shake256_init(&h);
 470     shake_hash(&h, msg->buf, msg->len);
 471     shake_done(&h, d.buf, d.len);
 472     m = &d;
 473   }
 474   ed448_pubkey(K, priv->buf, priv->len);
 475   ed448_sign((octet *)dsig.buf, priv->buf, priv->len, K,
 476              phflag, perso ? perso->buf : 0, perso ? perso->len : 0,
 477              m->buf, m->len);
 478   ct_remedy(dsig.buf, dsig.len);
 479   if (memcmp(dsig.buf, want->buf, ED448_SIGSZ) != 0) {
 480     ok = 0;
 481     fprintf(stderr, "failed!");
 482     fprintf(stderr, "\n\tpriv = "); type_hex.dump(priv, stderr);
 483     if (phflag >= 0) {
 484       fprintf(stderr, "\n\t  ph = %d", phflag);
 485       fprintf(stderr, "\n\tpers = "); type_hex.dump(perso, stderr);
 486     }
 487     fprintf(stderr, "\n\t msg = "); type_hex.dump(msg, stderr);
 488     if (phflag > 0)
 489       { fprintf(stderr, "\n\thash = "); type_hex.dump(m, stderr); }
 490     fprintf(stderr, "\n\tcalc = "); type_hex.dump(&dsig, stderr);
 491     fprintf(stderr, "\n\twant = "); type_hex.dump(want, stderr);
 492     fprintf(stderr, "\n");
 493   }
 494
 495   dstr_destroy(&dsig);
 496   return (ok);
 497 }
 498
 499 static int vrf_sign_ctx(dstr *dv)
 500   { return (vrf_sign(&dv[0], *(int *)dv[1].buf, &dv[2], &dv[3], &dv[4])); }
 501
 502 static int vrf_verify(dstr *pub, int phflag, dstr *perso,
 503                       dstr *msg, dstr *sig, int rc_want)
 504 {
 505   shake_ctx h;
 506   int rc_calc;
 507   dstr d = DSTR_INIT, *m;
 508   int ok = 1;
 509
 510   if (pub->len != ED448_PUBSZ) die(1, "bad pub length");
 511   if (sig->len != ED448_SIGSZ) die(1, "bad sig length");
 512
 513   if (phflag <= 0)
 514     m = msg;
 515   else {
 516     dstr_ensure(&d, 64); d.len = 64;
 517     shake256_init(&h);
 518     shake_hash(&h, msg->buf, msg->len);
 519     shake_done(&h, d.buf, d.len);
 520     m = &d;
 521   }
 522   rc_calc = ed448_verify((const octet *)pub->buf,
 523                          phflag, perso ? perso->buf : 0,
 524                          perso ? perso->len : 0,
 525                          m->buf, m->len,
 526                          (const octet *)sig->buf);
 527   if (!rc_want != !rc_calc) {
 528     ok = 0;
 529     fprintf(stderr, "failed!");
 530     fprintf(stderr, "\n\t pub = "); type_hex.dump(pub, stderr);
 531     if (phflag >= 0) {
 532       fprintf(stderr, "\n\t  ph = %d", phflag);
 533       fprintf(stderr, "\n\tpers = "); type_hex.dump(perso, stderr);
 534     }
 535     fprintf(stderr, "\n\t msg = "); type_hex.dump(msg, stderr);
 536     if (phflag > 0)
 537       { fprintf(stderr, "\n\thash = "); type_hex.dump(m, stderr); }
 538     fprintf(stderr, "\n\t sig = "); type_hex.dump(sig, stderr);
 539     fprintf(stderr, "\n\tcalc = %d", rc_calc);
 540     fprintf(stderr, "\n\twant = %d", rc_want);
 541     fprintf(stderr, "\n");
 542   }
 543
 544   return (ok);
 545 }
 546
 547 static int vrf_verify_ctx(dstr *dv)
 548 {
 549   return (vrf_verify(&dv[0], *(int *)dv[1].buf, &dv[2],
 550                      &dv[3], &dv[4], *(int *)dv[5].buf));
 551 }
 552
 553 static test_chunk tests[] = {
 554   { "pubkey", vrf_pubkey, { &type_hex, &type_hex } },
 555   { "sign", vrf_sign_ctx,
 556     { &type_hex, &type_int, &type_hex, &type_hex, &type_hex } },
 557   { "verify", vrf_verify_ctx,
 558     { &type_hex, &type_int, &type_hex, &type_hex, &type_hex, &type_int } },
 559   { 0, 0, { 0 } }
 560 };
 561
 562 int main(int argc, char *argv[])
 563 {
 564   test_run(argc, argv, tests, SRCDIR "/t/ed448");
 565   return (0);
 566 }
 567
 568 #endif
 569
 570 /*----- That's all, folks -------------------------------------------------*/