chiark / gitweb /
progs/perftest.c: Fix key-size handling.
[catacomb] / progs / perftest.c
1 /* -*-c-*-
2  *
3  * Measure performance of various operations (Unix-specific)
4  *
5  * (c) 2004 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 #define _FILE_OFFSET_BITS 64
31
32 #include "config.h"
33
34 #include <errno.h>
35 #include <limits.h>
36 #include <math.h>
37 #include <stdio.h>
38 #include <string.h>
39 #include <stdlib.h>
40 #include <time.h>
41
42 #include <sys/types.h>
43 #include <sys/time.h>
44 #include <unistd.h>
45
46 #include <mLib/alloc.h>
47 #include <mLib/dstr.h>
48 #include <mLib/mdwopt.h>
49 #include <mLib/quis.h>
50 #include <mLib/report.h>
51 #include <mLib/sub.h>
52 #include <mLib/tv.h>
53
54 #include "rand.h"
55 #include "mp.h"
56 #include "mprand.h"
57 #include "fibrand.h"
58 #include "rsa.h"
59 #include "mpint.h"
60 #include "mptext.h"
61 #include "mpmont.h"
62 #include "mpbarrett.h"
63 #include "dh.h"
64 #include "pgen.h"
65 #include "ec.h"
66 #include "group.h"
67 #include "x25519.h"
68 #include "x448.h"
69 #include "ed25519.h"
70 #include "ed448.h"
71
72 #include "cc.h"
73 #include "gcipher.h"
74 #include "ghash.h"
75 #include "gmac.h"
76 #include "poly1305.h"
77
78 #include "ectab.h"
79 #include "ptab.h"
80
81 /*----- Options -----------------------------------------------------------*/
82
83 typedef struct opts {
84   const char *name;                     /* Pre-configured named thing */
85   unsigned fbits;                       /* Field size bits */
86   unsigned gbits;                       /* Group size bits */
87   unsigned n;                           /* Number of factors */
88   unsigned i;                           /* Number of intervals (or zero) */
89   unsigned k;                           /* Main loop batch size */
90   double t;                             /* Time for each interval (secs) */
91   mp *e;                                /* Public exponent */
92   unsigned f;                           /* Flags */
93 #define OF_NOCHECK 1u                   /*   Don't do group checking */
94 } opts;
95
96 /*----- Job switch --------------------------------------------------------*/
97
98 /* --- Barrett exponentiation --- */
99
100 typedef struct bar_ctx {
101   size_t n;
102   mpbarrett b;
103   mp_expfactor *e;
104 } bar_ctx;
105
106 static void *bar_init(opts *o)
107 {
108   bar_ctx *c = CREATE(bar_ctx);
109   gprime_param gp;
110   qd_parse qd;
111   size_t i;
112
113   if (o->name) {
114     qd.p = o->name;
115     if (dh_parse(&qd, &gp))
116       die(1, "bad prime group: %s", qd.e);
117   } else {
118     if (!o->fbits) o->fbits = 1024;
119     dh_gen(&gp, o->gbits, o->fbits, 0, &rand_global, pgen_evspin, 0);
120   }
121   mpbarrett_create(&c->b, gp.p);
122   if (!o->n) o->n = 1;
123   c->n = o->n;
124   c->e = xmalloc(c->n * sizeof(group_expfactor));
125   for (i = 0; i < c->n; i++) {
126     c->e[i].base = mprand_range(MP_NEW, gp.p, &rand_global, 0);
127     c->e[i].exp = mprand_range(MP_NEW, gp.q, &rand_global, 0);
128   }
129   dh_paramfree(&gp);
130   return (c);
131 }
132
133 static void bar_run(void *cc)
134 {
135   bar_ctx *c = cc;
136   mp *d = mpbarrett_exp(&c->b, MP_NEW, c->e[0].base, c->e[0].exp);
137   MP_DROP(d);
138 }
139
140 static void barsim_run(void *cc)
141 {
142   bar_ctx *c = cc;
143   mp *d = mpbarrett_mexp(&c->b, MP_NEW, c->e, c->n);
144   MP_DROP(d);
145 }
146
147 /* --- Montgomery exponentiation --- */
148
149 typedef struct mont_ctx {
150   size_t n;
151   mpmont m;
152   mp_expfactor *e;
153 } mont_ctx;
154
155 static void *mont_init(opts *o)
156 {
157   mont_ctx *c = CREATE(mont_ctx);
158   gprime_param gp;
159   qd_parse qd;
160   size_t i;
161
162   if (o->name) {
163     qd.p = o->name;
164     if (dh_parse(&qd, &gp))
165       die(1, "bad prime group: %s", qd.e);
166   } else {
167     if (!o->fbits) o->fbits = 1024;
168     dh_gen(&gp, o->gbits, o->fbits, 0, &rand_global, pgen_evspin, 0);
169   }
170   mpmont_create(&c->m, gp.p);
171   if (!o->n) o->n = 1;
172   c->n = o->n;
173   c->e = xmalloc(c->n * sizeof(mp_expfactor));
174   for (i = 0; i < c->n; i++) {
175     c->e[i].base = mprand_range(MP_NEW, gp.p, &rand_global, 0);
176     c->e[i].exp = mprand_range(MP_NEW, gp.q, &rand_global, 0);
177   }
178   dh_paramfree(&gp);
179   return (c);
180 }
181
182 static void mont_run(void *cc)
183 {
184   mont_ctx *c = cc;
185   mp *d = mpmont_expr(&c->m, MP_NEW, c->e[0].base, c->e[0].exp);
186   MP_DROP(d);
187 }
188
189 static void montsim_run(void *cc)
190 {
191   mont_ctx *c = cc;
192   mp *d = mpmont_mexpr(&c->m, MP_NEW, c->e, c->n);
193   MP_DROP(d);
194 }
195
196 /* --- Group exponentiation --- */
197
198 typedef struct gr_ctx {
199   size_t n;
200   group *g;
201   group_expfactor *e;
202 } gr_ctx;
203
204 static void *grp_init(opts *o)
205 {
206   gr_ctx *c = CREATE(gr_ctx);
207   const char *e;
208   gprime_param gp;
209   qd_parse qd;
210   size_t i;
211
212   if (o->name) {
213     qd.p = o->name;
214     if (dh_parse(&qd, &gp))
215       die(1, "bad prime group: %s", qd.e);
216   } else {
217     if (!o->fbits) o->fbits = 1024;
218     dh_gen(&gp, o->gbits, o->fbits, 0, &rand_global, pgen_evspin, 0);
219   }
220   c->g = group_prime(&gp);
221   if (!(o->f & OF_NOCHECK) && (e = G_CHECK(c->g, &rand_global)) != 0)
222     die(1, "bad group: %s", e);
223   if (!o->n) o->n = 1;
224   c->n = o->n;
225   c->e = xmalloc(c->n * sizeof(group_expfactor));
226   for (i = 0; i < c->n; i++) {
227     c->e[i].base = G_CREATE(c->g);
228     G_FROMINT(c->g, c->e[i].base,
229               mprand_range(MP_NEW, gp.p, &rand_global, 0));
230     c->e[i].exp = mprand_range(MP_NEW, gp.q, &rand_global, 0);
231   }
232   dh_paramfree(&gp);
233   return (c);
234 }
235
236 static void *grec_init(opts *o)
237 {
238   gr_ctx *c = CREATE(gr_ctx);
239   const char *e;
240   ec_info ei;
241   ec p = EC_INIT;
242   size_t i;
243
244   if (!o->name)
245     die(1, "can't generate elliptic curves");
246   if ((e = ec_getinfo(&ei, o->name)) != 0)
247     die(1, "bad curve: %s", e);
248   c->g = group_ec(&ei);
249   if (!(o->f & OF_NOCHECK) && (e = G_CHECK(c->g, &rand_global)) != 0)
250     die(1, "bad group: %s", e);
251   if (!o->n) o->n = 1;
252   c->n = o->n;
253   c->e = xmalloc(c->n * sizeof(group_expfactor));
254   for (i = 0; i < c->n; i++) {
255     c->e[i].base = G_CREATE(c->g);
256     ec_rand(ei.c, &p, &rand_global);
257     G_FROMEC(c->g, c->e[i].base, &p);
258     c->e[i].exp = mprand_range(MP_NEW, ei.r, &rand_global, 0);
259   }
260   EC_DESTROY(&p);
261   return (c);
262 }
263
264 static void gr_run(void *cc)
265 {
266   gr_ctx *c = cc;
267   ge *x = G_CREATE(c->g);
268   G_EXP(c->g, x, c->e[0].base, c->e[0].exp);
269   G_DESTROY(c->g, x);
270 }
271
272 static void grsim_run(void *cc)
273 {
274   gr_ctx *c = cc;
275   ge *x = G_CREATE(c->g);
276   G_MEXP(c->g, x, c->e, c->n);
277   G_DESTROY(c->g, x);
278 }
279
280 /* --- x25519 --- */
281
282 typedef struct x25519_jobctx {
283   octet k[X25519_KEYSZ];
284   octet p[X25519_PUBSZ];
285 } x25519_jobctx;
286
287 static void *x25519_jobinit(opts *o)
288 {
289   x25519_jobctx *c = CREATE(x25519_jobctx);
290   rand_get(RAND_GLOBAL, c->k, sizeof(c->k));
291   rand_get(RAND_GLOBAL, c->p, sizeof(c->p));
292   return (c);
293 }
294
295 static void x25519_jobrun(void *cc)
296   { x25519_jobctx *c = cc; octet z[X25519_OUTSZ]; x25519(z, c->k, c->p); }
297
298 /* --- x448 --- */
299
300 typedef struct x448_jobctx {
301   octet k[X448_KEYSZ];
302   octet p[X448_PUBSZ];
303 } x448_jobctx;
304
305 static void *x448_jobinit(opts *o)
306 {
307   x448_jobctx *c = CREATE(x448_jobctx);
308   rand_get(RAND_GLOBAL, c->k, sizeof(c->k));
309   rand_get(RAND_GLOBAL, c->p, sizeof(c->p));
310   return (c);
311 }
312
313 static void x448_jobrun(void *cc)
314   { x448_jobctx *c = cc; octet z[X448_OUTSZ]; x448(z, c->k, c->p); }
315
316 /* --- Ed25519 --- */
317
318 typedef struct ed25519_signctx {
319   octet k[ED25519_KEYSZ];
320   octet K[ED25519_PUBSZ];
321   octet m[64];
322 } ed25519_signctx;
323
324 typedef struct ed25519_vrfctx {
325   octet K[ED25519_PUBSZ];
326   octet m[64];
327   octet sig[ED25519_SIGSZ];
328 } ed25519_vrfctx;
329
330 static void *ed25519_signinit(opts *o)
331 {
332   ed25519_signctx *c = CREATE(ed25519_signctx);
333
334   rand_get(RAND_GLOBAL, c->k, sizeof(c->k));
335   rand_get(RAND_GLOBAL, c->m, sizeof(c->m));
336   ed25519_pubkey(c->K, c->k, sizeof(c->k));
337   return (c);
338 }
339
340 static void ed25519_signrun(void *cc)
341 {
342   ed25519_signctx *c = cc;
343   octet sig[ED25519_SIGSZ];
344
345   ed25519_sign(sig, c->k, sizeof(c->k), c->K, c->m, sizeof(c->m));
346 }
347
348 static void *ed25519_vrfinit(opts *o)
349 {
350   octet k[ED25519_KEYSZ];
351   ed25519_vrfctx *c = CREATE(ed25519_vrfctx);
352
353   rand_get(RAND_GLOBAL, k, sizeof(k));
354   rand_get(RAND_GLOBAL, c->m, sizeof(c->m));
355   ed25519_pubkey(c->K, k, sizeof(k));
356   ed25519_sign(c->sig, k, sizeof(k), c->K, c->m, sizeof(c->m));
357   return (c);
358 }
359
360 static void ed25519_vrfrun(void *cc)
361 {
362   ed25519_vrfctx *c = cc;
363   ed25519_verify(c->K, c->m, sizeof(c->m), c->sig);
364 }
365
366 /* --- Ed448 --- */
367
368 typedef struct ed448_signctx {
369   octet k[ED448_KEYSZ];
370   octet K[ED448_PUBSZ];
371   octet m[64];
372 } ed448_signctx;
373
374 typedef struct ed448_vrfctx {
375   octet K[ED448_PUBSZ];
376   octet m[64];
377   octet sig[ED448_SIGSZ];
378 } ed448_vrfctx;
379
380 static void *ed448_signinit(opts *o)
381 {
382   ed448_signctx *c = CREATE(ed448_signctx);
383
384   rand_get(RAND_GLOBAL, c->k, sizeof(c->k));
385   rand_get(RAND_GLOBAL, c->m, sizeof(c->m));
386   ed448_pubkey(c->K, c->k, sizeof(c->k));
387   return (c);
388 }
389
390 static void ed448_signrun(void *cc)
391 {
392   ed448_signctx *c = cc;
393   octet sig[ED448_SIGSZ];
394
395   ed448_sign(sig, c->k, sizeof(c->k), c->K, 0, 0, 0, c->m, sizeof(c->m));
396 }
397
398 static void *ed448_vrfinit(opts *o)
399 {
400   octet k[ED448_KEYSZ];
401   ed448_vrfctx *c = CREATE(ed448_vrfctx);
402
403   rand_get(RAND_GLOBAL, k, sizeof(k));
404   rand_get(RAND_GLOBAL, c->m, sizeof(c->m));
405   ed448_pubkey(c->K, k, sizeof(k));
406   ed448_sign(c->sig, k, sizeof(k), c->K, 0, 0, 0, c->m, sizeof(c->m));
407   return (c);
408 }
409
410 static void ed448_vrfrun(void *cc)
411 {
412   ed448_vrfctx *c = cc;
413   ed448_verify(c->K, 0, 0, 0, c->m, sizeof(c->m), c->sig);
414 }
415
416 /* --- RSA --- */
417
418 typedef struct rsapriv_ctx {
419   rsa_priv rp;
420   rsa_privctx rpc;
421   mp *m;
422 } rsapriv_ctx;
423
424 static void *rsapriv_init(opts *o)
425 {
426   rsapriv_ctx *c = CREATE(rsapriv_ctx);
427
428   if (!o->fbits) o->fbits = 1024;
429   if (!o->e) o->e = mp_fromulong(MP_NEW, 65537);
430   rsa_gen_e(&c->rp, o->fbits, o->e, &rand_global, 0, pgen_evspin, 0);
431   rsa_privcreate(&c->rpc, &c->rp, 0);
432   c->m = mprand_range(MP_NEW, c->rp.n, &rand_global, 0);
433   return (c);
434 }
435
436 static void *rsaprivblind_init(opts *o)
437 {
438   rsapriv_ctx *c = CREATE(rsapriv_ctx);
439
440   if (!o->fbits) o->fbits = 1024;
441   if (!o->e) o->e = mp_fromulong(MP_NEW, 65537);
442   rsa_gen_e(&c->rp, o->fbits, o->e, &rand_global, 0, pgen_evspin, 0);
443   rsa_privcreate(&c->rpc, &c->rp, fibrand_create(0));
444   c->m = mprand_range(MP_NEW, c->rp.n, &rand_global, 0);
445   return (c);
446 }
447
448 static void rsapriv_run(void *cc)
449 {
450   rsapriv_ctx *c = cc;
451   mp *d = rsa_privop(&c->rpc, MP_NEW, c->m);
452   MP_DROP(d);
453 }
454
455 typedef struct rsapub_ctx {
456   rsa_pub rp;
457   rsa_pubctx rpc;
458   mp *m;
459 } rsapub_ctx;
460
461 static void *rsapub_init(opts *o)
462 {
463   rsapub_ctx *c = CREATE(rsapub_ctx);
464   rsa_priv rp;
465
466   if (!o->fbits) o->fbits = 1024;
467   if (!o->e) o->e = mp_fromulong(MP_NEW, 65537);
468   rsa_gen_e(&rp, o->fbits, o->e, &rand_global, 0, pgen_evspin, 0);
469   c->rp.n = MP_COPY(rp.n);
470   c->rp.e = MP_COPY(rp.e);
471   rsa_privfree(&rp);
472   rsa_pubcreate(&c->rpc, &c->rp);
473   c->m = mprand_range(MP_NEW, c->rp.n, &rand_global, 0);
474   return (c);
475 }
476
477 static void rsapub_run(void *cc)
478 {
479   rsapub_ctx *c = cc;
480   mp *d = rsa_pubop(&c->rpc, MP_NEW, c->m);
481   MP_DROP(d);
482 }
483
484 /* --- Symmetric encryption --- */
485
486 typedef struct ksched_ctx {
487   const gccipher *c;
488   octet *k;
489   size_t ksz;
490 } ksched_ctx;
491
492 static void *ksched_init(opts *o)
493 {
494   ksched_ctx *c = CREATE(ksched_ctx);
495   if (!o->name)
496     die(1, "must specify encryption scheme name");
497   if ((c->c = gcipher_byname(o->name)) == 0)
498     die(1, "encryption scheme `%s' not known", o->name);
499   c->ksz = keysz(o->fbits/8, c->c->keysz);
500   if (o->fbits%8 || (o->fbits && c->ksz != o->fbits/8))
501     die(1, "bad key size %u for %s", o->fbits, o->name);
502   c->k = xmalloc(c->ksz);
503   rand_get(RAND_GLOBAL, c->k, c->ksz);
504   return (c);
505 }
506
507 static void ksched_run(void *cc)
508 {
509   ksched_ctx *c = cc;
510   gcipher *gc = GC_INIT(c->c, c->k, c->ksz);
511   GC_DESTROY(gc);
512 }
513
514 typedef struct enc_ctx {
515   gcipher *c;
516   octet *m;
517   size_t sz;
518   size_t n;
519 } enc_ctx;
520
521 static void *enc_init(opts *o)
522 {
523   enc_ctx *c = CREATE(enc_ctx);
524   const gccipher *cc;
525   size_t ksz;
526   octet *k;
527   if (!o->name)
528     die(1, "must specify encryption scheme name");
529   if ((cc = gcipher_byname(o->name)) == 0)
530     die(1, "encryption scheme `%s' not known", o->name);
531   ksz = keysz(o->fbits/8, cc->keysz);
532   if (o->fbits%8 || (o->fbits && ksz != o->fbits/8))
533     die(1, "bad key size %u for %s", o->fbits, o->name);
534   k = xmalloc(ksz);
535   rand_get(RAND_GLOBAL, k, ksz);
536   c->c = GC_INIT(cc, k, ksz);
537   xfree(k);
538   c->sz = o->gbits ? o->gbits : 65536;
539   c->n = o->n ? o->n : 16;
540   c->m = xmalloc(c->sz);
541   return (c);
542 }
543
544 static void enc_run(void *cc)
545 {
546   enc_ctx *c = cc;
547   size_t i;
548   for (i = 0; i < c->n; i++)
549     GC_ENCRYPT(c->c, c->m, c->m, c->sz);
550 }
551
552 /* --- Hashing --- */
553
554 typedef struct hash_ctx {
555   const gchash *h;
556   octet *m;
557   size_t sz;
558   size_t n;
559 } hash_ctx;
560
561 static void *hash_init(opts *o)
562 {
563   hash_ctx *c = CREATE(hash_ctx);
564   if (!o->name)
565     die(1, "must specify hash function name");
566   if ((c->h = ghash_byname(o->name)) == 0)
567     die(1, "hash function `%s' not known", o->name);
568   c->sz = o->gbits ? o->gbits : 65536;
569   c->n = o->n ? o->n : 16;
570   c->m = xmalloc(c->sz);
571   return (c);
572 }
573
574 static void hash_run(void *cc)
575 {
576   hash_ctx *c = cc;
577   size_t i;
578   ghash *h = GH_INIT(c->h);
579   for (i = 0; i < c->n; i++)
580     GH_HASH(h, c->m, c->sz);
581   GH_DONE(h, 0);
582   GH_DESTROY(h);
583 }
584
585 /* --- Poly1305 --- */
586
587 typedef struct poly1305_jobctx {
588   poly1305_key k;
589   octet s[POLY1305_MASKSZ];
590   octet *m;
591   size_t sz;
592   size_t n;
593 } poly1305_jobctx;
594
595 static void *poly1305_jobinit(opts *o)
596 {
597   octet k[POLY1305_KEYSZ];
598   poly1305_jobctx *c = CREATE(poly1305_jobctx);
599   rand_get(RAND_GLOBAL, k, sizeof(k));
600   poly1305_keyinit(&c->k, k, sizeof(k));
601   rand_get(RAND_GLOBAL, c->s, sizeof(c->s));
602   c->sz = o->gbits ? o->gbits : 65536;
603   c->n = o->n ? o->n : 16;
604   c->m = xmalloc(c->sz);
605   return (c);
606 }
607
608 static void poly1305_jobrun(void *cc)
609 {
610   poly1305_jobctx *c = cc;
611   poly1305_ctx ctx;
612   octet t[POLY1305_TAGSZ];
613   size_t i;
614   poly1305_macinit(&ctx, &c->k, c->s);
615   for (i = 0; i < c->n; i++) poly1305_hash(&ctx, c->m, c->sz);
616   poly1305_done(&ctx, t);
617 }
618
619 /* --- Job table --- */
620
621 typedef struct jobops {
622   const char *name;
623   void *(*init)(opts *);
624   void (*run)(void *);
625 } jobops;
626
627 static const jobops jobtab[] = {
628   { "g-prime-exp",              grp_init,               gr_run },
629   { "g-ec-mul",                 grec_init,              gr_run },
630   { "g-prime-exp-sim",          grp_init,               grsim_run },
631   { "g-ec-mul-sim",             grec_init,              grsim_run },
632   { "barrett-exp",              bar_init,               bar_run },
633   { "barrett-exp-sim",          bar_init,               barsim_run },
634   { "mont-exp",                 mont_init,              mont_run },
635   { "mont-exp-sim",             mont_init,              montsim_run },
636   { "rsa-priv",                 rsapriv_init,           rsapriv_run },
637   { "rsa-priv-blind",           rsaprivblind_init,      rsapriv_run },
638   { "rsa-pub",                  rsapub_init,            rsapub_run },
639   { "x25519",                   x25519_jobinit,         x25519_jobrun },
640   { "x448",                     x448_jobinit,           x448_jobrun },
641   { "ed25519-sign",             ed25519_signinit,       ed25519_signrun },
642   { "ed25519-vrf",              ed25519_vrfinit,        ed25519_vrfrun },
643   { "ed448-sign",               ed448_signinit,         ed448_signrun },
644   { "ed448-vrf",                ed448_vrfinit,          ed448_vrfrun },
645   { "ksched",                   ksched_init,            ksched_run },
646   { "enc",                      enc_init,               enc_run },
647   { "hash",                     hash_init,              hash_run },
648   { "poly1305",                 poly1305_jobinit,       poly1305_jobrun },
649   { 0,                          0,                      0 }
650 };
651
652 /*----- Main code ---------------------------------------------------------*/
653
654 void version(FILE *fp)
655 {
656   pquis(fp, "$, Catacomb " VERSION "\n");
657 }
658
659 static void usage(FILE *fp)
660 {
661   pquis(fp, "Usage: $ [-options] job\n");
662 }
663
664 static void help(FILE *fp)
665 {
666   version(fp);
667   putc('\n', fp);
668   usage(fp);
669   pquis(fp, "\n\
670 Various performance tests.\n\
671 \n\
672 Options:\n\
673 \n\
674 -h, --help              Show this help text.\n\
675 -v, --version           Show program version number.\n\
676 -u, --usage             Show terse usage message.\n\
677 -l, --list [ITEM...]    List all the various names of things.\n\
678 \n\
679 -C, --name=NAME         Select curve/DH-group/enc/hash name.\n\
680 -b, --field-bits        Field size for g-prime and rsa;\n\
681                           key bits for ksched and enc.\n\
682 -q, --no-check          Don't check field/group for validity.\n\
683 -B, --group-bits        Group size for g-prime; data size for enc and hash.\n\
684 -n, --factors=COUNT     Number of factors for {exp,mul}-sim;\n\
685                           inner iterations for enc and hash.\n\
686 -i, --intervals=COUNT   Number of intervals to run for.  [0; forever]\n\
687 -k, --batch=COUNT       Number of operations to batch between timer checks.\n\
688 -t, --time=TIME         Length of an interval in seconds.  [1]\n\
689 ");
690 }
691
692 #define LISTS(LI)                                                       \
693   LI("Lists", list,                                                     \
694      listtab[i].name, listtab[i].name)                                  \
695   LI("Jobs", job,                                                       \
696      jobtab[i].name, jobtab[i].name)                                    \
697   LI("Elliptic curves", ec,                                             \
698      ectab[i].name, ectab[i].name)                                      \
699   LI("Diffie-Hellman groups", dh,                                       \
700      ptab[i].name, ptab[i].name)                                        \
701   LI("Encryption algorithms", cipher,                                   \
702      gciphertab[i], gciphertab[i]->name)                                \
703   LI("Hash functions", hash,                                            \
704      ghashtab[i], ghashtab[i]->name)
705
706 MAKELISTTAB(listtab, LISTS)
707
708 static unsigned uarg(const char *what, const char *p)
709 {
710   char *q;
711   unsigned long u;
712   errno = 0;
713   u = strtoul(p, &q, 0);
714   if (*q || u > UINT_MAX || q == p || errno)
715     die(1, "bad %s `%s'", what, p);
716   return (u);
717 }
718
719 static mp *mparg(const char *what, const char *p)
720 {
721   char *q;
722   mp *x = mp_readstring(MP_NEW, p, &q, 0);
723   if (!x || *q) die(1, "bad %s `%s'", what, p);
724   return (x);
725 }
726
727 static double farg(const char *what, const char *p)
728 {
729   char *q;
730   double f;
731   errno = 0;
732   f = strtod(p, &q);
733   if (*q || q == p || errno)
734     die(1, "bad %s `%s'", what, p);
735   return (f);
736 }
737
738 int main(int argc, char *argv[])
739 {
740   int i;
741   opts o = { 0 };
742   const jobops *j;
743   struct timeval tv_next, tv_now;
744   double t, ttot;
745   unsigned n, k;
746   unsigned long ii;
747   clock_t c0, c1;
748   double itot;
749   void *p;
750
751   ego(argv[0]);
752   o.t = 1;
753   for (;;) {
754     static const struct option opts[] = {
755       { "help",         0,              0,      'h' },
756       { "version",      0,              0,      'v' },
757       { "usage",        0,              0,      'u' },
758       { "list",         0,              0,      'l' },
759       { "name",         OPTF_ARGREQ,    0,      'C' },
760       { "field-bits",   OPTF_ARGREQ,    0,      'b' },
761       { "group-bits",   OPTF_ARGREQ,    0,      'B' },
762       { "factors",      OPTF_ARGREQ,    0,      'n' },
763       { "intervals",    OPTF_ARGREQ,    0,      'i' },
764       { "batch",        OPTF_ARGREQ,    0,      'k' },
765       { "public-exponent", OPTF_ARGREQ, 0,      'e' },
766       { "time",         OPTF_ARGREQ,    0,      't' },
767       { "no-check",     0,              0,      'q' },
768       { 0,              0,              0,      0 }
769     };
770
771     i = mdwopt(argc, argv, "hvulC:b:B:n:i:k:e:t:q", opts, 0, 0, 0);
772     if (i < 0) break;
773     switch (i) {
774       case 'h': help(stdout); exit(0);
775       case 'v': version(stdout); exit(0);
776       case 'u': usage(stdout); exit(0);
777       case 'l': exit(displaylists(listtab, argv + optind));
778       case 'C': o.name = optarg; break;
779       case 'b': o.fbits = uarg("field bits", optarg); break;
780       case 'B': o.gbits = uarg("subgroup bits", optarg); break;
781       case 'n': o.n = uarg("factor count", optarg); break;
782       case 'e':
783         mp_drop(o.e); o.e = mparg("public exponent", optarg);
784         if (MP_CMP(o.e, <, MP_THREE) || MP_EVENP(o.e))
785           die(1, "invalid public exponent");
786         break;
787       case 'i': o.i = uarg("interval count", optarg); break;
788       case 't': o.t = farg("interval length", optarg); break;
789       case 'k': o.k = uarg("batch size", optarg); break;
790       case 'q': o.f |= OF_NOCHECK; break;
791       default: usage(stderr); exit(1);
792     }
793   }
794   if (optind + 1 != argc) { usage(stderr); exit(1); }
795
796   for (j = jobtab; j->name; j++)
797     if (strcmp(j->name, argv[optind]) == 0) break;
798   if (!j->name) die(1, "unknown job type `%s'", argv[optind]);
799   p = j->init(&o);
800
801   n = 0;
802   ttot = itot =  0;
803   gettimeofday(&tv_now, 0);
804   do {
805     tv_addl(&tv_next, &tv_now, o.t, fmod(o.t * MILLION, MILLION));
806     ii = 0;
807     c0 = clock();
808     do {
809       for (k = 0; k < o.k; k++) { j->run(p); }
810       ii += k;
811       gettimeofday(&tv_now, 0);
812     } while (TV_CMP(&tv_now, <, &tv_next));
813     c1 = clock();
814     printf("%5u: did = %5lu; /sec = %5f; avg /sec = %5f\n",
815     t = (double)(c1 - c0)/CLOCKS_PER_SEC;
816     itot += ii; ttot += t;
817            n, ii, ii/t, itot/ttot);
818     fflush(stdout);
819     n++;
820   } while (!o.i || n < o.i);
821
822   return (0);
823 }
824
825 /*----- That's all, folks -------------------------------------------------*/