eap-radius: Don't clear unclaimed IPs early if accounting is enabled
[strongswan.git] / 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 }