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