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