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