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