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