Windows fix.
[libgcrypt.git] / tests / benchmark.c
1 /* benchmark.c - for libgcrypt
2  * Copyright (C) 2002, 2004, 2005, 2006, 2008 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser general Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <time.h>
26 #include <stdarg.h>
27 #ifdef _WIN32
28 #include <windows.h>
29 #else
30 #include <sys/times.h>
31 #endif
32 #include <gcrypt.h>
33
34 #define PGM "benchmark"
35
36 static int verbose;
37
38 /* Do encryption tests with large buffers.  */
39 static int large_buffers;
40
41 /* Number of cipher repetitions.  */
42 static int cipher_repetitions;
43
44
45 static const char sample_private_dsa_key_1024[] =
46 "(private-key\n"
47 "  (dsa\n"
48 "   (p #00A126202D592214C5A8F6016E2C3F4256052ACB1CB17D88E64B1293FAF08F5E4685"
49        "03E6F68366B326A56284370EB2103E92D8346A163E44A08FDC422AC8E9E44268557A"
50        "853539A6AF39353A59CE5E78FD98B57D0F3E3A7EBC8A256AC9A775BA59689F3004BF"
51        "C3035730C4C0C51626C5D7F5852637EC589BB29DAB46C161572E4B#)\n"
52 "   (q #00DEB5A296421887179ECA1762884DE2AF8185AFC5#)\n"
53 "   (g #3958B34AE7747194ECBD312F8FEE8CBE3918E94DF9FD11E2912E56318F33BDC38622"
54        "B18DDFF393074BCA8BAACF50DF27AEE529F3E8AEECE55C398DAB3A5E04C2EA142312"
55        "FACA2FE7F0A88884F8DAC3979EE67598F9A383B2A2325F035C796F352A5C3CDF2CB3"
56        "85AD24EC52A6E55247E1BB37D260F79E617D2A4446415B6AD79A#)\n"
57 "   (y #519E9FE9AB0545A6724E74603B7B04E48DC1437E0284A11EA605A7BA8AB1CF354FD4"
58        "ECC93880AC293391C69B558AD84E7AAFA88F11D028CF3A378F241D6B056A90C588F6"
59        "66F68D27262B4DA84657D15057D371BCEC1F6504032507D5B881E45FC93A1B973155"
60        "D91C57219D090C3ACD75E7C2B9F1176A208AC03D6C12AC28A271#)\n"
61 "   (x #4186F8A58C5DF46C5BCFC7006BEEBF05E93C0CA7#)\n"
62 "))\n";
63
64 static const char sample_public_dsa_key_1024[] =
65 "(public-key\n"
66 "  (dsa\n"
67 "   (p #00A126202D592214C5A8F6016E2C3F4256052ACB1CB17D88E64B1293FAF08F5E4685"
68        "03E6F68366B326A56284370EB2103E92D8346A163E44A08FDC422AC8E9E44268557A"
69        "853539A6AF39353A59CE5E78FD98B57D0F3E3A7EBC8A256AC9A775BA59689F3004BF"
70        "C3035730C4C0C51626C5D7F5852637EC589BB29DAB46C161572E4B#)\n"
71 "   (q #00DEB5A296421887179ECA1762884DE2AF8185AFC5#)\n"
72 "   (g #3958B34AE7747194ECBD312F8FEE8CBE3918E94DF9FD11E2912E56318F33BDC38622"
73        "B18DDFF393074BCA8BAACF50DF27AEE529F3E8AEECE55C398DAB3A5E04C2EA142312"
74        "FACA2FE7F0A88884F8DAC3979EE67598F9A383B2A2325F035C796F352A5C3CDF2CB3"
75        "85AD24EC52A6E55247E1BB37D260F79E617D2A4446415B6AD79A#)\n"
76 "   (y #519E9FE9AB0545A6724E74603B7B04E48DC1437E0284A11EA605A7BA8AB1CF354FD4"
77        "ECC93880AC293391C69B558AD84E7AAFA88F11D028CF3A378F241D6B056A90C588F6"
78        "66F68D27262B4DA84657D15057D371BCEC1F6504032507D5B881E45FC93A1B973155"
79        "D91C57219D090C3ACD75E7C2B9F1176A208AC03D6C12AC28A271#)\n"
80 "))\n";
81
82
83 static const char sample_private_dsa_key_2048[] =
84 "(private-key\n"
85 "  (dsa\n"
86 "   (p #00B54636673962B64F7DC23C71ACEF6E7331796F607560B194DFCC0CA370E858A365"
87        "A413152FB6EB8C664BD171AC316FE5B381CD084D07377571599880A068EF1382D85C"
88        "308B4E9DEAC12D66DE5C4A826EBEB5ED94A62E7301E18927E890589A2F230272A150"
89        "C118BC3DC2965AE0D05BE4F65C6137B2BA7EDABB192C3070D202C10AA3F534574970"
90        "71454DB8A73DDB6511A5BA98EF1450FD90DE5BAAFC9FD3AC22EBEA612DD075BB7405"
91        "D56866D125E33982C046808F7CEBA8E5C0B9F19A6FE451461660A1CBA9EF68891179"
92        "0256A573D3B8F35A5C7A0C6C31F2DB90E25A26845252AD9E485EF2D339E7B5890CD4"
93        "2F9C9F315ED409171EC35CA04CC06B275577B3#)\n"
94 "   (q #00DA67989167FDAC4AE3DF9247A716859A30C0CF9C5A6DBA01EABA3481#)\n"
95 "   (g #48E35DA584A089D05142AA63603FDB00D131B07A0781E2D5A8F9614D2B33D3E40A78"
96        "98A9E10CDBB612CF093F95A3E10D09566726F2C12823836B2D9CD974BB695665F3B3"
97        "5D219A9724B87F380BD5207EDA0AE38C79E8F18122C3F76E4CEB0ABED3250914987F"
98        "B30D4B9E19C04C28A5D4F45560AF586F6A1B41751EAD90AE7F044F4E2A4A50C1F508"
99        "4FC202463F478F678B9A19392F0D2961C5391C546EF365368BB46410C9C1CEE96E9F"
100        "0C953570C2ED06328B11C90E86E57CAA7FA5ABAA278E22A4C8C08E16EE59F484EC44"
101        "2CF55535BAA2C6BEA8833A555372BEFE1E665D3C7DAEF58061D5136331EF4EB61BC3"
102        "6EE4425A553AF8885FEA15A88135BE133520#)\n"
103 "   (y #66E0D1A69D663466F8FEF2B7C0878DAC93C36A2FB2C05E0306A53B926021D4B92A1C"
104        "2FA6860061E88E78CBBBA49B0E12700F07DBF86F72CEB2927EDAC0C7E3969C3A47BB"
105        "4E0AE93D8BB3313E93CC7A72DFEEE442EFBC81B3B2AEC9D8DCBE21220FB760201D79"
106        "328C41C773866587A44B6954767D022A88072900E964089D9B17133603056C985C4F"
107        "8A0B648F297F8D2C3CB43E4371DC6002B5B12CCC085BDB2CFC5074A0587566187EE3"
108        "E11A2A459BD94726248BB8D6CC62938E11E284C2C183576FBB51749EB238C4360923"
109        "79C08CE1C8CD77EB57404CE9B4744395ACF721487450BADE3220576F2F816248B0A7"
110        "14A264330AECCB24DE2A1107847B23490897#)\n"
111 "   (x #477BD14676E22563C5ABA68025CEBA2A48D485F5B2D4AD4C0EBBD6D0#)\n"
112 "))\n";
113
114
115 static const char sample_public_dsa_key_2048[] =
116 "(public-key\n"
117 "  (dsa\n"
118 "   (p #00B54636673962B64F7DC23C71ACEF6E7331796F607560B194DFCC0CA370E858A365"
119        "A413152FB6EB8C664BD171AC316FE5B381CD084D07377571599880A068EF1382D85C"
120        "308B4E9DEAC12D66DE5C4A826EBEB5ED94A62E7301E18927E890589A2F230272A150"
121        "C118BC3DC2965AE0D05BE4F65C6137B2BA7EDABB192C3070D202C10AA3F534574970"
122        "71454DB8A73DDB6511A5BA98EF1450FD90DE5BAAFC9FD3AC22EBEA612DD075BB7405"
123        "D56866D125E33982C046808F7CEBA8E5C0B9F19A6FE451461660A1CBA9EF68891179"
124        "0256A573D3B8F35A5C7A0C6C31F2DB90E25A26845252AD9E485EF2D339E7B5890CD4"
125        "2F9C9F315ED409171EC35CA04CC06B275577B3#)\n"
126 "   (q #00DA67989167FDAC4AE3DF9247A716859A30C0CF9C5A6DBA01EABA3481#)\n"
127 "   (g #48E35DA584A089D05142AA63603FDB00D131B07A0781E2D5A8F9614D2B33D3E40A78"
128        "98A9E10CDBB612CF093F95A3E10D09566726F2C12823836B2D9CD974BB695665F3B3"
129        "5D219A9724B87F380BD5207EDA0AE38C79E8F18122C3F76E4CEB0ABED3250914987F"
130        "B30D4B9E19C04C28A5D4F45560AF586F6A1B41751EAD90AE7F044F4E2A4A50C1F508"
131        "4FC202463F478F678B9A19392F0D2961C5391C546EF365368BB46410C9C1CEE96E9F"
132        "0C953570C2ED06328B11C90E86E57CAA7FA5ABAA278E22A4C8C08E16EE59F484EC44"
133        "2CF55535BAA2C6BEA8833A555372BEFE1E665D3C7DAEF58061D5136331EF4EB61BC3"
134        "6EE4425A553AF8885FEA15A88135BE133520#)\n"
135 "   (y #66E0D1A69D663466F8FEF2B7C0878DAC93C36A2FB2C05E0306A53B926021D4B92A1C"
136        "2FA6860061E88E78CBBBA49B0E12700F07DBF86F72CEB2927EDAC0C7E3969C3A47BB"
137        "4E0AE93D8BB3313E93CC7A72DFEEE442EFBC81B3B2AEC9D8DCBE21220FB760201D79"
138        "328C41C773866587A44B6954767D022A88072900E964089D9B17133603056C985C4F"
139        "8A0B648F297F8D2C3CB43E4371DC6002B5B12CCC085BDB2CFC5074A0587566187EE3"
140        "E11A2A459BD94726248BB8D6CC62938E11E284C2C183576FBB51749EB238C4360923"
141        "79C08CE1C8CD77EB57404CE9B4744395ACF721487450BADE3220576F2F816248B0A7"
142        "14A264330AECCB24DE2A1107847B23490897#)\n"
143 "))\n";
144
145
146 static const char sample_private_dsa_key_3072[] =
147 "(private-key\n"
148 "  (dsa\n"
149 "   (p #00BA73E148AEA5E8B64878AF5BE712B8302B9671C5F3EEB7722A9D0D9868D048C938"
150        "877C91C335C7819292E69C7D34264F1578E32EC2DA8408DF75D0EB76E0D3030B84B5"
151        "62D8EF93AB53BAB6B8A5DE464F5CA87AEA43BDCF0FB0B7815AA3114CFC84FD916A83"
152        "B3D5FD78390189332232E9D037D215313FD002FF46C048B66703F87FAE092AAA0988"
153        "AC745336EBE672A01DEDBD52395783579B67CF3AE1D6F1602CCCB12154FA0E00AE46"
154        "0D9B289CF709194625BCB919B11038DEFC50ADBBA20C3F320078E4E9529B4F6848E2"
155        "AB5E6278DB961FE226F2EEBD201E071C48C5BEF98B4D9BEE42C1C7102D893EBF8902"
156        "D7A91266340AFD6CE1D09E52282FFF5B97EAFA3886A3FCF84FF76D1E06538D0D8E60"
157        "B3332145785E07D29A5965382DE3470D1D888447FA9C00A2373378FC3FA7B9F7D17E"
158        "95A6A5AE1397BE46D976EF2C96E89913AC4A09351CA661BF6F67E30407DA846946C7"
159        "62D9BAA6B77825097D3E7B886456BB32E3E74516BF3FD93D71B257AA8F723E01CE33"
160        "8015353D3778B02B892AF7#)\n"
161 "   (q #00BFF3F3CC18FA018A5B8155A8695E1E4939660D5E4759322C39D50F3B93E5F68B#)\n"
162 "   (g #6CCFD8219F5FCE8EF2BEF3262929787140847E38674B1EF8DB20255E212CB6330EC4"
163        "DFE8A26AB7ECC5760DEB9BBF59A2B2821D510F1868172222867558B8D204E889C474"
164        "7CA30FBF9D8CF41AE5D5BD845174641101593849FF333E6C93A6550931B2B9D56B98"
165        "9CAB01729D9D736FA6D24A74D2DDE1E9E648D141473E443DD6BBF0B3CAB64F9FE4FC"
166        "134B2EB57437789F75C744DF1FA67FA8A64603E5441BC7ECE29E00BDF262BDC81E8C"
167        "7330A18A412DE38E7546D342B89A0AF675A89E6BEF00540EB107A2FE74EA402B0D89"
168        "F5C02918DEEEAF8B8737AC866B09B50810AB8D8668834A1B9E1E53866E2B0A926FAB"
169        "120A0CDE5B3715FFFE6ACD1AB73588DCC1EC4CE9392FE57F8D1D35811200CB07A0E6"
170        "374E2C4B0AEB7E3D077B8545C0E438DCC0F1AE81E186930E99EBC5B91B77E92803E0"
171        "21602887851A4FFDB3A7896AC655A0901218C121C5CBB0931E7D5EAC243F37711B5F"
172        "D5A62B1B38A83F03D8F6703D8B98DF367FC8A76990335F62173A5391836F0F2413EC"
173        "4997AF9EB55C6660B01A#)\n"
174 "   (y #2320B22434C5DB832B4EC267CC52E78DD5CCFA911E8F0804E7E7F32B186B2D4167AE"
175        "4AA6869822E76400492D6A193B0535322C72B0B7AA4A87E33044FDC84BE24C64A053"
176        "A37655EE9EABDCDC1FDF63F3F1C677CEB41595DF7DEFE9178D85A3D621B4E4775492"
177        "8C0A58D2458D06F9562E4DE2FE6129A64063A99E88E54485B97484A28188C4D33F15"
178        "DDC903B6CEA0135E3E3D27B4EA39319696305CE93D7BA7BE00367DBE3AAF43491E71"
179        "CBF254744A5567F5D70090D6139E0C990239627B3A1C5B20B6F9F6374B8D8D8A8997"
180        "437265BE1E3B4810D4B09254400DE287A0DFFBAEF339E48D422B1D41A37E642BC026"
181        "73314701C8FA9792845C129351A87A945A03E6C895860E51D6FB8B7340A94D1A8A7B"
182        "FA85AC83B4B14E73AB86CB96C236C8BFB0978B61B2367A7FE4F7891070F56C78D5DD"
183        "F5576BFE5BE4F333A4E2664E79528B3294907AADD63F4F2E7AA8147B928D8CD69765"
184        "3DB98C4297CB678046ED55C0DBE60BF7142C594603E4D705DC3D17270F9F086EC561"
185        "2703D518D8D49FF0EBE6#)\n"
186 "   (x #00A9FFFC88E67D6F7B810E291C050BAFEA7FC4A75E8D2F16CFED3416FD77607232#)\n"
187 "))\n";
188
189 static const char sample_public_dsa_key_3072[] =
190 "(public-key\n"
191 "  (dsa\n"
192 "   (p #00BA73E148AEA5E8B64878AF5BE712B8302B9671C5F3EEB7722A9D0D9868D048C938"
193        "877C91C335C7819292E69C7D34264F1578E32EC2DA8408DF75D0EB76E0D3030B84B5"
194        "62D8EF93AB53BAB6B8A5DE464F5CA87AEA43BDCF0FB0B7815AA3114CFC84FD916A83"
195        "B3D5FD78390189332232E9D037D215313FD002FF46C048B66703F87FAE092AAA0988"
196        "AC745336EBE672A01DEDBD52395783579B67CF3AE1D6F1602CCCB12154FA0E00AE46"
197        "0D9B289CF709194625BCB919B11038DEFC50ADBBA20C3F320078E4E9529B4F6848E2"
198        "AB5E6278DB961FE226F2EEBD201E071C48C5BEF98B4D9BEE42C1C7102D893EBF8902"
199        "D7A91266340AFD6CE1D09E52282FFF5B97EAFA3886A3FCF84FF76D1E06538D0D8E60"
200        "B3332145785E07D29A5965382DE3470D1D888447FA9C00A2373378FC3FA7B9F7D17E"
201        "95A6A5AE1397BE46D976EF2C96E89913AC4A09351CA661BF6F67E30407DA846946C7"
202        "62D9BAA6B77825097D3E7B886456BB32E3E74516BF3FD93D71B257AA8F723E01CE33"
203        "8015353D3778B02B892AF7#)\n"
204 "   (q #00BFF3F3CC18FA018A5B8155A8695E1E4939660D5E4759322C39D50F3B93E5F68B#)\n"
205 "   (g #6CCFD8219F5FCE8EF2BEF3262929787140847E38674B1EF8DB20255E212CB6330EC4"
206        "DFE8A26AB7ECC5760DEB9BBF59A2B2821D510F1868172222867558B8D204E889C474"
207        "7CA30FBF9D8CF41AE5D5BD845174641101593849FF333E6C93A6550931B2B9D56B98"
208        "9CAB01729D9D736FA6D24A74D2DDE1E9E648D141473E443DD6BBF0B3CAB64F9FE4FC"
209        "134B2EB57437789F75C744DF1FA67FA8A64603E5441BC7ECE29E00BDF262BDC81E8C"
210        "7330A18A412DE38E7546D342B89A0AF675A89E6BEF00540EB107A2FE74EA402B0D89"
211        "F5C02918DEEEAF8B8737AC866B09B50810AB8D8668834A1B9E1E53866E2B0A926FAB"
212        "120A0CDE5B3715FFFE6ACD1AB73588DCC1EC4CE9392FE57F8D1D35811200CB07A0E6"
213        "374E2C4B0AEB7E3D077B8545C0E438DCC0F1AE81E186930E99EBC5B91B77E92803E0"
214        "21602887851A4FFDB3A7896AC655A0901218C121C5CBB0931E7D5EAC243F37711B5F"
215        "D5A62B1B38A83F03D8F6703D8B98DF367FC8A76990335F62173A5391836F0F2413EC"
216        "4997AF9EB55C6660B01A#)\n"
217 "   (y #2320B22434C5DB832B4EC267CC52E78DD5CCFA911E8F0804E7E7F32B186B2D4167AE"
218        "4AA6869822E76400492D6A193B0535322C72B0B7AA4A87E33044FDC84BE24C64A053"
219        "A37655EE9EABDCDC1FDF63F3F1C677CEB41595DF7DEFE9178D85A3D621B4E4775492"
220        "8C0A58D2458D06F9562E4DE2FE6129A64063A99E88E54485B97484A28188C4D33F15"
221        "DDC903B6CEA0135E3E3D27B4EA39319696305CE93D7BA7BE00367DBE3AAF43491E71"
222        "CBF254744A5567F5D70090D6139E0C990239627B3A1C5B20B6F9F6374B8D8D8A8997"
223        "437265BE1E3B4810D4B09254400DE287A0DFFBAEF339E48D422B1D41A37E642BC026"
224        "73314701C8FA9792845C129351A87A945A03E6C895860E51D6FB8B7340A94D1A8A7B"
225        "FA85AC83B4B14E73AB86CB96C236C8BFB0978B61B2367A7FE4F7891070F56C78D5DD"
226        "F5576BFE5BE4F333A4E2664E79528B3294907AADD63F4F2E7AA8147B928D8CD69765"
227        "3DB98C4297CB678046ED55C0DBE60BF7142C594603E4D705DC3D17270F9F086EC561"
228        "2703D518D8D49FF0EBE6#)\n"
229 "))\n";
230
231
232 #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
233 #define DIMof(type,member)   DIM(((type *)0)->member)
234 #define BUG() do {fprintf ( stderr, "Ooops at %s:%d\n", __FILE__ , __LINE__ );\
235                   exit(2);} while(0)
236
237
238 /* Helper for the start and stop timer. */
239 #ifdef _WIN32
240 struct {
241   FILETIME creation_time, exit_time, kernel_time, user_time;
242 } started_at, stopped_at;
243 #else
244 static clock_t started_at, stopped_at;
245 #endif
246
247 static void
248 die (const char *format, ...)
249 {
250   va_list arg_ptr ;
251
252   va_start( arg_ptr, format ) ;
253   putchar ('\n');
254   fputs ( PGM ": ", stderr);
255   vfprintf (stderr, format, arg_ptr );
256   va_end(arg_ptr);
257   exit (1);
258 }
259
260 static void
261 show_sexp (const char *prefix, gcry_sexp_t a)
262 {
263   char *buf;
264   size_t size;
265
266   fputs (prefix, stderr);
267   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
268   buf = malloc (size);
269   if (!buf)
270     die ("out of core\n");
271
272   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
273   fprintf (stderr, "%.*s", (int)size, buf);
274 }
275
276
277 static void
278 start_timer (void)
279 {
280 #ifdef _WIN32
281   GetProcessTimes (GetCurrentProcess (),
282                    &started_at.creation_time, &started_at.exit_time,
283                    &started_at.kernel_time, &started_at.user_time);
284   stopped_at = started_at;
285 #else
286   struct tms tmp;
287
288   times (&tmp);
289   started_at = stopped_at = tmp.tms_utime;
290 #endif
291 }
292
293 static void
294 stop_timer (void)
295 {
296 #ifdef _WIN32
297   GetProcessTimes (GetCurrentProcess (),
298                    &stopped_at.creation_time, &stopped_at.exit_time,
299                    &stopped_at.kernel_time, &stopped_at.user_time);
300 #else
301   struct tms tmp;
302
303   times (&tmp);
304   stopped_at = tmp.tms_utime;
305 #endif
306 }
307
308 static const char *
309 elapsed_time (void)
310 {
311   static char buf[50];
312 #if _WIN32
313   unsigned long long t1, t2, t;
314
315   t1 = (((unsigned long long)started_at.kernel_time.dwHighDateTime << 32)
316         + started_at.kernel_time.dwLowDateTime);
317   t1 += (((unsigned long long)started_at.user_time.dwHighDateTime << 32)
318         + started_at.user_time.dwLowDateTime);
319   t2 = (((unsigned long long)stopped_at.kernel_time.dwHighDateTime << 32)
320         + stopped_at.kernel_time.dwLowDateTime);
321   t2 += (((unsigned long long)stopped_at.user_time.dwHighDateTime << 32)
322         + stopped_at.user_time.dwLowDateTime);
323   t = (t2 - t1)/10000;
324   snprintf (buf, sizeof buf, "%5.0fms", (double)t );
325 #else
326   snprintf (buf, sizeof buf, "%5.0fms",
327             (((double) (stopped_at - started_at))/CLOCKS_PER_SEC)*10000000);
328 #endif
329   return buf;
330 }
331
332
333 static void
334 random_bench (int very_strong)
335 {
336   char buf[128];
337   int i;
338
339   printf ("%-10s", "random");
340
341   if (!very_strong)
342     {
343       start_timer ();
344       for (i=0; i < 100; i++)
345         gcry_randomize (buf, sizeof buf, GCRY_STRONG_RANDOM);
346       stop_timer ();
347       printf (" %s", elapsed_time ());
348     }
349
350   start_timer ();
351   for (i=0; i < 100; i++)
352     gcry_randomize (buf, 8,
353                     very_strong? GCRY_VERY_STRONG_RANDOM:GCRY_STRONG_RANDOM);
354   stop_timer ();
355   printf (" %s", elapsed_time ());
356
357   putchar ('\n');
358   if (verbose)
359     gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
360 }
361
362
363
364 static void
365 md_bench ( const char *algoname )
366 {
367   int algo;
368   gcry_md_hd_t hd;
369   int i;
370   char buf[1000];
371   gcry_error_t err = GPG_ERR_NO_ERROR;
372
373   if (!algoname)
374     {
375       for (i=1; i < 400; i++)
376         if ( !gcry_md_test_algo (i) )
377           md_bench (gcry_md_algo_name (i));
378       return;
379     }
380
381   algo = gcry_md_map_name (algoname);
382   if (!algo)
383     {
384       fprintf (stderr, PGM ": invalid hash algorithm `%s'\n", algoname);
385       exit (1);
386     }
387
388   err = gcry_md_open (&hd, algo, 0);
389   if (err)
390     {
391       fprintf (stderr, PGM ": error opening hash algorithm `%s'\n", algoname);
392       exit (1);
393     }
394
395   for (i=0; i < sizeof buf; i++)
396     buf[i] = i;
397
398   printf ("%-12s", gcry_md_algo_name (algo));
399
400   start_timer ();
401   for (i=0; i < 1000; i++)
402     gcry_md_write (hd, buf, sizeof buf);
403   gcry_md_final (hd);
404   stop_timer ();
405   printf (" %s", elapsed_time ());
406
407   gcry_md_reset (hd);
408   start_timer ();
409   for (i=0; i < 10000; i++)
410     gcry_md_write (hd, buf, sizeof buf/10);
411   gcry_md_final (hd);
412   stop_timer ();
413   printf (" %s", elapsed_time ());
414
415   gcry_md_reset (hd);
416   start_timer ();
417   for (i=0; i < 1000000; i++)
418     gcry_md_write (hd, "", 1);
419   gcry_md_final (hd);
420   stop_timer ();
421   printf (" %s", elapsed_time ());
422
423   gcry_md_close (hd);
424   putchar ('\n');
425 }
426
427 static void
428 cipher_bench ( const char *algoname )
429 {
430   static int header_printed;
431   int algo;
432   gcry_cipher_hd_t hd;
433   int i;
434   int keylen, blklen;
435   char key[128];
436   char *outbuf, *buf;
437   size_t allocated_buflen, buflen;
438   int repetitions;
439   static struct { int mode; const char *name; int blocked; } modes[] = {
440     { GCRY_CIPHER_MODE_ECB, "ECB", 1 },
441     { GCRY_CIPHER_MODE_CBC, "CBC", 1 },
442     { GCRY_CIPHER_MODE_CFB, "CFB", 0 },
443     { GCRY_CIPHER_MODE_OFB, "OFB", 0 },
444     { GCRY_CIPHER_MODE_CTR, "CTR", 0 },
445     { GCRY_CIPHER_MODE_STREAM, "STREAM", 0 },
446     {0}
447   };
448   int modeidx;
449   gcry_error_t err = GPG_ERR_NO_ERROR;
450
451
452   if (!algoname)
453     {
454       for (i=1; i < 400; i++)
455         if ( !gcry_cipher_test_algo (i) )
456           cipher_bench (gcry_cipher_algo_name (i));
457       return;
458     }
459
460   if (large_buffers)
461     {
462       allocated_buflen = 1024 * 100;
463       repetitions = 10;
464     }
465   else
466     {
467       allocated_buflen = 1024;
468       repetitions = 1000;
469     }
470   repetitions *= cipher_repetitions;
471
472   buf = gcry_xmalloc (allocated_buflen);
473   outbuf = gcry_xmalloc (allocated_buflen);
474
475   if (!header_printed)
476     {
477       if (cipher_repetitions != 1)
478         printf ("Running each test %d times.\n", cipher_repetitions);
479       printf ("%-12s", "");
480       for (modeidx=0; modes[modeidx].mode; modeidx++)
481         printf (" %-15s", modes[modeidx].name );
482       putchar ('\n');
483       printf ("%-12s", "");
484       for (modeidx=0; modes[modeidx].mode; modeidx++)
485         printf (" ---------------" );
486       putchar ('\n');
487       header_printed = 1;
488     }
489
490   algo = gcry_cipher_map_name (algoname);
491   if (!algo)
492     {
493       fprintf (stderr, PGM ": invalid cipher algorithm `%s'\n", algoname);
494       exit (1);
495     }
496
497   keylen = gcry_cipher_get_algo_keylen (algo);
498   if (!keylen)
499     {
500       fprintf (stderr, PGM ": failed to get key length for algorithm `%s'\n",
501                algoname);
502       exit (1);
503     }
504   if ( keylen > sizeof key )
505     {
506         fprintf (stderr, PGM ": algo %d, keylength problem (%d)\n",
507                  algo, keylen );
508         exit (1);
509     }
510   for (i=0; i < keylen; i++)
511     key[i] = i + (clock () & 0xff);
512
513   blklen = gcry_cipher_get_algo_blklen (algo);
514   if (!blklen)
515     {
516       fprintf (stderr, PGM ": failed to get block length for algorithm `%s'\n",
517                algoname);
518       exit (1);
519     }
520
521   printf ("%-12s", gcry_cipher_algo_name (algo));
522   fflush (stdout);
523
524   for (modeidx=0; modes[modeidx].mode; modeidx++)
525     {
526       if ((blklen > 1 && modes[modeidx].mode == GCRY_CIPHER_MODE_STREAM)
527           | (blklen == 1 && modes[modeidx].mode != GCRY_CIPHER_MODE_STREAM))
528         {
529           printf ("                " );
530           continue;
531         }
532
533       for (i=0; i < sizeof buf; i++)
534         buf[i] = i;
535
536       err = gcry_cipher_open (&hd, algo, modes[modeidx].mode, 0);
537       if (err)
538         {
539           fprintf (stderr, PGM ": error opening cipher `%s'\n", algoname);
540           exit (1);
541         }
542       
543       err = gcry_cipher_setkey (hd, key, keylen);
544       if (err)
545       { 
546           fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
547                    gpg_strerror (err));
548           gcry_cipher_close (hd);
549           exit (1);
550         }
551
552       buflen = allocated_buflen;
553       if (modes[modeidx].blocked)
554         buflen = (buflen / blklen) * blklen;
555       
556       start_timer ();
557       for (i=err=0; !err && i < repetitions; i++)
558         err = gcry_cipher_encrypt ( hd, outbuf, buflen, buf, buflen);
559       stop_timer ();
560
561       printf (" %s", elapsed_time ());
562       fflush (stdout);
563       gcry_cipher_close (hd);
564       if (err)
565         { 
566           fprintf (stderr, "gcry_cipher_encrypt failed: %s\n",
567                    gpg_strerror (err) );
568           exit (1);
569         }
570
571       err = gcry_cipher_open (&hd, algo, modes[modeidx].mode, 0);
572       if (err)
573         {
574           fprintf (stderr, PGM ": error opening cipher `%s'/n", algoname);
575           exit (1);
576         }
577       
578       err = gcry_cipher_setkey (hd, key, keylen);
579       if (err)
580         { 
581           fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
582                    gpg_strerror (err));
583           gcry_cipher_close (hd);
584           exit (1);
585         }
586
587       start_timer ();
588       for (i=err=0; !err && i < repetitions; i++)
589         err = gcry_cipher_decrypt ( hd, outbuf, buflen,  buf, buflen);
590       stop_timer ();
591       printf (" %s", elapsed_time ());
592       fflush (stdout);
593       gcry_cipher_close (hd);
594       if (err)
595         { 
596           fprintf (stderr, "gcry_cipher_decrypt failed: %s\n",
597                    gpg_strerror (err) );
598           exit (1);
599         }
600     }
601
602   putchar ('\n');
603   gcry_free (buf);
604   gcry_free (outbuf);
605 }
606
607
608
609 static void
610 rsa_bench (int iterations, int print_header, int no_blinding)
611 {
612   gpg_error_t err;
613   int p_sizes[] = { 1024, 2048, 3072, 4096 };
614   int testno;
615
616   if (print_header)
617     printf ("Algorithm         generate %4d*sign %4d*verify\n"
618             "------------------------------------------------\n",
619             iterations, iterations );
620   for (testno=0; testno < DIM (p_sizes); testno++)
621     {
622       gcry_sexp_t key_spec, key_pair, pub_key, sec_key;
623       gcry_mpi_t x;
624       gcry_sexp_t data;
625       gcry_sexp_t sig = NULL;
626       int count;
627
628       printf ("RSA %3d bit    ", p_sizes[testno]);
629       fflush (stdout);
630
631       err = gcry_sexp_build (&key_spec, NULL,
632                              gcry_control (GCRYCTL_FIPS_MODE_P, 0)
633                              ? "(genkey (RSA (nbits %d)))"
634                              : "(genkey (RSA (nbits %d)(transient-key)))",
635                              p_sizes[testno]);
636       if (err)
637         die ("creating S-expression failed: %s\n", gcry_strerror (err));
638
639       start_timer ();
640       err = gcry_pk_genkey (&key_pair, key_spec);
641       if (err)
642         die ("creating %d bit RSA key failed: %s\n",
643              p_sizes[testno], gcry_strerror (err));
644
645       pub_key = gcry_sexp_find_token (key_pair, "public-key", 0);
646       if (! pub_key)
647         die ("public part missing in key\n");
648       sec_key = gcry_sexp_find_token (key_pair, "private-key", 0);
649       if (! sec_key)
650         die ("private part missing in key\n");
651       gcry_sexp_release (key_pair);
652       gcry_sexp_release (key_spec);
653
654       stop_timer ();
655       printf ("   %s", elapsed_time ());
656       fflush (stdout);
657
658       x = gcry_mpi_new (p_sizes[testno]);
659       gcry_mpi_randomize (x, p_sizes[testno]-8, GCRY_WEAK_RANDOM);
660       err = gcry_sexp_build (&data, NULL,
661                              "(data (flags raw) (value %m))", x);
662       gcry_mpi_release (x);
663       if (err)
664         die ("converting data failed: %s\n", gcry_strerror (err));
665
666       start_timer ();
667       for (count=0; count < iterations; count++)
668         {
669           gcry_sexp_release (sig);
670           err = gcry_pk_sign (&sig, data, sec_key);
671           if (err)
672             die ("signing failed (%d): %s\n", count, gpg_strerror (err));
673         }
674       stop_timer ();
675       printf ("   %s", elapsed_time ());
676       fflush (stdout);
677
678       start_timer ();
679       for (count=0; count < iterations; count++)
680         {
681           err = gcry_pk_verify (sig, data, pub_key);
682           if (err)
683             {
684               putchar ('\n');
685               show_sexp ("seckey:\n", sec_key);
686               show_sexp ("data:\n", data);
687               show_sexp ("sig:\n", sig);
688               die ("verify failed (%d): %s\n", count, gpg_strerror (err));
689             }
690         }
691       stop_timer ();
692       printf ("     %s", elapsed_time ());
693
694       if (no_blinding)
695         {
696           fflush (stdout);
697           x = gcry_mpi_new (p_sizes[testno]);
698           gcry_mpi_randomize (x, p_sizes[testno]-8, GCRY_WEAK_RANDOM);
699           err = gcry_sexp_build (&data, NULL,
700                                  "(data (flags no-blinding) (value %m))", x);
701           gcry_mpi_release (x);
702           if (err)
703             die ("converting data failed: %s\n", gcry_strerror (err));
704
705           start_timer ();
706           for (count=0; count < iterations; count++)
707             {
708               gcry_sexp_release (sig);
709               err = gcry_pk_sign (&sig, data, sec_key);
710               if (err)
711                 die ("signing failed (%d): %s\n", count, gpg_strerror (err));
712             }
713           stop_timer ();
714           printf ("   %s", elapsed_time ());
715           fflush (stdout);
716         }
717
718       putchar ('\n');
719       fflush (stdout);
720
721       gcry_sexp_release (sig);
722       gcry_sexp_release (data);
723       gcry_sexp_release (sec_key);
724       gcry_sexp_release (pub_key);
725     }
726 }
727
728
729
730 static void
731 dsa_bench (int iterations, int print_header)
732 {
733   gpg_error_t err;
734   gcry_sexp_t pub_key[3], sec_key[3];
735   int p_sizes[3] = { 1024, 2048, 3072 };
736   int q_sizes[3] = { 160, 224, 256 };
737   gcry_sexp_t data;
738   gcry_sexp_t sig;
739   int i, j;
740
741   err = gcry_sexp_sscan (pub_key+0, NULL, sample_public_dsa_key_1024,
742                          strlen (sample_public_dsa_key_1024));
743   if (!err)
744     err = gcry_sexp_sscan (sec_key+0, NULL, sample_private_dsa_key_1024,
745                            strlen (sample_private_dsa_key_1024));
746   if (!err)
747     err = gcry_sexp_sscan (pub_key+1, NULL, sample_public_dsa_key_2048,
748                            strlen (sample_public_dsa_key_2048));
749   if (!err)
750     err = gcry_sexp_sscan (sec_key+1, NULL, sample_private_dsa_key_2048,
751                            strlen (sample_private_dsa_key_2048));
752   if (!err)
753     err = gcry_sexp_sscan (pub_key+2, NULL, sample_public_dsa_key_3072,
754                            strlen (sample_public_dsa_key_3072));
755   if (!err)
756     err = gcry_sexp_sscan (sec_key+2, NULL, sample_private_dsa_key_3072,
757                            strlen (sample_private_dsa_key_3072));
758   if (err)
759     {
760       fprintf (stderr, PGM ": converting sample keys failed: %s\n",
761                gcry_strerror (err));
762       exit (1);
763     }
764
765   if (print_header)
766     printf ("Algorithm         generate %4d*sign %4d*verify\n"
767             "------------------------------------------------\n",
768             iterations, iterations );
769   for (i=0; i < DIM (q_sizes); i++)
770     {
771       gcry_mpi_t x;
772
773       x = gcry_mpi_new (q_sizes[i]);
774       gcry_mpi_randomize (x, q_sizes[i], GCRY_WEAK_RANDOM);
775       err = gcry_sexp_build (&data, NULL, "(data (flags raw) (value %m))", x);
776       gcry_mpi_release (x);
777       if (err)
778         {
779           fprintf (stderr, PGM ": converting data failed: %s\n",
780                    gcry_strerror (err));
781           exit (1);
782         }
783
784       printf ("DSA %d/%d             -", p_sizes[i], q_sizes[i]);
785       fflush (stdout);
786
787       start_timer ();
788       for (j=0; j < iterations; j++)
789         {
790           err = gcry_pk_sign (&sig, data, sec_key[i]);
791           if (err)
792             {
793               putchar ('\n');
794               fprintf (stderr, PGM ": signing failed: %s\n",
795                        gpg_strerror (err));
796               exit (1);
797             }
798         }
799       stop_timer ();
800       printf ("   %s", elapsed_time ());
801       fflush (stdout);
802
803       start_timer ();
804       for (j=0; j < iterations; j++)
805         {
806           err = gcry_pk_verify (sig, data, pub_key[i]);
807           if (err)
808             {
809               putchar ('\n');
810               fprintf (stderr, PGM ": verify failed: %s\n",
811                        gpg_strerror (err));
812               exit (1);
813             }
814         }
815       stop_timer ();
816       printf ("     %s\n", elapsed_time ());
817       fflush (stdout);
818
819       gcry_sexp_release (sig);
820       gcry_sexp_release (data);
821     }
822
823
824   for (i=0; i < DIM (q_sizes); i++)
825     {
826       gcry_sexp_release (sec_key[i]);
827       gcry_sexp_release (pub_key[i]);
828     }
829 }
830
831
832 static void
833 ecc_bench (int iterations, int print_header)
834 {
835 #if USE_ECC
836   gpg_error_t err;
837   int p_sizes[] = { 192, 224, 256, 384, 521 };
838   int testno;
839
840   if (print_header)
841     printf ("Algorithm         generate %4d*sign %4d*verify\n"
842             "------------------------------------------------\n",
843             iterations, iterations );
844   for (testno=0; testno < DIM (p_sizes); testno++)
845     {
846       gcry_sexp_t key_spec, key_pair, pub_key, sec_key;
847       gcry_mpi_t x;
848       gcry_sexp_t data;
849       gcry_sexp_t sig = NULL;
850       int count;
851
852       printf ("ECDSA %3d bit ", p_sizes[testno]);
853       fflush (stdout);
854
855       err = gcry_sexp_build (&key_spec, NULL,
856                              "(genkey (ECDSA (nbits %d)))", p_sizes[testno]);
857       if (err)
858         die ("creating S-expression failed: %s\n", gcry_strerror (err));
859
860       start_timer ();
861       err = gcry_pk_genkey (&key_pair, key_spec);
862       if (err)
863         die ("creating %d bit ECC key failed: %s\n",
864              p_sizes[testno], gcry_strerror (err));
865
866       pub_key = gcry_sexp_find_token (key_pair, "public-key", 0);
867       if (! pub_key)
868         die ("public part missing in key\n");
869       sec_key = gcry_sexp_find_token (key_pair, "private-key", 0);
870       if (! sec_key)
871         die ("private part missing in key\n");
872       gcry_sexp_release (key_pair);
873       gcry_sexp_release (key_spec);
874
875       stop_timer ();
876       printf ("     %s", elapsed_time ());
877       fflush (stdout);
878
879       x = gcry_mpi_new (p_sizes[testno]);
880       gcry_mpi_randomize (x, p_sizes[testno], GCRY_WEAK_RANDOM);
881       err = gcry_sexp_build (&data, NULL, "(data (flags raw) (value %m))", x);
882       gcry_mpi_release (x);
883       if (err)
884         die ("converting data failed: %s\n", gcry_strerror (err));
885
886       start_timer ();
887       for (count=0; count < iterations; count++)
888         {
889           gcry_sexp_release (sig);
890           err = gcry_pk_sign (&sig, data, sec_key);
891           if (err)
892             die ("signing failed: %s\n", gpg_strerror (err));
893         }
894       stop_timer ();
895       printf ("   %s", elapsed_time ());
896       fflush (stdout);
897
898       start_timer ();
899       for (count=0; count < iterations; count++)
900         {
901           err = gcry_pk_verify (sig, data, pub_key);
902           if (err)
903             {
904               putchar ('\n');
905               show_sexp ("seckey:\n", sec_key);
906               show_sexp ("data:\n", data);
907               show_sexp ("sig:\n", sig);
908               die ("verify failed: %s\n", gpg_strerror (err));
909             }
910         }
911       stop_timer ();
912       printf ("     %s\n", elapsed_time ());
913       fflush (stdout);
914
915       gcry_sexp_release (sig);
916       gcry_sexp_release (data);
917       gcry_sexp_release (sec_key);
918       gcry_sexp_release (pub_key);
919     }
920 #endif /*USE_ECC*/
921 }
922
923
924
925 static void
926 do_powm ( const char *n_str, const char *e_str, const char *m_str)
927 {
928   gcry_mpi_t e, n, msg, cip;
929   gcry_error_t err;
930   int i;
931
932   err = gcry_mpi_scan (&n, GCRYMPI_FMT_HEX, n_str, 0, 0);
933   if (err) BUG ();
934   err = gcry_mpi_scan (&e, GCRYMPI_FMT_HEX, e_str, 0, 0);
935   if (err) BUG ();
936   err = gcry_mpi_scan (&msg, GCRYMPI_FMT_HEX, m_str, 0, 0);
937   if (err) BUG ();
938
939   cip = gcry_mpi_new (0);
940
941   start_timer ();
942   for (i=0; i < 1000; i++)
943     gcry_mpi_powm (cip, msg, e, n);
944   stop_timer ();
945   printf (" %s", elapsed_time ()); fflush (stdout);
946 /*    { */
947 /*      char *buf; */
948
949 /*      if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, (void**)&buf, NULL, cip)) */
950 /*        BUG (); */
951 /*      printf ("result: %s\n", buf); */
952 /*      gcry_free (buf); */
953 /*    } */
954   gcry_mpi_release (cip);
955   gcry_mpi_release (msg);
956   gcry_mpi_release (n);
957   gcry_mpi_release (e);
958 }
959
960
961 static void
962 mpi_bench (void)
963 {
964   printf ("%-10s", "powm"); fflush (stdout);
965
966   do_powm (
967 "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E4",
968            "29", 
969 "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8"
970            );
971   do_powm (
972            "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA40716",
973            "29", 
974            "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847"
975            );
976   do_powm (
977            "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA4071620A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA40716",
978            "29", 
979            "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847"
980            );
981
982   putchar ('\n');
983
984
985 }
986
987
988 int
989 main( int argc, char **argv )
990 {
991   int last_argc = -1;
992   int no_blinding = 0;
993   int use_random_daemon = 0;
994
995   if (argc)
996     { argc--; argv++; }
997
998   while (argc && last_argc != argc )
999     {
1000       last_argc = argc;
1001       if (!strcmp (*argv, "--"))
1002         {
1003           argc--; argv++;
1004           break;
1005         }
1006       else if (!strcmp (*argv, "--help"))
1007         {
1008           fputs ("usage: benchmark "
1009                  "[md|cipher|random|mpi|rsa|dsa|ecc [algonames]]\n",
1010                  stdout);
1011           exit (0);
1012         }
1013       else if (!strcmp (*argv, "--verbose"))
1014         {
1015           verbose++;
1016           argc--; argv++;
1017         }
1018       else if (!strcmp (*argv, "--use-random-daemon"))
1019         {
1020           use_random_daemon = 1;
1021           argc--; argv++;
1022         }
1023       else if (!strcmp (*argv, "--no-blinding"))
1024         {
1025           no_blinding = 1;
1026           argc--; argv++;
1027         }
1028       else if (!strcmp (*argv, "--large-buffers"))
1029         {
1030           large_buffers = 1;
1031           argc--; argv++;
1032         }
1033       else if (!strcmp (*argv, "--cipher-repetition"))
1034         {
1035           argc--; argv++;
1036           if (argc)
1037             {
1038               cipher_repetitions = atoi(*argv);
1039               argc--; argv++;
1040             }
1041         }
1042       else if (!strcmp (*argv, "--fips"))
1043         {
1044           argc--; argv++;
1045           /* This command needs to be called before gcry_check_version.  */
1046           gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
1047         }
1048     }          
1049
1050   gcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
1051
1052   if (!gcry_check_version (GCRYPT_VERSION))
1053     {
1054       fprintf (stderr, PGM ": version mismatch\n");
1055       exit (1);
1056     }
1057   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
1058
1059   if (use_random_daemon)
1060     gcry_control (GCRYCTL_USE_RANDOM_DAEMON, 1);
1061
1062   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
1063
1064
1065   if (cipher_repetitions < 1)
1066     cipher_repetitions = 1;
1067   
1068   if ( !argc )
1069     {
1070       gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1071       md_bench (NULL);
1072       putchar ('\n');
1073       cipher_bench (NULL);
1074       putchar ('\n');
1075       rsa_bench (100, 1, no_blinding);
1076       dsa_bench (100, 0);
1077       ecc_bench (100, 0);
1078       putchar ('\n');
1079       mpi_bench ();
1080       putchar ('\n');
1081       random_bench (0);
1082     }
1083   else if ( !strcmp (*argv, "random") || !strcmp (*argv, "strongrandom"))
1084     {
1085       if (argc == 1)
1086         random_bench ((**argv == 's'));
1087       else if (argc == 2)
1088         {
1089           gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, argv[1]);
1090           random_bench ((**argv == 's'));
1091           gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1092         }
1093       else
1094         fputs ("usage: benchmark [strong]random [seedfile]\n", stdout);
1095     }
1096   else if ( !strcmp (*argv, "md"))
1097     {
1098       if (argc == 1)
1099         md_bench (NULL);
1100       else
1101         for (argc--, argv++; argc; argc--, argv++)
1102           md_bench ( *argv );
1103     }
1104   else if ( !strcmp (*argv, "cipher"))
1105     {
1106       if (argc == 1)
1107         cipher_bench (NULL);
1108       else
1109         for (argc--, argv++; argc; argc--, argv++)
1110           cipher_bench ( *argv );
1111     }
1112   else if ( !strcmp (*argv, "mpi"))
1113     {
1114         mpi_bench ();
1115     }
1116   else if ( !strcmp (*argv, "rsa"))
1117     {
1118         gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1119         rsa_bench (100, 1, no_blinding);
1120     }
1121   else if ( !strcmp (*argv, "dsa"))
1122     {
1123         gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1124         dsa_bench (100, 1);
1125     }
1126   else if ( !strcmp (*argv, "ecc"))
1127     {
1128         gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1129         ecc_bench (100, 1);
1130     }
1131   else
1132     {
1133       fprintf (stderr, PGM ": bad arguments\n");
1134       return 1;
1135     }
1136   
1137   return 0;
1138 }
1139