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