~mdw / catacomb / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
progs/perftest.c: Use from Glibc syscall numbers.
[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 #ifdef HAVE_LINUX_PERF_EVENT_H
47 # include <sys/syscall.h>
48 # include <linux/perf_event.h>
49 #endif
50
51 #include <mLib/alloc.h>
52 #include <mLib/bits.h>
53 #include <mLib/dstr.h>
54 #include <mLib/macros.h>
55 #include <mLib/mdwopt.h>
56 #include <mLib/quis.h>
57 #include <mLib/report.h>
58 #include <mLib/sub.h>
59 #include <mLib/tv.h>
60
61 #include "rand.h"
62 #include "mp.h"
63 #include "mprand.h"
64 #include "fibrand.h"
65 #include "rsa.h"
66 #include "mpint.h"
67 #include "mptext.h"
68 #include "mpmont.h"
69 #include "mpbarrett.h"
70 #include "dh.h"
71 #include "pgen.h"
72 #include "ec.h"
73 #include "group.h"
74 #include "x25519.h"
75 #include "x448.h"
76 #include "ed25519.h"
77 #include "ed448.h"
78
79 #include "cc.h"
80 #include "gaead.h"
81 #include "gcipher.h"
82 #include "ghash.h"
83 #include "gmac.h"
84 #include "poly1305.h"
85
86 #include "ectab.h"
87 #include "ptab.h"
88
89 /*----- Options -----------------------------------------------------------*/
90
91 typedef struct opts {
92 const char *name; /* Pre-configured named thing */
93 const char *opwhat; /* What to call operations */
94 unsigned fbits; /* Field size bits */
95 unsigned gbits; /* Group size bits */
96 unsigned n; /* Number of factors */
97 unsigned i; /* Number of intervals (or zero) */
98 unsigned k; /* Main loop batch size */
99 unsigned long sc; /* Scale factor */
100 double t; /* Time for each interval (secs) */
101 mp *e; /* Public exponent */
102 unsigned f; /* Flags */
103 #define OF_NOCHECK 1u /* Don't do group checking */
104 } opts;
105
106 /*----- Job switch --------------------------------------------------------*/
107
108 /* --- Barrett exponentiation --- */
109
110 typedef struct bar_ctx {
111 size_t n;
112 mpbarrett b;
113 mp_expfactor *e;
114 } bar_ctx;
115
116 static void *bar_init(opts *o)
117 {
118 bar_ctx *c = CREATE(bar_ctx);
119 gprime_param gp;
120 qd_parse qd;
121 size_t i;
122
123 if (o->name) {
124 qd.p = o->name;
125 if (dh_parse(&qd, &gp))
126 die(1, "bad prime group: %s", qd.e);
127 } else {
128 if (!o->fbits) o->fbits = 1024;
129 dh_gen(&gp, o->gbits, o->fbits, 0, &rand_global, pgen_evspin, 0);
130 }
131 mpbarrett_create(&c->b, gp.p);
132 if (!o->n) o->n = 1;
133 c->n = o->n;
134 c->e = xmalloc(c->n * sizeof(group_expfactor));
135 for (i = 0; i < c->n; i++) {
136 c->e[i].base = mprand_range(MP_NEW, gp.p, &rand_global, 0);
137 c->e[i].exp = mprand_range(MP_NEW, gp.q, &rand_global, 0);
138 }
139 dh_paramfree(&gp);
140 return (c);
141 }
142
143 static void bar_run(void *cc)
144 {
145 bar_ctx *c = cc;
146 mp *d = mpbarrett_exp(&c->b, MP_NEW, c->e[0].base, c->e[0].exp);
147 MP_DROP(d);
148 }
149
150 static void barsim_run(void *cc)
151 {
152 bar_ctx *c = cc;
153 mp *d = mpbarrett_mexp(&c->b, MP_NEW, c->e, c->n);
154 MP_DROP(d);
155 }
156
157 /* --- Montgomery exponentiation --- */
158
159 typedef struct mont_ctx {
160 size_t n;
161 mpmont m;
162 mp_expfactor *e;
163 } mont_ctx;
164
165 static void *mont_init(opts *o)
166 {
167 mont_ctx *c = CREATE(mont_ctx);
168 gprime_param gp;
169 qd_parse qd;
170 size_t i;
171
172 if (o->name) {
173 qd.p = o->name;
174 if (dh_parse(&qd, &gp))
175 die(1, "bad prime group: %s", qd.e);
176 } else {
177 if (!o->fbits) o->fbits = 1024;
178 dh_gen(&gp, o->gbits, o->fbits, 0, &rand_global, pgen_evspin, 0);
179 }
180 mpmont_create(&c->m, gp.p);
181 if (!o->n) o->n = 1;
182 c->n = o->n;
183 c->e = xmalloc(c->n * sizeof(mp_expfactor));
184 for (i = 0; i < c->n; i++) {
185 c->e[i].base = mprand_range(MP_NEW, gp.p, &rand_global, 0);
186 c->e[i].exp = mprand_range(MP_NEW, gp.q, &rand_global, 0);
187 }
188 dh_paramfree(&gp);
189 return (c);
190 }
191
192 static void mont_run(void *cc)
193 {
194 mont_ctx *c = cc;
195 mp *d = mpmont_expr(&c->m, MP_NEW, c->e[0].base, c->e[0].exp);
196 MP_DROP(d);
197 }
198
199 static void montsim_run(void *cc)
200 {
201 mont_ctx *c = cc;
202 mp *d = mpmont_mexpr(&c->m, MP_NEW, c->e, c->n);
203 MP_DROP(d);
204 }
205
206 /* --- Group exponentiation --- */
207
208 typedef struct gr_ctx {
209 size_t n;
210 group *g;
211 group_expfactor *e;
212 } gr_ctx;
213
214 static void *grp_init(opts *o)
215 {
216 gr_ctx *c = CREATE(gr_ctx);
217 const char *e;
218 gprime_param gp;
219 qd_parse qd;
220 size_t i;
221
222 if (o->name) {
223 qd.p = o->name;
224 if (dh_parse(&qd, &gp))
225 die(1, "bad prime group: %s", qd.e);
226 } else {
227 if (!o->fbits) o->fbits = 1024;
228 dh_gen(&gp, o->gbits, o->fbits, 0, &rand_global, pgen_evspin, 0);
229 }
230 c->g = group_prime(&gp);
231 if (!(o->f & OF_NOCHECK) && (e = G_CHECK(c->g, &rand_global)) != 0)
232 die(1, "bad group: %s", e);
233 if (!o->n) o->n = 1;
234 c->n = o->n;
235 c->e = xmalloc(c->n * sizeof(group_expfactor));
236 for (i = 0; i < c->n; i++) {
237 c->e[i].base = G_CREATE(c->g);
238 G_FROMINT(c->g, c->e[i].base,
239 mprand_range(MP_NEW, gp.p, &rand_global, 0));
240 c->e[i].exp = mprand_range(MP_NEW, gp.q, &rand_global, 0);
241 }
242 dh_paramfree(&gp);
243 return (c);
244 }
245
246 static void *grec_init(opts *o)
247 {
248 gr_ctx *c = CREATE(gr_ctx);
249 const char *e;
250 ec_info ei;
251 ec p = EC_INIT;
252 size_t i;
253
254 if (!o->name)
255 die(1, "can't generate elliptic curves");
256 if ((e = ec_getinfo(&ei, o->name)) != 0)
257 die(1, "bad curve: %s", e);
258 c->g = group_ec(&ei);
259 if (!(o->f & OF_NOCHECK) && (e = G_CHECK(c->g, &rand_global)) != 0)
260 die(1, "bad group: %s", e);
261 if (!o->n) o->n = 1;
262 c->n = o->n;
263 c->e = xmalloc(c->n * sizeof(group_expfactor));
264 for (i = 0; i < c->n; i++) {
265 c->e[i].base = G_CREATE(c->g);
266 ec_rand(ei.c, &p, &rand_global);
267 G_FROMEC(c->g, c->e[i].base, &p);
268 c->e[i].exp = mprand_range(MP_NEW, ei.r, &rand_global, 0);
269 }
270 EC_DESTROY(&p);
271 return (c);
272 }
273
274 static void gr_run(void *cc)
275 {
276 gr_ctx *c = cc;
277 ge *x = G_CREATE(c->g);
278 G_EXP(c->g, x, c->e[0].base, c->e[0].exp);
279 G_DESTROY(c->g, x);
280 }
281
282 static void grsim_run(void *cc)
283 {
284 gr_ctx *c = cc;
285 ge *x = G_CREATE(c->g);
286 G_MEXP(c->g, x, c->e, c->n);
287 G_DESTROY(c->g, x);
288 }
289
290 /* --- x25519 --- */
291
292 typedef struct x25519_jobctx {
293 octet k[X25519_KEYSZ];
294 octet p[X25519_PUBSZ];
295 } x25519_jobctx;
296
297 static void *x25519_jobinit(opts *o)
298 {
299 x25519_jobctx *c = CREATE(x25519_jobctx);
300 rand_get(RAND_GLOBAL, c->k, sizeof(c->k));
301 rand_get(RAND_GLOBAL, c->p, sizeof(c->p));
302 return (c);
303 }
304
305 static void x25519_jobrun(void *cc)
306 { x25519_jobctx *c = cc; octet z[X25519_OUTSZ]; x25519(z, c->k, c->p); }
307
308 /* --- x448 --- */
309
310 typedef struct x448_jobctx {
311 octet k[X448_KEYSZ];
312 octet p[X448_PUBSZ];
313 } x448_jobctx;
314
315 static void *x448_jobinit(opts *o)
316 {
317 x448_jobctx *c = CREATE(x448_jobctx);
318 rand_get(RAND_GLOBAL, c->k, sizeof(c->k));
319 rand_get(RAND_GLOBAL, c->p, sizeof(c->p));
320 return (c);
321 }
322
323 static void x448_jobrun(void *cc)
324 { x448_jobctx *c = cc; octet z[X448_OUTSZ]; x448(z, c->k, c->p); }
325
326 /* --- Ed25519 --- */
327
328 typedef struct ed25519_signctx {
329 octet k[ED25519_KEYSZ];
330 octet K[ED25519_PUBSZ];
331 octet m[64];
332 } ed25519_signctx;
333
334 typedef struct ed25519_vrfctx {
335 octet K[ED25519_PUBSZ];
336 octet m[64];
337 octet sig[ED25519_SIGSZ];
338 } ed25519_vrfctx;
339
340 static void *ed25519_signinit(opts *o)
341 {
342 ed25519_signctx *c = CREATE(ed25519_signctx);
343
344 rand_get(RAND_GLOBAL, c->k, sizeof(c->k));
345 rand_get(RAND_GLOBAL, c->m, sizeof(c->m));
346 ed25519_pubkey(c->K, c->k, sizeof(c->k));
347 return (c);
348 }
349
350 static void ed25519_signrun(void *cc)
351 {
352 ed25519_signctx *c = cc;
353 octet sig[ED25519_SIGSZ];
354
355 ed25519_sign(sig, c->k, sizeof(c->k), c->K, c->m, sizeof(c->m));
356 }
357
358 static void *ed25519_vrfinit(opts *o)
359 {
360 octet k[ED25519_KEYSZ];
361 ed25519_vrfctx *c = CREATE(ed25519_vrfctx);
362
363 rand_get(RAND_GLOBAL, k, sizeof(k));
364 rand_get(RAND_GLOBAL, c->m, sizeof(c->m));
365 ed25519_pubkey(c->K, k, sizeof(k));
366 ed25519_sign(c->sig, k, sizeof(k), c->K, c->m, sizeof(c->m));
367 return (c);
368 }
369
370 static void ed25519_vrfrun(void *cc)
371 {
372 ed25519_vrfctx *c = cc;
373 ed25519_verify(c->K, c->m, sizeof(c->m), c->sig);
374 }
375
376 /* --- Ed448 --- */
377
378 typedef struct ed448_signctx {
379 octet k[ED448_KEYSZ];
380 octet K[ED448_PUBSZ];
381 octet m[64];
382 } ed448_signctx;
383
384 typedef struct ed448_vrfctx {
385 octet K[ED448_PUBSZ];
386 octet m[64];
387 octet sig[ED448_SIGSZ];
388 } ed448_vrfctx;
389
390 static void *ed448_signinit(opts *o)
391 {
392 ed448_signctx *c = CREATE(ed448_signctx);
393
394 rand_get(RAND_GLOBAL, c->k, sizeof(c->k));
395 rand_get(RAND_GLOBAL, c->m, sizeof(c->m));
396 ed448_pubkey(c->K, c->k, sizeof(c->k));
397 return (c);
398 }
399
400 static void ed448_signrun(void *cc)
401 {
402 ed448_signctx *c = cc;
403 octet sig[ED448_SIGSZ];
404
405 ed448_sign(sig, c->k, sizeof(c->k), c->K, 0, 0, 0, c->m, sizeof(c->m));
406 }
407
408 static void *ed448_vrfinit(opts *o)
409 {
410 octet k[ED448_KEYSZ];
411 ed448_vrfctx *c = CREATE(ed448_vrfctx);
412
413 rand_get(RAND_GLOBAL, k, sizeof(k));
414 rand_get(RAND_GLOBAL, c->m, sizeof(c->m));
415 ed448_pubkey(c->K, k, sizeof(k));
416 ed448_sign(c->sig, k, sizeof(k), c->K, 0, 0, 0, c->m, sizeof(c->m));
417 return (c);
418 }
419
420 static void ed448_vrfrun(void *cc)
421 {
422 ed448_vrfctx *c = cc;
423 ed448_verify(c->K, 0, 0, 0, c->m, sizeof(c->m), c->sig);
424 }
425
426 /* --- RSA --- */
427
428 typedef struct rsapriv_ctx {
429 rsa_priv rp;
430 rsa_privctx rpc;
431 mp *m;
432 } rsapriv_ctx;
433
434 static void *rsapriv_init(opts *o)
435 {
436 rsapriv_ctx *c = CREATE(rsapriv_ctx);
437
438 if (!o->fbits) o->fbits = 1024;
439 if (!o->e) o->e = mp_fromulong(MP_NEW, 65537);
440 rsa_gen_e(&c->rp, o->fbits, o->e, &rand_global, 0, pgen_evspin, 0);
441 rsa_privcreate(&c->rpc, &c->rp, 0);
442 c->m = mprand_range(MP_NEW, c->rp.n, &rand_global, 0);
443 return (c);
444 }
445
446 static void *rsaprivblind_init(opts *o)
447 {
448 rsapriv_ctx *c = CREATE(rsapriv_ctx);
449
450 if (!o->fbits) o->fbits = 1024;
451 if (!o->e) o->e = mp_fromulong(MP_NEW, 65537);
452 rsa_gen_e(&c->rp, o->fbits, o->e, &rand_global, 0, pgen_evspin, 0);
453 rsa_privcreate(&c->rpc, &c->rp, fibrand_create(0));
454 c->m = mprand_range(MP_NEW, c->rp.n, &rand_global, 0);
455 return (c);
456 }
457
458 static void rsapriv_run(void *cc)
459 {
460 rsapriv_ctx *c = cc;
461 mp *d = rsa_privop(&c->rpc, MP_NEW, c->m);
462 MP_DROP(d);
463 }
464
465 typedef struct rsapub_ctx {
466 rsa_pub rp;
467 rsa_pubctx rpc;
468 mp *m;
469 } rsapub_ctx;
470
471 static void *rsapub_init(opts *o)
472 {
473 rsapub_ctx *c = CREATE(rsapub_ctx);
474 rsa_priv rp;
475
476 if (!o->fbits) o->fbits = 1024;
477 if (!o->e) o->e = mp_fromulong(MP_NEW, 65537);
478 rsa_gen_e(&rp, o->fbits, o->e, &rand_global, 0, pgen_evspin, 0);
479 c->rp.n = MP_COPY(rp.n);
480 c->rp.e = MP_COPY(rp.e);
481 rsa_privfree(&rp);
482 rsa_pubcreate(&c->rpc, &c->rp);
483 c->m = mprand_range(MP_NEW, c->rp.n, &rand_global, 0);
484 return (c);
485 }
486
487 static void rsapub_run(void *cc)
488 {
489 rsapub_ctx *c = cc;
490 mp *d = rsa_pubop(&c->rpc, MP_NEW, c->m);
491 MP_DROP(d);
492 }
493
494 /* --- Symmetric encryption --- */
495
496 typedef struct ksched_ctx {
497 const gccipher *c;
498 octet *k;
499 size_t ksz;
500 } ksched_ctx;
501
502 static void *ksched_init(opts *o)
503 {
504 ksched_ctx *c = CREATE(ksched_ctx);
505 if (!o->name)
506 die(1, "must specify encryption scheme name");
507 if ((c->c = gcipher_byname(o->name)) == 0)
508 die(1, "encryption scheme `%s' not known", o->name);
509 c->ksz = keysz(o->fbits/8, c->c->keysz);
510 if (o->fbits%8 || (o->fbits && c->ksz != o->fbits/8))
511 die(1, "bad key size %u for %s", o->fbits, o->name);
512 c->k = xmalloc(c->ksz);
513 rand_get(RAND_GLOBAL, c->k, c->ksz);
514 return (c);
515 }
516
517 static void ksched_run(void *cc)
518 {
519 ksched_ctx *c = cc;
520 gcipher *gc = GC_INIT(c->c, c->k, c->ksz);
521 GC_DESTROY(gc);
522 }
523
524 typedef struct enc_ctx {
525 gcipher *c;
526 octet *m;
527 size_t sz;
528 size_t n;
529 } enc_ctx;
530
531 static void *enc_init(opts *o)
532 {
533 enc_ctx *c = CREATE(enc_ctx);
534 const gccipher *cc;
535 size_t ksz;
536 octet *k;
537 if (!o->name)
538 die(1, "must specify encryption scheme name");
539 if ((cc = gcipher_byname(o->name)) == 0)
540 die(1, "encryption scheme `%s' not known", o->name);
541 ksz = keysz(o->fbits/8, cc->keysz);
542 if (o->fbits%8 || (o->fbits && ksz != o->fbits/8))
543 die(1, "bad key size %u for %s", o->fbits, o->name);
544 k = xmalloc(ksz);
545 rand_get(RAND_GLOBAL, k, ksz);
546 c->c = GC_INIT(cc, k, ksz);
547 xfree(k);
548 c->sz = o->gbits ? o->gbits : 65536;
549 c->n = o->n ? o->n : 16;
550 o->opwhat = "byte"; o->sc = c->n*c->sz;
551 c->m = xmalloc(c->sz);
552 return (c);
553 }
554
555 static void enc_run(void *cc)
556 {
557 enc_ctx *c = cc;
558 size_t i;
559 for (i = 0; i < c->n; i++)
560 GC_ENCRYPT(c->c, c->m, c->m, c->sz);
561 }
562
563 /* --- Authenticated encryption --- */
564
565 typedef struct aeadsetup_ctx {
566 const gcaead *aec;
567 octet *k; size_t ksz;
568 octet *n; size_t nsz;
569 size_t tsz;
570 } aeadsetup_ctx;
571
572 static void *aeadsetup_init(opts *o)
573 {
574 aeadsetup_ctx *c = CREATE(aeadsetup_ctx);
575 if (!o->name)
576 die(1, "must specify encryption scheme name");
577 if ((c->aec = gaead_byname(o->name)) == 0)
578 die(1, "aead scheme `%s' not known", o->name);
579 c->ksz = keysz(o->fbits/8, c->aec->keysz);
580 c->nsz = keysz_pad(o->gbits/8, c->aec->noncesz);
581 c->tsz = keysz(0, c->aec->tagsz);
582 if (o->fbits%8 || (o->fbits && c->ksz != o->fbits/8))
583 die(1, "bad key size %u for %s", o->fbits, o->name);
584 if (o->gbits%8 || (o->gbits && c->nsz != o->gbits/8))
585 die(1, "bad nonce size %u for %s", o->gbits, o->name);
586 c->k = xmalloc(c->ksz); rand_get(RAND_GLOBAL, c->k, c->ksz);
587 c->n = xmalloc(c->nsz); rand_get(RAND_GLOBAL, c->n, c->nsz);
588 return (c);
589 }
590
591 static void aeadsetup_run(void *cc)
592 {
593 aeadsetup_ctx *c = cc;
594 gaead_key *k = GAEAD_KEY(c->aec, c->k, c->ksz);
595 gaead_enc *e = GAEAD_ENC(k, c->n, c->nsz, 0, 0, c->tsz);
596 GAEAD_DESTROY(e); GAEAD_DESTROY(k);
597 }
598
599 typedef struct aeadenc_ctx {
600 gaead_enc *enc;
601 octet *n; size_t nsz;
602 octet *p, *q; size_t sz; size_t nn;
603 size_t tsz;
604 } aeadenc_ctx;
605
606 static void *aeadenc_init(opts *o)
607 {
608 aeadenc_ctx *c = CREATE(aeadenc_ctx);
609 const gcaead *aec;
610 gaead_key *key;
611 octet *k; size_t ksz;
612
613 if (!o->name)
614 die(1, "must specify encryption scheme name");
615 if ((aec = gaead_byname(o->name)) == 0)
616 die(1, "aead scheme `%s' not known", o->name);
617 c->sz = o->gbits ? o->gbits : 65536;
618 c->nn = o->n ? o->n : 16;
619 ksz = keysz(o->fbits/8, aec->keysz);
620 c->nsz = keysz(0, aec->noncesz);
621 c->tsz = keysz(0, aec->tagsz);
622 if (o->fbits%8 || (o->fbits && ksz != o->fbits/8))
623 die(1, "bad key size %u for %s", o->fbits, o->name);
624
625 k = xmalloc(ksz); rand_get(RAND_GLOBAL, k, ksz);
626 c->n = xmalloc(c->nsz); rand_get(RAND_GLOBAL, c->n, c->nsz);
627 c->p = xmalloc(c->sz); c->q = xmalloc(c->sz + aec->bufsz);
628
629 key = GAEAD_KEY(aec, k, ksz);
630 c->enc = GAEAD_ENC(key, c->n, c->nsz, 0, 0, c->tsz);
631 GAEAD_DESTROY(key); xfree(k);
632
633 o->opwhat = "byte"; o->sc = c->nn*c->sz;
634 return (c);
635 }
636
637 static void aeadaad_run(void *cc)
638 {
639 aeadenc_ctx *c = cc;
640 gaead_aad *a;
641 size_t i;
642
643 GAEAD_REINIT(c->enc, c->n, c->nsz, c->nn*c->sz, 0, c->tsz);
644 a = GAEAD_AAD(c->enc);
645 for (i = 0; i < c->nn; i++) GAEAD_HASH(a, c->p, c->sz);
646 GAEAD_DESTROY(a);
647 }
648
649 static void aeadenc_run(void *cc)
650 {
651 aeadenc_ctx *c = cc;
652 buf b;
653 size_t i;
654
655 GAEAD_REINIT(c->enc, c->n, c->nsz, 0, c->nn*c->sz, c->tsz);
656 for (i = 0; i < c->nn; i++) {
657 buf_init(&b, c->q, c->sz + c->enc->ops->c->bufsz);
658 GAEAD_ENCRYPT(c->enc, c->p, c->sz, &b);
659 }
660 }
661
662 /* --- Hashing --- */
663
664 typedef struct hash_ctx {
665 const gchash *h;
666 octet *m;
667 size_t sz;
668 size_t n;
669 } hash_ctx;
670
671 static void *hash_init(opts *o)
672 {
673 hash_ctx *c = CREATE(hash_ctx);
674 if (!o->name)
675 die(1, "must specify hash function name");
676 if ((c->h = ghash_byname(o->name)) == 0)
677 die(1, "hash function `%s' not known", o->name);
678 c->sz = o->gbits ? o->gbits : 65536;
679 c->n = o->n ? o->n : 16;
680 o->opwhat = "byte"; o->sc = c->n*c->sz;
681 c->m = xmalloc(c->sz);
682 return (c);
683 }
684
685 static void hash_run(void *cc)
686 {
687 hash_ctx *c = cc;
688 size_t i;
689 ghash *h = GH_INIT(c->h);
690 for (i = 0; i < c->n; i++)
691 GH_HASH(h, c->m, c->sz);
692 GH_DONE(h, 0);
693 GH_DESTROY(h);
694 }
695
696 /* --- Poly1305 --- */
697
698 typedef struct poly1305_jobctx {
699 poly1305_key k;
700 octet s[POLY1305_MASKSZ];
701 octet *m;
702 size_t sz;
703 size_t n;
704 } poly1305_jobctx;
705
706 static void *poly1305_jobinit(opts *o)
707 {
708 octet k[POLY1305_KEYSZ];
709 poly1305_jobctx *c = CREATE(poly1305_jobctx);
710 rand_get(RAND_GLOBAL, k, sizeof(k));
711 poly1305_keyinit(&c->k, k, sizeof(k));
712 rand_get(RAND_GLOBAL, c->s, sizeof(c->s));
713 c->sz = o->gbits ? o->gbits : 65536;
714 c->n = o->n ? o->n : 16;
715 o->opwhat = "byte"; o->sc = c->n*c->sz;
716 c->m = xmalloc(c->sz);
717 return (c);
718 }
719
720 static void poly1305_jobrun(void *cc)
721 {
722 poly1305_jobctx *c = cc;
723 poly1305_ctx ctx;
724 octet t[POLY1305_TAGSZ];
725 size_t i;
726 poly1305_macinit(&ctx, &c->k, c->s);
727 for (i = 0; i < c->n; i++) poly1305_hash(&ctx, c->m, c->sz);
728 poly1305_done(&ctx, t);
729 }
730
731 /* --- Job table --- */
732
733 typedef struct jobops {
734 const char *name;
735 void *(*init)(opts *);
736 void (*run)(void *);
737 } jobops;
738
739 static const jobops jobtab[] = {
740 { "g-prime-exp", grp_init, gr_run },
741 { "g-ec-mul", grec_init, gr_run },
742 { "g-prime-exp-sim", grp_init, grsim_run },
743 { "g-ec-mul-sim", grec_init, grsim_run },
744 { "barrett-exp", bar_init, bar_run },
745 { "barrett-exp-sim", bar_init, barsim_run },
746 { "mont-exp", mont_init, mont_run },
747 { "mont-exp-sim", mont_init, montsim_run },
748 { "rsa-priv", rsapriv_init, rsapriv_run },
749 { "rsa-priv-blind", rsaprivblind_init, rsapriv_run },
750 { "rsa-pub", rsapub_init, rsapub_run },
751 { "x25519", x25519_jobinit, x25519_jobrun },
752 { "x448", x448_jobinit, x448_jobrun },
753 { "ed25519-sign", ed25519_signinit, ed25519_signrun },
754 { "ed25519-vrf", ed25519_vrfinit, ed25519_vrfrun },
755 { "ed448-sign", ed448_signinit, ed448_signrun },
756 { "ed448-vrf", ed448_vrfinit, ed448_vrfrun },
757 { "ksched", ksched_init, ksched_run },
758 { "enc", enc_init, enc_run },
759 { "aead-setup", aeadsetup_init, aeadsetup_run },
760 { "aead-aad", aeadenc_init, aeadaad_run },
761 { "aead-enc", aeadenc_init, aeadenc_run },
762 { "hash", hash_init, hash_run },
763 { "poly1305", poly1305_jobinit, poly1305_jobrun },
764 { 0, 0, 0 }
765 };
766
767 /*----- Cycle counting ----------------------------------------------------*/
768
769 typedef kludge64 cycles;
770 static int cyclecount_active_p = 0;
771
772 #if defined(__GNUC__) && (CPUFAM_X86 || CPUFAM_AMD64)
773
774 static void init_cyclecount(void) { cyclecount_active_p = 1; }
775
776 static cycles cyclecount(void)
777 {
778 uint32 lo, hi;
779 kludge64 cy;
780
781 __asm__("rdtsc" : "=a"(lo), "=d"(hi));
782 SET64(cy, hi, lo);
783 return cy;
784 }
785
786 #elif defined(HAVE_LINUX_PERF_EVENT_H) && defined(HAVE_UINT64)
787
788 static int perf_fd = -1;
789
790 static void init_cyclecount(void)
791 {
792 struct perf_event_attr attr = { 0 };
793
794 attr.type = PERF_TYPE_HARDWARE;
795 attr.size = sizeof(attr);
796 attr.config = PERF_COUNT_HW_CPU_CYCLES;
797 attr.disabled = 0;
798 attr.exclude_kernel = 1;
799 attr.exclude_hv = 1;
800
801 if ((perf_fd = syscall(SYS_perf_event_open, &attr, 0, -1, -1, 0)) < 0)
802 moan("failed to open perf event: %s", strerror(errno));
803 else
804 cyclecount_active_p = 1;
805 }
806
807 static cycles cyclecount(void)
808 {
809 kludge64 cy;
810 ssize_t n;
811
812 if (!cyclecount_active_p)
813 goto fail;
814 else if ((n = read(perf_fd, &cy.i, sizeof(cy.i))) != sizeof(cy.i)) {
815 if (n < 0) moan("error reading perf event: %s", strerror(errno));
816 else moan("unexpected short read from perf event");
817 cyclecount_active_p = 0; close(perf_fd); perf_fd = -1;
818 goto fail;
819 }
820 end:
821 return (cy);
822 fail:
823 SET64(cy, 0, 0);
824 goto end;
825 }
826
827 #else
828
829 static void init_cyclecount(void) { cyclecount_active_p = 0; }
830 static cycles cyclecount(void) { kludge64 cy; SET64(cy, 0, 0); return (cy); }
831
832 #endif
833
834 /*----- Main code ---------------------------------------------------------*/
835
836 void version(FILE *fp)
837 {
838 pquis(fp, "$, Catacomb " VERSION "\n");
839 }
840
841 static void usage(FILE *fp)
842 {
843 pquis(fp, "Usage: $ [-options] job\n");
844 }
845
846 static void help(FILE *fp)
847 {
848 version(fp);
849 putc('\n', fp);
850 usage(fp);
851 pquis(fp, "\n\
852 Various performance tests.\n\
853 \n\
854 Options:\n\
855 \n\
856 -h, --help Show this help text.\n\
857 -v, --version Show program version number.\n\
858 -u, --usage Show terse usage message.\n\
859 -l, --list [ITEM...] List all the various names of things.\n\
860 \n\
861 -C, --name=NAME Select curve/DH-group/enc/hash name.\n\
862 -b, --field-bits Field size for g-prime and rsa;\n\
863 key bits for ksched, enc, aead-setup, aead-enc.\n\
864 -q, --no-check Don't check field/group for validity.\n\
865 -B, --group-bits Group size for g-prime; nonce bits for aead-setup;\n\
866 data size for enc, aead-aad, aead-enc, and hash.\n\
867 -n, --factors=COUNT Number of factors for {exp,mul}-sim;\n\
868 inner iters for enc, aead-aad, aead-enc, hash.\n\
869 -i, --intervals=COUNT Number of intervals to run for. [0; forever]\n\
870 -k, --batch=COUNT Number of operations to batch between timer checks.\n\
871 -t, --time=TIME Length of an interval in seconds. [1]\n\
872 ");
873 }
874
875 #define LISTS(LI) \
876 LI("Lists", list, \
877 listtab[i].name, listtab[i].name) \
878 LI("Jobs", job, \
879 jobtab[i].name, jobtab[i].name) \
880 LI("Elliptic curves", ec, \
881 ectab[i].name, ectab[i].name) \
882 LI("Diffie-Hellman groups", dh, \
883 ptab[i].name, ptab[i].name) \
884 LI("Encryption algorithms", cipher, \
885 gciphertab[i], gciphertab[i]->name) \
886 LI("Authenticated encryption schemes", aead, \
887 gaeadtab[i], gaeadtab[i]->name) \
888 LI("Hash functions", hash, \
889 ghashtab[i], ghashtab[i]->name)
890
891 MAKELISTTAB(listtab, LISTS)
892
893 static unsigned uarg(const char *what, const char *p)
894 {
895 char *q;
896 unsigned long u;
897 errno = 0;
898 u = strtoul(p, &q, 0);
899 if (*q || u > UINT_MAX || q == p || errno)
900 die(1, "bad %s `%s'", what, p);
901 return (u);
902 }
903
904 static mp *mparg(const char *what, const char *p)
905 {
906 char *q;
907 mp *x = mp_readstring(MP_NEW, p, &q, 0);
908 if (!x || *q) die(1, "bad %s `%s'", what, p);
909 return (x);
910 }
911
912 static double farg(const char *what, const char *p)
913 {
914 char *q;
915 double f;
916 errno = 0;
917 f = strtod(p, &q);
918 if (*q || q == p || errno)
919 die(1, "bad %s `%s'", what, p);
920 return (f);
921 }
922
923 int main(int argc, char *argv[])
924 {
925 int i;
926 opts o = { 0 };
927 const jobops *j;
928 struct timeval tv_next, tv_now;
929 double t, ttot, cy, cytot;
930 unsigned n, k;
931 unsigned long ii;
932 clock_t c0, c1;
933 kludge64 cy0, cy1, cydiff;
934 double itot;
935 void *p;
936
937 ego(argv[0]);
938 o.t = 1; o.k = 1; o.sc = 1; o.opwhat = "op";
939 for (;;) {
940 static const struct option opts[] = {
941 { "help", 0, 0, 'h' },
942 { "version", 0, 0, 'v' },
943 { "usage", 0, 0, 'u' },
944 { "list", 0, 0, 'l' },
945 { "name", OPTF_ARGREQ, 0, 'C' },
946 { "field-bits", OPTF_ARGREQ, 0, 'b' },
947 { "group-bits", OPTF_ARGREQ, 0, 'B' },
948 { "factors", OPTF_ARGREQ, 0, 'n' },
949 { "intervals", OPTF_ARGREQ, 0, 'i' },
950 { "batch", OPTF_ARGREQ, 0, 'k' },
951 { "public-exponent", OPTF_ARGREQ, 0, 'e' },
952 { "time", OPTF_ARGREQ, 0, 't' },
953 { "no-check", 0, 0, 'q' },
954 { 0, 0, 0, 0 }
955 };
956
957 i = mdwopt(argc, argv, "hvulC:b:B:n:i:k:e:t:q", opts, 0, 0, 0);
958 if (i < 0) break;
959 switch (i) {
960 case 'h': help(stdout); exit(0);
961 case 'v': version(stdout); exit(0);
962 case 'u': usage(stdout); exit(0);
963 case 'l': exit(displaylists(listtab, argv + optind));
964 case 'C': o.name = optarg; break;
965 case 'b': o.fbits = uarg("field bits", optarg); break;
966 case 'B': o.gbits = uarg("subgroup bits", optarg); break;
967 case 'n': o.n = uarg("factor count", optarg); break;
968 case 'e':
969 mp_drop(o.e); o.e = mparg("public exponent", optarg);
970 if (MP_CMP(o.e, <, MP_THREE) || MP_EVENP(o.e))
971 die(1, "invalid public exponent");
972 break;
973 case 'i': o.i = uarg("interval count", optarg); break;
974 case 't': o.t = farg("interval length", optarg); break;
975 case 'k': o.k = uarg("batch size", optarg); break;
976 case 'q': o.f |= OF_NOCHECK; break;
977 default: usage(stderr); exit(1);
978 }
979 }
980 if (optind + 1 != argc) { usage(stderr); exit(1); }
981
982 for (j = jobtab; j->name; j++)
983 if (STRCMP(j->name, ==, argv[optind])) break;
984 if (!j->name) die(1, "unknown job type `%s'", argv[optind]);
985 p = j->init(&o);
986
987 n = 0;
988 ttot = itot = 0; cytot = 0; init_cyclecount();
989 gettimeofday(&tv_now, 0);
990 do {
991 tv_addl(&tv_next, &tv_now, o.t, fmod(o.t * MILLION, MILLION));
992 ii = 0;
993 c0 = clock(); cy0 = cyclecount();
994 do {
995 for (k = 0; k < o.k; k++) { j->run(p); }
996 ii += k;
997 gettimeofday(&tv_now, 0);
998 } while (TV_CMP(&tv_now, <, &tv_next));
999 cy1 = cyclecount(); c1 = clock();
1000 t = (double)(c1 - c0)/CLOCKS_PER_SEC;
1001 itot += ii; ttot += t;
1002 printf("%5u: did = %5lu; /sec = %5f; avg /sec = %5f",
1003 n, ii, ii/t, itot/ttot);
1004 if (cyclecount_active_p) {
1005 SUB64(cydiff, cy1, cy0); cy = LO64(cydiff) + ldexp(HI64(cydiff), 32);
1006 cytot += cy;
1007 printf(" (cy/%s = %3f; avg cy/%s = %3f)",
1008 o.opwhat, cy/ii/o.sc, o.opwhat, cytot/itot/o.sc);
1009 }
1010 putchar('\n');
1011 fflush(stdout);
1012 n++;
1013 } while (!o.i || n < o.i);
1014
1015 return (0);
1016 }
1017
1018 /*----- That's all, folks -------------------------------------------------*/
Catacomb cryptographic library