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