scripts/dh_speed.c

   1 /*
   2  * Copyright (C) 2009 Martin Willi
   3  * HSR Hochschule fuer Technik Rapperswil
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  */
  15
  16 #include <stdio.h>
  17 #include <time.h>
  18 #include <assert.h>
  19 #include <library.h>
  20 #include <utils/debug.h>
  21 #include <crypto/diffie_hellman.h>
  22
  23 static void usage()
  24 {
  25         printf("usage: dh_speed plugins rounds group1 [group2 [...]]\n");
  26         exit(1);
  27 }
  28
  29 struct {
  30         char *name;
  31         diffie_hellman_group_t group;
  32 } groups[] = {
  33         {"modp768",                     MODP_768_BIT},
  34         {"modp1024",            MODP_1024_BIT},
  35         {"modp1024s160",        MODP_1024_160},
  36         {"modp1536",            MODP_1536_BIT},
  37         {"modp2048",            MODP_2048_BIT},
  38         {"modp2048s224",        MODP_2048_224},
  39         {"modp2048s256",        MODP_2048_256},
  40         {"modp3072",            MODP_3072_BIT},
  41         {"modp4096",            MODP_4096_BIT},
  42         {"modp6144",            MODP_6144_BIT},
  43         {"modp8192",            MODP_8192_BIT},
  44         {"ecp256",                      ECP_256_BIT},
  45         {"ecp384",                      ECP_384_BIT},
  46         {"ecp521",                      ECP_521_BIT},
  47         {"ecp192",                      ECP_192_BIT},
  48         {"ecp224",                      ECP_224_BIT},
  49         {"curve25519",          CURVE_25519},
  50         {"curve448",            CURVE_448},
  51 };
  52
  53 static void start_timing(struct timespec *start)
  54 {
  55         clock_gettime(CLOCK_THREAD_CPUTIME_ID, start);
  56 }
  57
  58 static double end_timing(struct timespec *start)
  59 {
  60         struct timespec end;
  61
  62         clock_gettime(CLOCK_THREAD_CPUTIME_ID, &end);
  63         return (end.tv_nsec - start->tv_nsec) / 1000000000.0 +
  64                         (end.tv_sec - start->tv_sec) * 1.0;
  65 }
  66
  67 static void run_test(diffie_hellman_group_t group, int rounds)
  68 {
  69         diffie_hellman_t *l[rounds], *r;
  70         chunk_t chunk, chunks[rounds], lsecrets[rounds], rsecrets[rounds];
  71         struct timespec timing;
  72         int round;
  73
  74         r = lib->crypto->create_dh(lib->crypto, group);
  75         if (!r)
  76         {
  77                 printf("skipping %N, not supported\n",
  78                                 diffie_hellman_group_names, group);
  79                 return;
  80         }
  81
  82         printf("%N:\t", diffie_hellman_group_names, group);
  83
  84         start_timing(&timing);
  85         for (round = 0; round < rounds; round++)
  86         {
  87                 l[round] = lib->crypto->create_dh(lib->crypto, group);
  88                 assert(l[round]->get_my_public_value(l[round], &chunks[round]));
  89         }
  90         printf("A = g^a/s: %8.1f", rounds / end_timing(&timing));
  91
  92         for (round = 0; round < rounds; round++)
  93         {
  94                 assert(r->set_other_public_value(r, chunks[round]));
  95                 assert(r->get_shared_secret(r, &rsecrets[round]));
  96                 chunk_free(&chunks[round]);
  97         }
  98
  99         assert(r->get_my_public_value(r, &chunk));
 100         start_timing(&timing);
 101         for (round = 0; round < rounds; round++)
 102         {
 103                 assert(l[round]->set_other_public_value(l[round], chunk));
 104                 assert(l[round]->get_shared_secret(l[round], &lsecrets[round]));
 105         }
 106         printf(" | S = B^a/s: %8.1f\n", rounds / end_timing(&timing));
 107         chunk_free(&chunk);
 108
 109         for (round = 0; round < rounds; round++)
 110         {
 111                 assert(chunk_equals(rsecrets[round], lsecrets[round]));
 112                 free(lsecrets[round].ptr);
 113                 free(rsecrets[round].ptr);
 114                 l[round]->destroy(l[round]);
 115         }
 116         r->destroy(r);
 117 }
 118
 119 int main(int argc, char *argv[])
 120 {
 121         int rounds, i, j;
 122
 123         if (argc < 4)
 124         {
 125                 usage();
 126         }
 127
 128         library_init(NULL, "dh_speed");
 129         lib->plugins->load(lib->plugins, argv[1]);
 130         atexit(library_deinit);
 131
 132         rounds = atoi(argv[2]);
 133
 134         for (i = 3; i < argc; i++)
 135         {
 136                 bool found = FALSE;
 137
 138                 for (j = 0; j < countof(groups); j++)
 139                 {
 140                         if (streq(groups[j].name, argv[i]))
 141                         {
 142                                 run_test(groups[j].group, rounds);
 143                                 found = TRUE;
 144                         }
 145                 }
 146                 if (!found)
 147                 {
 148                         printf("group %s not found\n", argv[i]);
 149                 }
 150         }
 151         return 0;
 152 }