tests: Fix memory leak.
[libgcrypt.git] / tests / benchmark.c
1 /* benchmark.c - for libgcrypt
2  * Copyright (C) 2002, 2004, 2005, 2006, 2008 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser general Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stdarg.h>
26
27 #ifdef _GCRYPT_IN_LIBGCRYPT
28 # include "../src/gcrypt-int.h"
29 # include "../compat/libcompat.h"
30 #else
31 # include <gcrypt.h>
32 #endif
33
34 #include "stopwatch.h"
35
36
37 #define PGM "benchmark"
38
39 static int verbose;
40
41 /* Do encryption tests with large buffers.  */
42 static int large_buffers;
43
44 /* Number of cipher repetitions.  */
45 static int cipher_repetitions;
46
47 /* Number of hash repetitions.  */
48 static int hash_repetitions;
49
50 /* Number of hash repetitions.  */
51 static int mac_repetitions;
52
53 /* Alignment of the buffers.  */
54 static int buffer_alignment;
55
56 /* Whether to include the keysetup in the cipher timings.  */
57 static int cipher_with_keysetup;
58
59 /* Whether fips mode was active at startup.  */
60 static int in_fips_mode;
61
62 /* Whether we are running as part of the regression test suite.  */
63 static int in_regression_test;
64
65 /* Whether --progress is in use.  */
66 static int with_progress;
67
68 /* Runtime flag to switch to a different progress output.  */
69 static int single_char_progress;
70
71
72 static const char sample_private_dsa_key_1024[] =
73 "(private-key\n"
74 "  (dsa\n"
75 "   (p #00A126202D592214C5A8F6016E2C3F4256052ACB1CB17D88E64B1293FAF08F5E4685"
76        "03E6F68366B326A56284370EB2103E92D8346A163E44A08FDC422AC8E9E44268557A"
77        "853539A6AF39353A59CE5E78FD98B57D0F3E3A7EBC8A256AC9A775BA59689F3004BF"
78        "C3035730C4C0C51626C5D7F5852637EC589BB29DAB46C161572E4B#)\n"
79 "   (q #00DEB5A296421887179ECA1762884DE2AF8185AFC5#)\n"
80 "   (g #3958B34AE7747194ECBD312F8FEE8CBE3918E94DF9FD11E2912E56318F33BDC38622"
81        "B18DDFF393074BCA8BAACF50DF27AEE529F3E8AEECE55C398DAB3A5E04C2EA142312"
82        "FACA2FE7F0A88884F8DAC3979EE67598F9A383B2A2325F035C796F352A5C3CDF2CB3"
83        "85AD24EC52A6E55247E1BB37D260F79E617D2A4446415B6AD79A#)\n"
84 "   (y #519E9FE9AB0545A6724E74603B7B04E48DC1437E0284A11EA605A7BA8AB1CF354FD4"
85        "ECC93880AC293391C69B558AD84E7AAFA88F11D028CF3A378F241D6B056A90C588F6"
86        "66F68D27262B4DA84657D15057D371BCEC1F6504032507D5B881E45FC93A1B973155"
87        "D91C57219D090C3ACD75E7C2B9F1176A208AC03D6C12AC28A271#)\n"
88 "   (x #4186F8A58C5DF46C5BCFC7006BEEBF05E93C0CA7#)\n"
89 "))\n";
90
91 static const char sample_public_dsa_key_1024[] =
92 "(public-key\n"
93 "  (dsa\n"
94 "   (p #00A126202D592214C5A8F6016E2C3F4256052ACB1CB17D88E64B1293FAF08F5E4685"
95        "03E6F68366B326A56284370EB2103E92D8346A163E44A08FDC422AC8E9E44268557A"
96        "853539A6AF39353A59CE5E78FD98B57D0F3E3A7EBC8A256AC9A775BA59689F3004BF"
97        "C3035730C4C0C51626C5D7F5852637EC589BB29DAB46C161572E4B#)\n"
98 "   (q #00DEB5A296421887179ECA1762884DE2AF8185AFC5#)\n"
99 "   (g #3958B34AE7747194ECBD312F8FEE8CBE3918E94DF9FD11E2912E56318F33BDC38622"
100        "B18DDFF393074BCA8BAACF50DF27AEE529F3E8AEECE55C398DAB3A5E04C2EA142312"
101        "FACA2FE7F0A88884F8DAC3979EE67598F9A383B2A2325F035C796F352A5C3CDF2CB3"
102        "85AD24EC52A6E55247E1BB37D260F79E617D2A4446415B6AD79A#)\n"
103 "   (y #519E9FE9AB0545A6724E74603B7B04E48DC1437E0284A11EA605A7BA8AB1CF354FD4"
104        "ECC93880AC293391C69B558AD84E7AAFA88F11D028CF3A378F241D6B056A90C588F6"
105        "66F68D27262B4DA84657D15057D371BCEC1F6504032507D5B881E45FC93A1B973155"
106        "D91C57219D090C3ACD75E7C2B9F1176A208AC03D6C12AC28A271#)\n"
107 "))\n";
108
109
110 static const char sample_private_dsa_key_2048[] =
111 "(private-key\n"
112 "  (dsa\n"
113 "   (p #00B54636673962B64F7DC23C71ACEF6E7331796F607560B194DFCC0CA370E858A365"
114        "A413152FB6EB8C664BD171AC316FE5B381CD084D07377571599880A068EF1382D85C"
115        "308B4E9DEAC12D66DE5C4A826EBEB5ED94A62E7301E18927E890589A2F230272A150"
116        "C118BC3DC2965AE0D05BE4F65C6137B2BA7EDABB192C3070D202C10AA3F534574970"
117        "71454DB8A73DDB6511A5BA98EF1450FD90DE5BAAFC9FD3AC22EBEA612DD075BB7405"
118        "D56866D125E33982C046808F7CEBA8E5C0B9F19A6FE451461660A1CBA9EF68891179"
119        "0256A573D3B8F35A5C7A0C6C31F2DB90E25A26845252AD9E485EF2D339E7B5890CD4"
120        "2F9C9F315ED409171EC35CA04CC06B275577B3#)\n"
121 "   (q #00DA67989167FDAC4AE3DF9247A716859A30C0CF9C5A6DBA01EABA3481#)\n"
122 "   (g #48E35DA584A089D05142AA63603FDB00D131B07A0781E2D5A8F9614D2B33D3E40A78"
123        "98A9E10CDBB612CF093F95A3E10D09566726F2C12823836B2D9CD974BB695665F3B3"
124        "5D219A9724B87F380BD5207EDA0AE38C79E8F18122C3F76E4CEB0ABED3250914987F"
125        "B30D4B9E19C04C28A5D4F45560AF586F6A1B41751EAD90AE7F044F4E2A4A50C1F508"
126        "4FC202463F478F678B9A19392F0D2961C5391C546EF365368BB46410C9C1CEE96E9F"
127        "0C953570C2ED06328B11C90E86E57CAA7FA5ABAA278E22A4C8C08E16EE59F484EC44"
128        "2CF55535BAA2C6BEA8833A555372BEFE1E665D3C7DAEF58061D5136331EF4EB61BC3"
129        "6EE4425A553AF8885FEA15A88135BE133520#)\n"
130 "   (y #66E0D1A69D663466F8FEF2B7C0878DAC93C36A2FB2C05E0306A53B926021D4B92A1C"
131        "2FA6860061E88E78CBBBA49B0E12700F07DBF86F72CEB2927EDAC0C7E3969C3A47BB"
132        "4E0AE93D8BB3313E93CC7A72DFEEE442EFBC81B3B2AEC9D8DCBE21220FB760201D79"
133        "328C41C773866587A44B6954767D022A88072900E964089D9B17133603056C985C4F"
134        "8A0B648F297F8D2C3CB43E4371DC6002B5B12CCC085BDB2CFC5074A0587566187EE3"
135        "E11A2A459BD94726248BB8D6CC62938E11E284C2C183576FBB51749EB238C4360923"
136        "79C08CE1C8CD77EB57404CE9B4744395ACF721487450BADE3220576F2F816248B0A7"
137        "14A264330AECCB24DE2A1107847B23490897#)\n"
138 "   (x #477BD14676E22563C5ABA68025CEBA2A48D485F5B2D4AD4C0EBBD6D0#)\n"
139 "))\n";
140
141
142 static const char sample_public_dsa_key_2048[] =
143 "(public-key\n"
144 "  (dsa\n"
145 "   (p #00B54636673962B64F7DC23C71ACEF6E7331796F607560B194DFCC0CA370E858A365"
146        "A413152FB6EB8C664BD171AC316FE5B381CD084D07377571599880A068EF1382D85C"
147        "308B4E9DEAC12D66DE5C4A826EBEB5ED94A62E7301E18927E890589A2F230272A150"
148        "C118BC3DC2965AE0D05BE4F65C6137B2BA7EDABB192C3070D202C10AA3F534574970"
149        "71454DB8A73DDB6511A5BA98EF1450FD90DE5BAAFC9FD3AC22EBEA612DD075BB7405"
150        "D56866D125E33982C046808F7CEBA8E5C0B9F19A6FE451461660A1CBA9EF68891179"
151        "0256A573D3B8F35A5C7A0C6C31F2DB90E25A26845252AD9E485EF2D339E7B5890CD4"
152        "2F9C9F315ED409171EC35CA04CC06B275577B3#)\n"
153 "   (q #00DA67989167FDAC4AE3DF9247A716859A30C0CF9C5A6DBA01EABA3481#)\n"
154 "   (g #48E35DA584A089D05142AA63603FDB00D131B07A0781E2D5A8F9614D2B33D3E40A78"
155        "98A9E10CDBB612CF093F95A3E10D09566726F2C12823836B2D9CD974BB695665F3B3"
156        "5D219A9724B87F380BD5207EDA0AE38C79E8F18122C3F76E4CEB0ABED3250914987F"
157        "B30D4B9E19C04C28A5D4F45560AF586F6A1B41751EAD90AE7F044F4E2A4A50C1F508"
158        "4FC202463F478F678B9A19392F0D2961C5391C546EF365368BB46410C9C1CEE96E9F"
159        "0C953570C2ED06328B11C90E86E57CAA7FA5ABAA278E22A4C8C08E16EE59F484EC44"
160        "2CF55535BAA2C6BEA8833A555372BEFE1E665D3C7DAEF58061D5136331EF4EB61BC3"
161        "6EE4425A553AF8885FEA15A88135BE133520#)\n"
162 "   (y #66E0D1A69D663466F8FEF2B7C0878DAC93C36A2FB2C05E0306A53B926021D4B92A1C"
163        "2FA6860061E88E78CBBBA49B0E12700F07DBF86F72CEB2927EDAC0C7E3969C3A47BB"
164        "4E0AE93D8BB3313E93CC7A72DFEEE442EFBC81B3B2AEC9D8DCBE21220FB760201D79"
165        "328C41C773866587A44B6954767D022A88072900E964089D9B17133603056C985C4F"
166        "8A0B648F297F8D2C3CB43E4371DC6002B5B12CCC085BDB2CFC5074A0587566187EE3"
167        "E11A2A459BD94726248BB8D6CC62938E11E284C2C183576FBB51749EB238C4360923"
168        "79C08CE1C8CD77EB57404CE9B4744395ACF721487450BADE3220576F2F816248B0A7"
169        "14A264330AECCB24DE2A1107847B23490897#)\n"
170 "))\n";
171
172
173 static const char sample_private_dsa_key_3072[] =
174 "(private-key\n"
175 "  (dsa\n"
176 "   (p #00BA73E148AEA5E8B64878AF5BE712B8302B9671C5F3EEB7722A9D0D9868D048C938"
177        "877C91C335C7819292E69C7D34264F1578E32EC2DA8408DF75D0EB76E0D3030B84B5"
178        "62D8EF93AB53BAB6B8A5DE464F5CA87AEA43BDCF0FB0B7815AA3114CFC84FD916A83"
179        "B3D5FD78390189332232E9D037D215313FD002FF46C048B66703F87FAE092AAA0988"
180        "AC745336EBE672A01DEDBD52395783579B67CF3AE1D6F1602CCCB12154FA0E00AE46"
181        "0D9B289CF709194625BCB919B11038DEFC50ADBBA20C3F320078E4E9529B4F6848E2"
182        "AB5E6278DB961FE226F2EEBD201E071C48C5BEF98B4D9BEE42C1C7102D893EBF8902"
183        "D7A91266340AFD6CE1D09E52282FFF5B97EAFA3886A3FCF84FF76D1E06538D0D8E60"
184        "B3332145785E07D29A5965382DE3470D1D888447FA9C00A2373378FC3FA7B9F7D17E"
185        "95A6A5AE1397BE46D976EF2C96E89913AC4A09351CA661BF6F67E30407DA846946C7"
186        "62D9BAA6B77825097D3E7B886456BB32E3E74516BF3FD93D71B257AA8F723E01CE33"
187        "8015353D3778B02B892AF7#)\n"
188 "   (q #00BFF3F3CC18FA018A5B8155A8695E1E4939660D5E4759322C39D50F3B93E5F68B#)\n"
189 "   (g #6CCFD8219F5FCE8EF2BEF3262929787140847E38674B1EF8DB20255E212CB6330EC4"
190        "DFE8A26AB7ECC5760DEB9BBF59A2B2821D510F1868172222867558B8D204E889C474"
191        "7CA30FBF9D8CF41AE5D5BD845174641101593849FF333E6C93A6550931B2B9D56B98"
192        "9CAB01729D9D736FA6D24A74D2DDE1E9E648D141473E443DD6BBF0B3CAB64F9FE4FC"
193        "134B2EB57437789F75C744DF1FA67FA8A64603E5441BC7ECE29E00BDF262BDC81E8C"
194        "7330A18A412DE38E7546D342B89A0AF675A89E6BEF00540EB107A2FE74EA402B0D89"
195        "F5C02918DEEEAF8B8737AC866B09B50810AB8D8668834A1B9E1E53866E2B0A926FAB"
196        "120A0CDE5B3715FFFE6ACD1AB73588DCC1EC4CE9392FE57F8D1D35811200CB07A0E6"
197        "374E2C4B0AEB7E3D077B8545C0E438DCC0F1AE81E186930E99EBC5B91B77E92803E0"
198        "21602887851A4FFDB3A7896AC655A0901218C121C5CBB0931E7D5EAC243F37711B5F"
199        "D5A62B1B38A83F03D8F6703D8B98DF367FC8A76990335F62173A5391836F0F2413EC"
200        "4997AF9EB55C6660B01A#)\n"
201 "   (y #2320B22434C5DB832B4EC267CC52E78DD5CCFA911E8F0804E7E7F32B186B2D4167AE"
202        "4AA6869822E76400492D6A193B0535322C72B0B7AA4A87E33044FDC84BE24C64A053"
203        "A37655EE9EABDCDC1FDF63F3F1C677CEB41595DF7DEFE9178D85A3D621B4E4775492"
204        "8C0A58D2458D06F9562E4DE2FE6129A64063A99E88E54485B97484A28188C4D33F15"
205        "DDC903B6CEA0135E3E3D27B4EA39319696305CE93D7BA7BE00367DBE3AAF43491E71"
206        "CBF254744A5567F5D70090D6139E0C990239627B3A1C5B20B6F9F6374B8D8D8A8997"
207        "437265BE1E3B4810D4B09254400DE287A0DFFBAEF339E48D422B1D41A37E642BC026"
208        "73314701C8FA9792845C129351A87A945A03E6C895860E51D6FB8B7340A94D1A8A7B"
209        "FA85AC83B4B14E73AB86CB96C236C8BFB0978B61B2367A7FE4F7891070F56C78D5DD"
210        "F5576BFE5BE4F333A4E2664E79528B3294907AADD63F4F2E7AA8147B928D8CD69765"
211        "3DB98C4297CB678046ED55C0DBE60BF7142C594603E4D705DC3D17270F9F086EC561"
212        "2703D518D8D49FF0EBE6#)\n"
213 "   (x #00A9FFFC88E67D6F7B810E291C050BAFEA7FC4A75E8D2F16CFED3416FD77607232#)\n"
214 "))\n";
215
216 static const char sample_public_dsa_key_3072[] =
217 "(public-key\n"
218 "  (dsa\n"
219 "   (p #00BA73E148AEA5E8B64878AF5BE712B8302B9671C5F3EEB7722A9D0D9868D048C938"
220        "877C91C335C7819292E69C7D34264F1578E32EC2DA8408DF75D0EB76E0D3030B84B5"
221        "62D8EF93AB53BAB6B8A5DE464F5CA87AEA43BDCF0FB0B7815AA3114CFC84FD916A83"
222        "B3D5FD78390189332232E9D037D215313FD002FF46C048B66703F87FAE092AAA0988"
223        "AC745336EBE672A01DEDBD52395783579B67CF3AE1D6F1602CCCB12154FA0E00AE46"
224        "0D9B289CF709194625BCB919B11038DEFC50ADBBA20C3F320078E4E9529B4F6848E2"
225        "AB5E6278DB961FE226F2EEBD201E071C48C5BEF98B4D9BEE42C1C7102D893EBF8902"
226        "D7A91266340AFD6CE1D09E52282FFF5B97EAFA3886A3FCF84FF76D1E06538D0D8E60"
227        "B3332145785E07D29A5965382DE3470D1D888447FA9C00A2373378FC3FA7B9F7D17E"
228        "95A6A5AE1397BE46D976EF2C96E89913AC4A09351CA661BF6F67E30407DA846946C7"
229        "62D9BAA6B77825097D3E7B886456BB32E3E74516BF3FD93D71B257AA8F723E01CE33"
230        "8015353D3778B02B892AF7#)\n"
231 "   (q #00BFF3F3CC18FA018A5B8155A8695E1E4939660D5E4759322C39D50F3B93E5F68B#)\n"
232 "   (g #6CCFD8219F5FCE8EF2BEF3262929787140847E38674B1EF8DB20255E212CB6330EC4"
233        "DFE8A26AB7ECC5760DEB9BBF59A2B2821D510F1868172222867558B8D204E889C474"
234        "7CA30FBF9D8CF41AE5D5BD845174641101593849FF333E6C93A6550931B2B9D56B98"
235        "9CAB01729D9D736FA6D24A74D2DDE1E9E648D141473E443DD6BBF0B3CAB64F9FE4FC"
236        "134B2EB57437789F75C744DF1FA67FA8A64603E5441BC7ECE29E00BDF262BDC81E8C"
237        "7330A18A412DE38E7546D342B89A0AF675A89E6BEF00540EB107A2FE74EA402B0D89"
238        "F5C02918DEEEAF8B8737AC866B09B50810AB8D8668834A1B9E1E53866E2B0A926FAB"
239        "120A0CDE5B3715FFFE6ACD1AB73588DCC1EC4CE9392FE57F8D1D35811200CB07A0E6"
240        "374E2C4B0AEB7E3D077B8545C0E438DCC0F1AE81E186930E99EBC5B91B77E92803E0"
241        "21602887851A4FFDB3A7896AC655A0901218C121C5CBB0931E7D5EAC243F37711B5F"
242        "D5A62B1B38A83F03D8F6703D8B98DF367FC8A76990335F62173A5391836F0F2413EC"
243        "4997AF9EB55C6660B01A#)\n"
244 "   (y #2320B22434C5DB832B4EC267CC52E78DD5CCFA911E8F0804E7E7F32B186B2D4167AE"
245        "4AA6869822E76400492D6A193B0535322C72B0B7AA4A87E33044FDC84BE24C64A053"
246        "A37655EE9EABDCDC1FDF63F3F1C677CEB41595DF7DEFE9178D85A3D621B4E4775492"
247        "8C0A58D2458D06F9562E4DE2FE6129A64063A99E88E54485B97484A28188C4D33F15"
248        "DDC903B6CEA0135E3E3D27B4EA39319696305CE93D7BA7BE00367DBE3AAF43491E71"
249        "CBF254744A5567F5D70090D6139E0C990239627B3A1C5B20B6F9F6374B8D8D8A8997"
250        "437265BE1E3B4810D4B09254400DE287A0DFFBAEF339E48D422B1D41A37E642BC026"
251        "73314701C8FA9792845C129351A87A945A03E6C895860E51D6FB8B7340A94D1A8A7B"
252        "FA85AC83B4B14E73AB86CB96C236C8BFB0978B61B2367A7FE4F7891070F56C78D5DD"
253        "F5576BFE5BE4F333A4E2664E79528B3294907AADD63F4F2E7AA8147B928D8CD69765"
254        "3DB98C4297CB678046ED55C0DBE60BF7142C594603E4D705DC3D17270F9F086EC561"
255        "2703D518D8D49FF0EBE6#)\n"
256 "))\n";
257
258
259 static const char sample_public_elg_key_1024[] =
260 "(public-key"
261 "  (elg"
262 "   (p #00F7CC7C08AF096B620C545C9353B1140D698FF8BE2D97A3515C17C7F8DABCDB8FB6"
263        "64A46416C90C530C18DF5ABB6C1DDE3AE2FA9DDC9CE40DF644CDE2E759F6DE43F31A"
264        "EEEBC136A460B3E4B0A8F99326A335145B19F4C81B13804894B7D2A30F78A8A7D7F4"
265        "52B83836FDB0DE90BE327FB5E5318757BEF5FE0FC3A5461CBEA0D3#)"
266 "   (g #06#)"
267 "   (y #36B38FB63E3340A0DD8A0468E9FAA512A32DA010BF7110201D0A3DF1B8FEA0E16F3C"
268        "80374584E554804B96EAA8C270FE531F75D0DBD81BA65640EDB1F76D46C27D2925B7"
269        "3EC3B295CDAEEF242904A84D74FB2879425F82D4C5B59BB49A992F85D574168DED85"
270        "D227600BBEF7AF0B8F0DEB785528370E4C4B3E4D65C536122A5A#)"
271 "   ))";
272 static const char sample_private_elg_key_1024[] =
273 "(private-key"
274 "  (elg"
275 "   (p #00F7CC7C08AF096B620C545C9353B1140D698FF8BE2D97A3515C17C7F8DABCDB8FB6"
276        "64A46416C90C530C18DF5ABB6C1DDE3AE2FA9DDC9CE40DF644CDE2E759F6DE43F31A"
277        "EEEBC136A460B3E4B0A8F99326A335145B19F4C81B13804894B7D2A30F78A8A7D7F4"
278        "52B83836FDB0DE90BE327FB5E5318757BEF5FE0FC3A5461CBEA0D3#)"
279 "   (g #06#)"
280 "   (y #36B38FB63E3340A0DD8A0468E9FAA512A32DA010BF7110201D0A3DF1B8FEA0E16F3C"
281        "80374584E554804B96EAA8C270FE531F75D0DBD81BA65640EDB1F76D46C27D2925B7"
282        "3EC3B295CDAEEF242904A84D74FB2879425F82D4C5B59BB49A992F85D574168DED85"
283        "D227600BBEF7AF0B8F0DEB785528370E4C4B3E4D65C536122A5A#)"
284 "   (x #03656C6186FCD27D4A4B1F5010DC0D2AE7833B501E423FCD51DE5EB6D80DACFE#)"
285 "   ))";
286
287
288 static const char sample_public_elg_key_2048[] =
289 "(public-key"
290 "  (elg"
291 "   (p #00BE5A2BB4E562D7B644E3D01321CB818DBA27295C339FC2C47EAE9823225EE1E7B6"
292        "38C5DE300E931080E09CC89A18C9D180C16559FEF0D89D6A09534BB86489CCCEE30D"
293        "C18E007A8726BB99F2B2D90D2694597757B120CD2435C0098AD1B74C20004C25BA97"
294        "73EAA4FBEC594EE17F8B25867EEB0F9F857C751116ADED68ADA2A1E9F9F4F40D18F0"
295        "EC1221CA6A746FC5F4CDA2B8B5D0AB83834564ACF6FDBB1AB01D4BFBD1E2C0108FF5"
296        "5FB3190C6D6DA4D95EA683EFA44935CFBC0BF5C6118ACC3768AEA9A98D06024841B8"
297        "D07C234289D22A5E3948F199C397AA991C59A55BEA0C01E91902E039116946FEA135"
298        "768011AF6B622C5AF366EF0196FC4EAEAA8127#)"
299 "   (g #07#)"
300 "   (y #5AFF87BC23D8B97AA62897A5C1CDFFA86C59F39EDBD6012B6F333CE23D872009B8C8"
301        "D1E220E18CFCADFE0AA16346BA2EA132472FFEC746D11C6E758896052313BB501210"
302        "2389C683A25A3464E9B35A192BAE0A3BB99C973126F7560D968C4A754901DC967354"
303        "D61A90ACD56D90DCC4337AFB71FAE3FD18C60EB0D6DD173877DF5DB5199C4931FE4E"
304        "5046F814422580E1162798406FC6554781142DBB7922D4B5B37A111F23761636090F"
305        "6212681E133365191CF15753AE737F17943ED4B7506DE0A85C3B6D63227F9D65ADF8"
306        "2C3DF0676C8F43B5B1C07D9AD4E6D0C812401D7DA7B9484DBA8CD3B73B19A95EB237"
307        "D493E092AEA2371AA904009C8960B0969D12#)"
308 "   ))";
309 static const char sample_private_elg_key_2048[] =
310 "(private-key"
311 "  (elg"
312 "   (p #00BE5A2BB4E562D7B644E3D01321CB818DBA27295C339FC2C47EAE9823225EE1E7B6"
313        "38C5DE300E931080E09CC89A18C9D180C16559FEF0D89D6A09534BB86489CCCEE30D"
314        "C18E007A8726BB99F2B2D90D2694597757B120CD2435C0098AD1B74C20004C25BA97"
315        "73EAA4FBEC594EE17F8B25867EEB0F9F857C751116ADED68ADA2A1E9F9F4F40D18F0"
316        "EC1221CA6A746FC5F4CDA2B8B5D0AB83834564ACF6FDBB1AB01D4BFBD1E2C0108FF5"
317        "5FB3190C6D6DA4D95EA683EFA44935CFBC0BF5C6118ACC3768AEA9A98D06024841B8"
318        "D07C234289D22A5E3948F199C397AA991C59A55BEA0C01E91902E039116946FEA135"
319        "768011AF6B622C5AF366EF0196FC4EAEAA8127#)"
320 "   (g #07#)"
321 "   (y #5AFF87BC23D8B97AA62897A5C1CDFFA86C59F39EDBD6012B6F333CE23D872009B8C8"
322        "D1E220E18CFCADFE0AA16346BA2EA132472FFEC746D11C6E758896052313BB501210"
323        "2389C683A25A3464E9B35A192BAE0A3BB99C973126F7560D968C4A754901DC967354"
324        "D61A90ACD56D90DCC4337AFB71FAE3FD18C60EB0D6DD173877DF5DB5199C4931FE4E"
325        "5046F814422580E1162798406FC6554781142DBB7922D4B5B37A111F23761636090F"
326        "6212681E133365191CF15753AE737F17943ED4B7506DE0A85C3B6D63227F9D65ADF8"
327        "2C3DF0676C8F43B5B1C07D9AD4E6D0C812401D7DA7B9484DBA8CD3B73B19A95EB237"
328        "D493E092AEA2371AA904009C8960B0969D12#)"
329 "   (x #0628C3903972C55BDC1BC4223075616D3F3BA57D55532DDB40CB14CF72070E0D28BF"
330        "D0402B9088D25ED8FC#)"
331 "  ))";
332
333 static const char sample_public_elg_key_3072[] =
334 "(public-key"
335 "  (elg"
336 "   (p #008EAA3497AFE3706E1A57FFA52E68C64C500731B58EBAFEB51C4A20AB15BA57FA72"
337        "BA1510A4703D5AA6F05DB67E4A776F92AD08800577DC686D00B793167A5D79C997E0"
338        "5B9A9E5974B4B68B4D71ED8EC37F2F45235D901997D72915643F058E712AA18275A2"
339        "C6F9F7C2B9B7CD1E814D215F12A840800B546AEF2A2E6C077CDD1A322738FFD36DB2"
340        "FA5420B5848EED870BC1A6CF55040AE8D2A5945F11AE2BCBE107B41A59EFDBD3B05C"
341        "F4C876C02C9AEAE22CD4C86806A415302936E4C1E5AA59DBBCCD2F83C20941A29888"
342        "A70ADB94D3B8A6489C46BF2C5219CD9FD2341EA21D4E68A4ECC468FD09D215FE96D4"
343        "7AEA12FD22B2456D2CC13672FC7E9772A365C68668157C51E46966B6A1831C429BA0"
344        "D513519713C49C13C5FC7C14BE0A117627B204C4478D0A93C6B57929E448C9B65BF2"
345        "390E04BC5940320C0262FC1A221E7C796493432239A6F12BC62C5CF32E8ADBC1730C"
346        "84C6E6E6BD95AF62835941F3F344AF46BFE5A8F629D5FA699FE37EF8B8C6A2484E42"
347        "D226206FDF7D1FB93A5457#)"
348 "   (g #0B#)"
349 "   (y #18E734FF645AE169079AEAFC78772371089AD3088627ECF77034AFBDF33ADF594AAF"
350        "3288F6979E0DB59CE3D2F0FEE031DFF187F1E4549D3C79668794CB19C14481ECDE2D"
351        "D50861AB674F87A011D50D35F28E424D0D2353850899C2CDD0CC8FDBFC5A0CA395F0"
352        "E605D46CBDD140DBEF426EBD638C9ADD83C195C45CE84ED2D2B21B87800C783A4F79"
353        "12226FEFBDA01C66B254534A51765AF09687275AA80C5DFBA143A6262E47C547D7E2"
354        "289413F8C5C56AED3FA7E5DF5526958E2294FE318AF590C0E720029C202563E6E686"
355        "9EC810F39A859262FB6047C1D418CAA9047A00BDB127B44B69CF6BC8E6B3709B4C23"
356        "79783C5F8457EFE23EDA6FF00D1DDCC29268FC4A6C18577BE2B7004089CBB824027A"
357        "A53C86B51DB054CC83B4F50C8923E2E9431F0A77D741237226CC68591083A2E40171"
358        "5C7B74100BB74003E2264F8B44A0B0BC5404C44218ABE65C04AA573877506CE4F48C"
359        "9E3F8AD1CD8DD9F285DD015C2FC5DEBCFA5779AD87F0BBC62E9EC6246021AB450DB9"
360        "4DDDEFAFD2C7C66E235D#)"
361 "   ))";
362 static const char sample_private_elg_key_3072[] =
363 "(private-key"
364 "  (elg"
365 "   (p #008EAA3497AFE3706E1A57FFA52E68C64C500731B58EBAFEB51C4A20AB15BA57FA72"
366        "BA1510A4703D5AA6F05DB67E4A776F92AD08800577DC686D00B793167A5D79C997E0"
367        "5B9A9E5974B4B68B4D71ED8EC37F2F45235D901997D72915643F058E712AA18275A2"
368        "C6F9F7C2B9B7CD1E814D215F12A840800B546AEF2A2E6C077CDD1A322738FFD36DB2"
369        "FA5420B5848EED870BC1A6CF55040AE8D2A5945F11AE2BCBE107B41A59EFDBD3B05C"
370        "F4C876C02C9AEAE22CD4C86806A415302936E4C1E5AA59DBBCCD2F83C20941A29888"
371        "A70ADB94D3B8A6489C46BF2C5219CD9FD2341EA21D4E68A4ECC468FD09D215FE96D4"
372        "7AEA12FD22B2456D2CC13672FC7E9772A365C68668157C51E46966B6A1831C429BA0"
373        "D513519713C49C13C5FC7C14BE0A117627B204C4478D0A93C6B57929E448C9B65BF2"
374        "390E04BC5940320C0262FC1A221E7C796493432239A6F12BC62C5CF32E8ADBC1730C"
375        "84C6E6E6BD95AF62835941F3F344AF46BFE5A8F629D5FA699FE37EF8B8C6A2484E42"
376        "D226206FDF7D1FB93A5457#)"
377 "   (g #0B#)"
378 "   (y #18E734FF645AE169079AEAFC78772371089AD3088627ECF77034AFBDF33ADF594AAF"
379        "3288F6979E0DB59CE3D2F0FEE031DFF187F1E4549D3C79668794CB19C14481ECDE2D"
380        "D50861AB674F87A011D50D35F28E424D0D2353850899C2CDD0CC8FDBFC5A0CA395F0"
381        "E605D46CBDD140DBEF426EBD638C9ADD83C195C45CE84ED2D2B21B87800C783A4F79"
382        "12226FEFBDA01C66B254534A51765AF09687275AA80C5DFBA143A6262E47C547D7E2"
383        "289413F8C5C56AED3FA7E5DF5526958E2294FE318AF590C0E720029C202563E6E686"
384        "9EC810F39A859262FB6047C1D418CAA9047A00BDB127B44B69CF6BC8E6B3709B4C23"
385        "79783C5F8457EFE23EDA6FF00D1DDCC29268FC4A6C18577BE2B7004089CBB824027A"
386        "A53C86B51DB054CC83B4F50C8923E2E9431F0A77D741237226CC68591083A2E40171"
387        "5C7B74100BB74003E2264F8B44A0B0BC5404C44218ABE65C04AA573877506CE4F48C"
388        "9E3F8AD1CD8DD9F285DD015C2FC5DEBCFA5779AD87F0BBC62E9EC6246021AB450DB9"
389        "4DDDEFAFD2C7C66E235D#)"
390 "   (x #03A73F0389E470AAC831B039F8AA0C4EBD3A47DD083E32EEA08E4911236CD597C272"
391        "9823D47A51C8535DA52FE6DAB3E8D1C20D#)"
392 "  ))";
393
394
395 #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
396 #define DIMof(type,member)   DIM(((type *)0)->member)
397 #define BUG() do {fprintf ( stderr, "Ooops at %s:%d\n", __FILE__ , __LINE__ );\
398                   exit(2);} while(0)
399
400
401 static void
402 die (const char *format, ...)
403 {
404   va_list arg_ptr ;
405
406   va_start( arg_ptr, format ) ;
407   putchar ('\n');
408   fputs ( PGM ": ", stderr);
409   vfprintf (stderr, format, arg_ptr );
410   va_end(arg_ptr);
411   exit (1);
412 }
413
414
415 static void
416 show_sexp (const char *prefix, gcry_sexp_t a)
417 {
418   char *buf;
419   size_t size;
420
421   fputs (prefix, stderr);
422   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
423   buf = malloc (size);
424   if (!buf)
425     die ("out of core\n");
426
427   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
428   fprintf (stderr, "%.*s", (int)size, buf);
429 }
430
431
432 static void
433 progress_cb (void *cb_data, const char *what, int printchar,
434              int current, int total)
435 {
436   (void)cb_data;
437
438   if (single_char_progress)
439     {
440       fputc (printchar, stdout);
441       fflush (stderr);
442     }
443   else
444     {
445       fprintf (stderr, PGM ": progress (%s %c %d %d)\n",
446                what, printchar, current, total);
447       fflush (stderr);
448     }
449 }
450
451
452 static void
453 random_bench (int very_strong)
454 {
455   char buf[128];
456   int i;
457
458   printf ("%-10s", "random");
459
460   if (!very_strong)
461     {
462       start_timer ();
463       for (i=0; i < 100; i++)
464         gcry_randomize (buf, sizeof buf, GCRY_STRONG_RANDOM);
465       stop_timer ();
466       printf (" %s", elapsed_time (1));
467     }
468
469   start_timer ();
470   for (i=0; i < 100; i++)
471     gcry_randomize (buf, 8,
472                     very_strong? GCRY_VERY_STRONG_RANDOM:GCRY_STRONG_RANDOM);
473   stop_timer ();
474   printf (" %s", elapsed_time (1));
475
476   putchar ('\n');
477   if (verbose)
478     gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
479 }
480
481
482
483 static void
484 md_bench ( const char *algoname )
485 {
486   int algo;
487   gcry_md_hd_t hd;
488   int i, j, repcount;
489   char buf_base[1000+15];
490   size_t bufsize = 1000;
491   char *buf;
492   char *largebuf_base;
493   char *largebuf;
494   char digest[512/8];
495   gcry_error_t err = GPG_ERR_NO_ERROR;
496
497   if (!algoname)
498     {
499       for (i=1; i < 400; i++)
500         if (in_fips_mode && i == GCRY_MD_MD5)
501           ; /* Don't use MD5 in fips mode.  */
502         else if ( !gcry_md_test_algo (i) )
503           md_bench (gcry_md_algo_name (i));
504       return;
505     }
506
507   buf = buf_base + ((16 - ((size_t)buf_base & 0x0f)) % buffer_alignment);
508
509   algo = gcry_md_map_name (algoname);
510   if (!algo)
511     {
512       fprintf (stderr, PGM ": invalid hash algorithm `%s'\n", algoname);
513       exit (1);
514     }
515
516   err = gcry_md_open (&hd, algo, 0);
517   if (err)
518     {
519       fprintf (stderr, PGM ": error opening hash algorithm `%s'\n", algoname);
520       exit (1);
521     }
522
523   for (i=0; i < bufsize; i++)
524     buf[i] = i;
525
526   printf ("%-12s", gcry_md_algo_name (algo));
527
528   start_timer ();
529   for (repcount=0; repcount < hash_repetitions; repcount++)
530     for (i=0; i < 1000; i++)
531       gcry_md_write (hd, buf, bufsize);
532   gcry_md_final (hd);
533   stop_timer ();
534   printf (" %s", elapsed_time (1));
535   fflush (stdout);
536
537   gcry_md_reset (hd);
538   start_timer ();
539   for (repcount=0; repcount < hash_repetitions; repcount++)
540     for (i=0; i < 10000; i++)
541       gcry_md_write (hd, buf, bufsize/10);
542   gcry_md_final (hd);
543   stop_timer ();
544   printf (" %s", elapsed_time (1));
545   fflush (stdout);
546
547   gcry_md_reset (hd);
548   start_timer ();
549   for (repcount=0; repcount < hash_repetitions; repcount++)
550     for (i=0; i < 1000000; i++)
551       gcry_md_write (hd, buf, 1);
552   gcry_md_final (hd);
553   stop_timer ();
554   printf (" %s", elapsed_time (1));
555   fflush (stdout);
556
557   start_timer ();
558   for (repcount=0; repcount < hash_repetitions; repcount++)
559     for (i=0; i < 1000; i++)
560       for (j=0; j < bufsize; j++)
561         gcry_md_putc (hd, buf[j]);
562   gcry_md_final (hd);
563   stop_timer ();
564   printf (" %s", elapsed_time (1));
565   fflush (stdout);
566
567   gcry_md_close (hd);
568
569   /* Now 100 hash operations on 10000 bytes using the fast function.
570      We initialize the buffer so that all memory pages are committed
571      and we have repeatable values.  */
572   if (gcry_md_get_algo_dlen (algo) > sizeof digest)
573     die ("digest buffer too short\n");
574
575   if (gcry_md_get_algo_dlen (algo))
576     {
577       largebuf_base = malloc (10000+15);
578       if (!largebuf_base)
579         die ("out of core\n");
580       largebuf = (largebuf_base
581                   + ((16 - ((size_t)largebuf_base & 0x0f)) % buffer_alignment));
582
583       for (i=0; i < 10000; i++)
584         largebuf[i] = i;
585       start_timer ();
586       for (repcount=0; repcount < hash_repetitions; repcount++)
587         for (i=0; i < 100; i++)
588           gcry_md_hash_buffer (algo, digest, largebuf, 10000);
589       stop_timer ();
590       printf (" %s", elapsed_time (1));
591       free (largebuf_base);
592     }
593
594   putchar ('\n');
595   fflush (stdout);
596 }
597
598
599
600 static void
601 mac_bench ( const char *algoname )
602 {
603   int algo;
604   gcry_mac_hd_t hd;
605   int step, pos, j, i, repcount;
606   char buf_base[1000+15];
607   size_t bufsize = 1000;
608   char *buf;
609   char mac[3][512];
610   char key[512];
611   unsigned int maclen, keylen;
612   size_t macoutlen;
613   gcry_error_t err = GPG_ERR_NO_ERROR;
614
615   if (!algoname)
616     {
617       for (i=1; i < 600; i++)
618         if (in_fips_mode && i == GCRY_MAC_HMAC_MD5)
619           ; /* Don't use MD5 in fips mode.  */
620         else if ( !gcry_mac_test_algo (i) )
621           mac_bench (gcry_mac_algo_name (i));
622       return;
623     }
624
625   buf = buf_base + ((16 - ((size_t)buf_base & 0x0f)) % buffer_alignment);
626
627   algo = gcry_mac_map_name (algoname);
628   if (!algo)
629     {
630       fprintf (stderr, PGM ": invalid hash algorithm `%s'\n", algoname);
631       exit (1);
632     }
633
634   maclen = gcry_mac_get_algo_maclen (algo);
635   if (maclen > sizeof(mac))
636     maclen = sizeof(mac);
637
638   keylen = gcry_mac_get_algo_keylen (algo);
639   if (keylen == 0)
640     keylen = 32;
641   if (keylen > sizeof(key))
642     keylen = sizeof(key);
643   for (i=0; i < keylen; i++)
644     key[i] = (keylen - i) ^ 0x54;
645
646   err = gcry_mac_open (&hd, algo, 0, NULL);
647   if (err)
648     {
649       fprintf (stderr, PGM ": error opening mac algorithm `%s': %s\n", algoname,
650                gpg_strerror (err));
651       exit (1);
652     }
653
654   err = gcry_mac_setkey (hd, key, keylen);
655   if (err)
656     {
657       fprintf (stderr, PGM ": error setting key for mac algorithm `%s': %s\n",
658                algoname, gpg_strerror (err));
659       exit (1);
660     }
661
662   for (i=0; i < bufsize; i++)
663     buf[i] = i;
664
665   if (algo >= GCRY_MAC_POLY1305_AES && algo <= GCRY_MAC_POLY1305_SEED)
666     {
667       static const char iv[16] = { 1, 2, 3, 4, };
668       err = gcry_mac_setiv(hd, iv, sizeof(iv));
669       if (err)
670         {
671           fprintf (stderr, PGM ": error setting nonce for mac algorithm `%s': %s\n",
672                    algoname, gpg_strerror (err));
673           exit (1);
674         }
675     }
676
677   printf ("%-20s", gcry_mac_algo_name (algo));
678
679   start_timer ();
680   for (repcount=0; repcount < mac_repetitions; repcount++)
681     for (i=0; i < 1000; i++)
682       gcry_mac_write (hd, buf, bufsize);
683   macoutlen = maclen;
684   gcry_mac_read (hd, mac[0], &macoutlen);
685   stop_timer ();
686   printf (" %s", elapsed_time (1));
687   fflush (stdout);
688
689   gcry_mac_reset (hd);
690   start_timer ();
691   for (repcount=0; repcount < mac_repetitions; repcount++)
692     for (i=0; i < 1000; i++)
693       for (step=bufsize/10, pos=0, j=0; j < 10; j++, pos+=step)
694         gcry_mac_write (hd, &buf[pos], step);
695   macoutlen = maclen;
696   gcry_mac_read (hd, mac[1], &macoutlen);
697   stop_timer ();
698   printf (" %s", elapsed_time (1));
699   fflush (stdout);
700
701   gcry_mac_reset (hd);
702   start_timer ();
703   for (repcount=0; repcount < mac_repetitions; repcount++)
704     for (i=0; i < 1000; i++)
705       for (step=bufsize/100, pos=0, j=0; j < 100; j++, pos+=step)
706         gcry_mac_write (hd, &buf[pos], step);
707   macoutlen = maclen;
708   gcry_mac_read (hd, mac[2], &macoutlen);
709   stop_timer ();
710   printf (" %s", elapsed_time (1));
711   fflush (stdout);
712
713   gcry_mac_close (hd);
714
715   for (i=1; i < 3; i++)
716     {
717       if (memcmp(mac[i-1], mac[i], maclen))
718         {
719           fprintf (stderr, PGM ": mac mismatch with algorithm `%s'\n",
720                    algoname);
721           exit(1);
722         }
723     }
724
725   putchar ('\n');
726   fflush (stdout);
727 }
728
729
730 static void ccm_aead_init(gcry_cipher_hd_t hd, size_t buflen, int authlen)
731 {
732   const int _L = 4;
733   const int noncelen = 15 - _L;
734   char nonce[noncelen];
735   u64 params[3];
736   gcry_error_t err = GPG_ERR_NO_ERROR;
737
738   memset (nonce, 0x33, noncelen);
739
740   err = gcry_cipher_setiv (hd, nonce, noncelen);
741   if (err)
742     {
743       fprintf (stderr, "gcry_cipher_setiv failed: %s\n",
744                gpg_strerror (err));
745       gcry_cipher_close (hd);
746       exit (1);
747     }
748
749   params[0] = buflen; /* encryptedlen */
750   params[1] = 0; /* aadlen */
751   params[2] = authlen; /* authtaglen */
752   err = gcry_cipher_ctl (hd, GCRYCTL_SET_CCM_LENGTHS, params, sizeof(params));
753   if (err)
754     {
755       fprintf (stderr, "gcry_cipher_setiv failed: %s\n",
756                gpg_strerror (err));
757       gcry_cipher_close (hd);
758       exit (1);
759     }
760 }
761
762
763 static void
764 cipher_bench ( const char *algoname )
765 {
766   static int header_printed;
767   int algo;
768   gcry_cipher_hd_t hd;
769   int i;
770   int keylen, blklen;
771   char key[128];
772   char *outbuf, *buf;
773   char *raw_outbuf, *raw_buf;
774   size_t allocated_buflen, buflen;
775   int repetitions;
776   static const struct {
777     int mode;
778     const char *name;
779     int blocked;
780     void (* const aead_init)(gcry_cipher_hd_t hd, size_t buflen, int authlen);
781     int req_blocksize;
782     int authlen;
783     int noncelen;
784   } modes[] = {
785     { GCRY_CIPHER_MODE_ECB, "   ECB/Stream", 1 },
786     { GCRY_CIPHER_MODE_CBC, "      CBC", 1 },
787     { GCRY_CIPHER_MODE_CFB, "      CFB", 0 },
788     { GCRY_CIPHER_MODE_OFB, "      OFB", 0 },
789     { GCRY_CIPHER_MODE_CTR, "      CTR", 0 },
790     { GCRY_CIPHER_MODE_CCM, "      CCM", 0,
791       ccm_aead_init, GCRY_CCM_BLOCK_LEN, 8 },
792     { GCRY_CIPHER_MODE_GCM, "      GCM", 0,
793       NULL, GCRY_GCM_BLOCK_LEN, GCRY_GCM_BLOCK_LEN },
794     { GCRY_CIPHER_MODE_OCB, "      OCB", 1,
795       NULL, 16, 16, 15 },
796     { GCRY_CIPHER_MODE_STREAM, "", 0 },
797     {0}
798   };
799   int modeidx;
800   gcry_error_t err = GPG_ERR_NO_ERROR;
801
802
803   if (!algoname)
804     {
805       for (i=1; i < 400; i++)
806         if ( !gcry_cipher_test_algo (i) )
807           cipher_bench (gcry_cipher_algo_name (i));
808       return;
809     }
810
811   if (large_buffers)
812     {
813       allocated_buflen = 1024 * 100;
814       repetitions = 10;
815     }
816   else
817     {
818       allocated_buflen = 1024;
819       repetitions = 1000;
820     }
821   repetitions *= cipher_repetitions;
822
823   raw_buf = gcry_xcalloc (allocated_buflen+15, 1);
824   buf = (raw_buf
825          + ((16 - ((size_t)raw_buf & 0x0f)) % buffer_alignment));
826   outbuf = raw_outbuf = gcry_xmalloc (allocated_buflen+15);
827   outbuf = (raw_outbuf
828             + ((16 - ((size_t)raw_outbuf & 0x0f)) % buffer_alignment));
829
830   if (!header_printed)
831     {
832       if (cipher_repetitions != 1)
833         printf ("Running each test %d times.\n", cipher_repetitions);
834       printf ("%-12s", "");
835       for (modeidx=0; modes[modeidx].mode; modeidx++)
836         if (*modes[modeidx].name)
837           printf (" %-15s", modes[modeidx].name );
838       putchar ('\n');
839       printf ("%-12s", "");
840       for (modeidx=0; modes[modeidx].mode; modeidx++)
841         if (*modes[modeidx].name)
842           printf (" ---------------" );
843       putchar ('\n');
844       header_printed = 1;
845     }
846
847   algo = gcry_cipher_map_name (algoname);
848   if (!algo)
849     {
850       fprintf (stderr, PGM ": invalid cipher algorithm `%s'\n", algoname);
851       exit (1);
852     }
853
854   keylen = gcry_cipher_get_algo_keylen (algo);
855   if (!keylen)
856     {
857       fprintf (stderr, PGM ": failed to get key length for algorithm `%s'\n",
858                algoname);
859       exit (1);
860     }
861   if ( keylen > sizeof key )
862     {
863         fprintf (stderr, PGM ": algo %d, keylength problem (%d)\n",
864                  algo, keylen );
865         exit (1);
866     }
867   for (i=0; i < keylen; i++)
868     key[i] = i + (clock () & 0xff);
869
870   blklen = gcry_cipher_get_algo_blklen (algo);
871   if (!blklen)
872     {
873       fprintf (stderr, PGM ": failed to get block length for algorithm `%s'\n",
874                algoname);
875       exit (1);
876     }
877
878   printf ("%-12s", gcry_cipher_algo_name (algo));
879   fflush (stdout);
880
881   for (modeidx=0; modes[modeidx].mode; modeidx++)
882     {
883       if ((blklen > 1 && modes[modeidx].mode == GCRY_CIPHER_MODE_STREAM)
884           || (blklen == 1 && modes[modeidx].mode != GCRY_CIPHER_MODE_STREAM))
885         continue;
886
887       if (modes[modeidx].req_blocksize > 0
888           && blklen != modes[modeidx].req_blocksize)
889         {
890           printf (" %7s %7s", "-", "-" );
891           continue;
892         }
893
894       for (i=0; i < sizeof buf; i++)
895         buf[i] = i;
896
897       err = gcry_cipher_open (&hd, algo, modes[modeidx].mode, 0);
898       if (err)
899         {
900           fprintf (stderr, PGM ": error opening cipher `%s'\n", algoname);
901           exit (1);
902         }
903
904       if (!cipher_with_keysetup)
905         {
906           err = gcry_cipher_setkey (hd, key, keylen);
907           if (err)
908             {
909               fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
910                        gpg_strerror (err));
911               gcry_cipher_close (hd);
912               exit (1);
913             }
914         }
915
916       buflen = allocated_buflen;
917       if (modes[modeidx].blocked)
918         buflen = (buflen / blklen) * blklen;
919
920       start_timer ();
921       for (i=err=0; !err && i < repetitions; i++)
922         {
923           if (cipher_with_keysetup)
924             {
925               err = gcry_cipher_setkey (hd, key, keylen);
926               if (err)
927                 {
928                   fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
929                            gpg_strerror (err));
930                   gcry_cipher_close (hd);
931                   exit (1);
932                 }
933             }
934
935           if (modes[modeidx].noncelen)
936             {
937               char nonce[100];
938               size_t noncelen;
939
940               noncelen = modes[modeidx].noncelen;
941               if (noncelen > sizeof nonce)
942                 noncelen = sizeof nonce;
943               memset (nonce, 42, noncelen);
944               err = gcry_cipher_setiv (hd, nonce, noncelen);
945               if (err)
946                 {
947                   fprintf (stderr, "gcry_cipher_setiv failed: %s\n",
948                            gpg_strerror (err));
949                   gcry_cipher_close (hd);
950                   exit (1);
951                 }
952             }
953
954           if (modes[modeidx].aead_init)
955             {
956               (*modes[modeidx].aead_init) (hd, buflen, modes[modeidx].authlen);
957               gcry_cipher_final (hd);
958               err = gcry_cipher_encrypt (hd, outbuf, buflen, buf, buflen);
959               if (err)
960                 break;
961               err = gcry_cipher_gettag (hd, outbuf, modes[modeidx].authlen);
962             }
963           else
964             {
965               err = gcry_cipher_encrypt (hd, outbuf, buflen, buf, buflen);
966             }
967         }
968       stop_timer ();
969
970       printf (" %s", elapsed_time (1));
971       fflush (stdout);
972       gcry_cipher_close (hd);
973       if (err)
974         {
975           fprintf (stderr, "gcry_cipher_encrypt failed: %s\n",
976                    gpg_strerror (err) );
977           exit (1);
978         }
979
980       err = gcry_cipher_open (&hd, algo, modes[modeidx].mode, 0);
981       if (err)
982         {
983           fprintf (stderr, PGM ": error opening cipher `%s'/n", algoname);
984           exit (1);
985         }
986
987       if (!cipher_with_keysetup)
988         {
989           err = gcry_cipher_setkey (hd, key, keylen);
990           if (err)
991             {
992               fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
993                        gpg_strerror (err));
994               gcry_cipher_close (hd);
995               exit (1);
996             }
997         }
998
999       start_timer ();
1000       for (i=err=0; !err && i < repetitions; i++)
1001         {
1002           if (cipher_with_keysetup)
1003             {
1004               err = gcry_cipher_setkey (hd, key, keylen);
1005               if (err)
1006                 {
1007                   fprintf (stderr, "gcry_cipher_setkey failed: %s\n",
1008                            gpg_strerror (err));
1009                   gcry_cipher_close (hd);
1010                   exit (1);
1011                 }
1012             }
1013
1014           if (modes[modeidx].noncelen)
1015             {
1016               char nonce[100];
1017               size_t noncelen;
1018
1019               noncelen = modes[modeidx].noncelen;
1020               if (noncelen > sizeof nonce)
1021                 noncelen = sizeof nonce;
1022               memset (nonce, 42, noncelen);
1023               err = gcry_cipher_setiv (hd, nonce, noncelen);
1024               if (err)
1025                 {
1026                   fprintf (stderr, "gcry_cipher_setiv failed: %s\n",
1027                            gpg_strerror (err));
1028                   gcry_cipher_close (hd);
1029                   exit (1);
1030                 }
1031             }
1032
1033           if (modes[modeidx].aead_init)
1034             {
1035               (*modes[modeidx].aead_init) (hd, buflen, modes[modeidx].authlen);
1036               gcry_cipher_final (hd);
1037               err = gcry_cipher_decrypt (hd, outbuf, buflen, buf, buflen);
1038               if (err)
1039                 break;
1040               err = gcry_cipher_checktag (hd, outbuf, modes[modeidx].authlen);
1041               if (gpg_err_code (err) == GPG_ERR_CHECKSUM)
1042                 err = 0;
1043             }
1044           else
1045             {
1046               gcry_cipher_final (hd);
1047               err = gcry_cipher_decrypt (hd, outbuf, buflen, buf, buflen);
1048             }
1049         }
1050       stop_timer ();
1051       printf (" %s", elapsed_time (1));
1052       fflush (stdout);
1053       gcry_cipher_close (hd);
1054       if (err)
1055         {
1056           fprintf (stderr, "gcry_cipher_decrypt failed: %s\n",
1057                    gpg_strerror (err) );
1058           exit (1);
1059         }
1060     }
1061
1062   putchar ('\n');
1063   gcry_free (raw_buf);
1064   gcry_free (raw_outbuf);
1065 }
1066
1067
1068
1069 static void
1070 rsa_bench (int iterations, int print_header, int no_blinding)
1071 {
1072   gpg_error_t err;
1073   int p_sizes[] = { 1024, 2048, 3072, 4096 };
1074   int testno;
1075
1076   if (print_header)
1077     printf ("Algorithm         generate %4d*priv %4d*public\n"
1078             "------------------------------------------------\n",
1079             iterations, iterations );
1080   for (testno=0; testno < DIM (p_sizes); testno++)
1081     {
1082       gcry_sexp_t key_spec, key_pair, pub_key, sec_key;
1083       gcry_mpi_t x;
1084       gcry_sexp_t data;
1085       gcry_sexp_t sig = NULL;
1086       int count;
1087       unsigned nbits = p_sizes[testno];
1088
1089       printf ("RSA %3d bit    ", nbits);
1090       fflush (stdout);
1091
1092       if (in_fips_mode && !(nbits == 2048 || nbits == 3072))
1093         {
1094           puts ("[skipped in fips mode]");
1095           continue;
1096         }
1097
1098       err = gcry_sexp_build (&key_spec, NULL,
1099                              gcry_fips_mode_active ()
1100                              ? "(genkey (RSA (nbits %d)))"
1101                              : "(genkey (RSA (nbits %d)(transient-key)))",
1102                              nbits);
1103       if (err)
1104         die ("creating S-expression failed: %s\n", gcry_strerror (err));
1105
1106       start_timer ();
1107       err = gcry_pk_genkey (&key_pair, key_spec);
1108       if (err)
1109         die ("creating %d bit RSA key failed: %s\n",
1110              nbits, gcry_strerror (err));
1111
1112       pub_key = gcry_sexp_find_token (key_pair, "public-key", 0);
1113       if (! pub_key)
1114         die ("public part missing in key\n");
1115       sec_key = gcry_sexp_find_token (key_pair, "private-key", 0);
1116       if (! sec_key)
1117         die ("private part missing in key\n");
1118       gcry_sexp_release (key_pair);
1119       gcry_sexp_release (key_spec);
1120
1121       stop_timer ();
1122       printf ("   %s", elapsed_time (1));
1123       fflush (stdout);
1124
1125       x = gcry_mpi_new (nbits);
1126       gcry_mpi_randomize (x, nbits-8, GCRY_WEAK_RANDOM);
1127       err = gcry_sexp_build (&data, NULL,
1128                              "(data (flags raw) (value %m))", x);
1129       gcry_mpi_release (x);
1130       if (err)
1131         die ("converting data failed: %s\n", gcry_strerror (err));
1132
1133       start_timer ();
1134       for (count=0; count < iterations; count++)
1135         {
1136           gcry_sexp_release (sig);
1137           err = gcry_pk_sign (&sig, data, sec_key);
1138           if (err)
1139             die ("signing failed (%d): %s\n", count, gpg_strerror (err));
1140         }
1141       stop_timer ();
1142       printf ("   %s", elapsed_time (1));
1143       fflush (stdout);
1144
1145       start_timer ();
1146       for (count=0; count < iterations; count++)
1147         {
1148           err = gcry_pk_verify (sig, data, pub_key);
1149           if (err)
1150             {
1151               putchar ('\n');
1152               show_sexp ("seckey:\n", sec_key);
1153               show_sexp ("data:\n", data);
1154               show_sexp ("sig:\n", sig);
1155               die ("verify failed (%d): %s\n", count, gpg_strerror (err));
1156             }
1157         }
1158       stop_timer ();
1159       printf ("     %s", elapsed_time (1));
1160
1161       if (no_blinding)
1162         {
1163           fflush (stdout);
1164           x = gcry_mpi_new (nbits);
1165           gcry_mpi_randomize (x, nbits-8, GCRY_WEAK_RANDOM);
1166           err = gcry_sexp_build (&data, NULL,
1167                                  "(data (flags no-blinding) (value %m))", x);
1168           gcry_mpi_release (x);
1169           if (err)
1170             die ("converting data failed: %s\n", gcry_strerror (err));
1171
1172           start_timer ();
1173           for (count=0; count < iterations; count++)
1174             {
1175               gcry_sexp_release (sig);
1176               err = gcry_pk_sign (&sig, data, sec_key);
1177               if (err)
1178                 die ("signing failed (%d): %s\n", count, gpg_strerror (err));
1179             }
1180           stop_timer ();
1181           printf ("   %s", elapsed_time (1));
1182           fflush (stdout);
1183         }
1184
1185       putchar ('\n');
1186       fflush (stdout);
1187
1188       gcry_sexp_release (sig);
1189       gcry_sexp_release (data);
1190       gcry_sexp_release (sec_key);
1191       gcry_sexp_release (pub_key);
1192     }
1193 }
1194
1195
1196 static void
1197 elg_bench (int iterations, int print_header)
1198 {
1199   gpg_error_t err;
1200   gcry_sexp_t pub_key[3], sec_key[3];
1201   int p_sizes[3] = { 1024, 2048, 3072 };
1202   gcry_sexp_t data = NULL;
1203   gcry_sexp_t enc = NULL;
1204   gcry_sexp_t plain = NULL;
1205   int i, j;
1206
1207   err = gcry_sexp_sscan (pub_key+0, NULL, sample_public_elg_key_1024,
1208                          strlen (sample_public_elg_key_1024));
1209   if (!err)
1210     err = gcry_sexp_sscan (sec_key+0, NULL, sample_private_elg_key_1024,
1211                            strlen (sample_private_elg_key_1024));
1212   if (!err)
1213     err = gcry_sexp_sscan (pub_key+1, NULL, sample_public_elg_key_2048,
1214                            strlen (sample_public_elg_key_2048));
1215   if (!err)
1216     err = gcry_sexp_sscan (sec_key+1, NULL, sample_private_elg_key_2048,
1217                            strlen (sample_private_elg_key_2048));
1218   if (!err)
1219     err = gcry_sexp_sscan (pub_key+2, NULL, sample_public_elg_key_3072,
1220                            strlen (sample_public_elg_key_3072));
1221   if (!err)
1222     err = gcry_sexp_sscan (sec_key+2, NULL, sample_private_elg_key_3072,
1223                            strlen (sample_private_elg_key_3072));
1224   if (err)
1225     {
1226       fprintf (stderr, PGM ": converting sample keys failed: %s\n",
1227                gcry_strerror (err));
1228       exit (1);
1229     }
1230
1231   if (print_header)
1232     printf ("Algorithm         generate %4d*priv %4d*public\n"
1233             "------------------------------------------------\n",
1234             iterations, iterations );
1235   for (i=0; i < DIM (p_sizes); i++)
1236     {
1237       char timerbuf1[100];
1238
1239       {
1240         gcry_mpi_t x = gcry_mpi_new (p_sizes[i]);
1241         gcry_mpi_randomize (x, p_sizes[i] - 16, GCRY_WEAK_RANDOM);
1242         err = gcry_sexp_build (&data, NULL, "(data (flags raw) (value %m))", x);
1243         gcry_mpi_release (x);
1244       }
1245       if (err)
1246         {
1247           fprintf (stderr, PGM ": converting data failed: %s\n",
1248                    gcry_strerror (err));
1249           exit (1);
1250         }
1251
1252       printf ("ELG %d bit             -", p_sizes[i]);
1253       fflush (stdout);
1254
1255       start_timer ();
1256       for (j=0; j < iterations; j++)
1257         {
1258           gcry_sexp_release (enc);
1259           err = gcry_pk_encrypt (&enc, data, pub_key[i]);
1260           if (err)
1261             {
1262               putchar ('\n');
1263               fprintf (stderr, PGM ": encrypt failed: %s\n",
1264                        gpg_strerror (err));
1265               exit (1);
1266             }
1267         }
1268       stop_timer ();
1269       snprintf (timerbuf1, sizeof timerbuf1, "   %s", elapsed_time (1));
1270       fflush (stdout);
1271
1272       start_timer ();
1273       for (j=0; j < iterations; j++)
1274         {
1275           gcry_sexp_release (plain);
1276           err = gcry_pk_decrypt (&plain, enc, sec_key[i]);
1277           if (err)
1278             {
1279               putchar ('\n');
1280               fprintf (stderr, PGM ": decrypt failed: %s\n",
1281                        gpg_strerror (err));
1282               exit (1);
1283             }
1284         }
1285       stop_timer ();
1286
1287       printf ("   %s  %s\n", elapsed_time (1), timerbuf1);
1288       fflush (stdout);
1289
1290       gcry_sexp_release (plain);
1291       plain = NULL;
1292       gcry_sexp_release (enc);
1293       enc = NULL;
1294       gcry_sexp_release (data);
1295       data = NULL;
1296     }
1297
1298   for (i=0; i < DIM (p_sizes); i++)
1299     {
1300       gcry_sexp_release (sec_key[i]);
1301       gcry_sexp_release (pub_key[i]);
1302     }
1303 }
1304
1305
1306 static void
1307 dsa_bench (int iterations, int print_header)
1308 {
1309   gpg_error_t err;
1310   gcry_sexp_t pub_key[3], sec_key[3];
1311   int p_sizes[3] = { 1024, 2048, 3072 };
1312   int q_sizes[3] = { 160, 224, 256 };
1313   gcry_sexp_t data;
1314   gcry_sexp_t sig = NULL;
1315   int i, j;
1316
1317   err = gcry_sexp_sscan (pub_key+0, NULL, sample_public_dsa_key_1024,
1318                          strlen (sample_public_dsa_key_1024));
1319   if (!err)
1320     err = gcry_sexp_sscan (sec_key+0, NULL, sample_private_dsa_key_1024,
1321                            strlen (sample_private_dsa_key_1024));
1322   if (!err)
1323     err = gcry_sexp_sscan (pub_key+1, NULL, sample_public_dsa_key_2048,
1324                            strlen (sample_public_dsa_key_2048));
1325   if (!err)
1326     err = gcry_sexp_sscan (sec_key+1, NULL, sample_private_dsa_key_2048,
1327                            strlen (sample_private_dsa_key_2048));
1328   if (!err)
1329     err = gcry_sexp_sscan (pub_key+2, NULL, sample_public_dsa_key_3072,
1330                            strlen (sample_public_dsa_key_3072));
1331   if (!err)
1332     err = gcry_sexp_sscan (sec_key+2, NULL, sample_private_dsa_key_3072,
1333                            strlen (sample_private_dsa_key_3072));
1334   if (err)
1335     {
1336       fprintf (stderr, PGM ": converting sample keys failed: %s\n",
1337                gcry_strerror (err));
1338       exit (1);
1339     }
1340
1341   if (print_header)
1342     printf ("Algorithm         generate %4d*priv %4d*public\n"
1343             "------------------------------------------------\n",
1344             iterations, iterations );
1345   for (i=0; i < DIM (q_sizes); i++)
1346     {
1347       gcry_mpi_t x;
1348
1349       x = gcry_mpi_new (q_sizes[i]);
1350       gcry_mpi_randomize (x, q_sizes[i], GCRY_WEAK_RANDOM);
1351       err = gcry_sexp_build (&data, NULL, "(data (flags raw) (value %m))", x);
1352       gcry_mpi_release (x);
1353       if (err)
1354         {
1355           fprintf (stderr, PGM ": converting data failed: %s\n",
1356                    gcry_strerror (err));
1357           exit (1);
1358         }
1359
1360       printf ("DSA %d/%d             -", p_sizes[i], q_sizes[i]);
1361       fflush (stdout);
1362
1363       start_timer ();
1364       for (j=0; j < iterations; j++)
1365         {
1366           gcry_sexp_release (sig);
1367           err = gcry_pk_sign (&sig, data, sec_key[i]);
1368           if (err)
1369             {
1370               putchar ('\n');
1371               fprintf (stderr, PGM ": signing failed: %s\n",
1372                        gpg_strerror (err));
1373               exit (1);
1374             }
1375         }
1376       stop_timer ();
1377       printf ("   %s", elapsed_time (1));
1378       fflush (stdout);
1379
1380       start_timer ();
1381       for (j=0; j < iterations; j++)
1382         {
1383           err = gcry_pk_verify (sig, data, pub_key[i]);
1384           if (err)
1385             {
1386               putchar ('\n');
1387               fprintf (stderr, PGM ": verify failed: %s\n",
1388                        gpg_strerror (err));
1389               exit (1);
1390             }
1391         }
1392       stop_timer ();
1393       printf ("     %s\n", elapsed_time (1));
1394       fflush (stdout);
1395
1396       gcry_sexp_release (sig);
1397       gcry_sexp_release (data);
1398       sig = NULL;
1399     }
1400
1401
1402   for (i=0; i < DIM (q_sizes); i++)
1403     {
1404       gcry_sexp_release (sec_key[i]);
1405       gcry_sexp_release (pub_key[i]);
1406     }
1407 }
1408
1409
1410 static void
1411 ecc_bench (int iterations, int print_header)
1412 {
1413 #if USE_ECC
1414   gpg_error_t err;
1415   const char *p_sizes[] = { "192", "224", "256", "384", "521", "Ed25519",
1416               "gost256", "gost512" };
1417   int testno;
1418
1419   if (print_header)
1420     printf ("Algorithm         generate %4d*priv %4d*public\n"
1421             "------------------------------------------------\n",
1422             iterations, iterations );
1423   for (testno=0; testno < DIM (p_sizes); testno++)
1424     {
1425       gcry_sexp_t key_spec, key_pair, pub_key, sec_key;
1426       gcry_mpi_t x;
1427       gcry_sexp_t data;
1428       gcry_sexp_t sig = NULL;
1429       int count;
1430       int p_size;
1431       int is_ed25519;
1432       int is_gost;
1433
1434       is_ed25519 = !strcmp (p_sizes[testno], "Ed25519");
1435       is_gost = !strncmp (p_sizes[testno], "gost", 4);
1436
1437       /* Only P-{224,256,384,521} are allowed in fips mode */
1438       if (gcry_fips_mode_active()
1439           && (is_ed25519 || is_gost || !strcmp (p_sizes[testno], "192")))
1440          continue;
1441
1442       if (is_ed25519)
1443         {
1444           p_size = 256;
1445           printf ("EdDSA Ed25519 ");
1446           fflush (stdout);
1447         }
1448       else if (is_gost)
1449         {
1450           p_size = atoi (p_sizes[testno] + 4);
1451           printf ("GOST  %3d bit ", p_size);
1452           fflush (stdout);
1453         }
1454       else
1455         {
1456           p_size = atoi (p_sizes[testno]);
1457           printf ("ECDSA %3d bit ", p_size);
1458         }
1459       fflush (stdout);
1460
1461       if (is_ed25519)
1462         err = gcry_sexp_build (&key_spec, NULL,
1463                                "(genkey (ecdsa (curve \"Ed25519\")"
1464                                "(flags eddsa)))");
1465       else if (is_gost)
1466         err = gcry_sexp_build (&key_spec, NULL,
1467                                "(genkey (ecdsa (curve %s)))",
1468                                p_size == 256 ? "GOST2001-test" : "GOST2012-test");
1469       else
1470         err = gcry_sexp_build (&key_spec, NULL,
1471                                "(genkey (ECDSA (nbits %d)))", p_size);
1472       if (err)
1473         die ("creating S-expression failed: %s\n", gcry_strerror (err));
1474
1475       start_timer ();
1476       err = gcry_pk_genkey (&key_pair, key_spec);
1477       if (err)
1478         die ("creating %d bit ECC key failed: %s\n",
1479              p_size, gcry_strerror (err));
1480       if (verbose > 2)
1481         show_sexp ("ECC key:\n", key_pair);
1482
1483       pub_key = gcry_sexp_find_token (key_pair, "public-key", 0);
1484       if (! pub_key)
1485         die ("public part missing in key\n");
1486       sec_key = gcry_sexp_find_token (key_pair, "private-key", 0);
1487       if (! sec_key)
1488         die ("private part missing in key\n");
1489       gcry_sexp_release (key_pair);
1490       gcry_sexp_release (key_spec);
1491
1492       stop_timer ();
1493       printf ("     %s", elapsed_time (1));
1494       fflush (stdout);
1495
1496       x = gcry_mpi_new (p_size);
1497       gcry_mpi_randomize (x, p_size, GCRY_WEAK_RANDOM);
1498       if (is_ed25519)
1499         err = gcry_sexp_build (&data, NULL,
1500                                "(data (flags eddsa)(hash-algo sha512)"
1501                                " (value %m))", x);
1502       else if (is_gost)
1503         err = gcry_sexp_build (&data, NULL, "(data (flags gost) (value %m))", x);
1504       else
1505         err = gcry_sexp_build (&data, NULL, "(data (flags raw) (value %m))", x);
1506       gcry_mpi_release (x);
1507
1508       if (err)
1509         die ("converting data failed: %s\n", gcry_strerror (err));
1510
1511       start_timer ();
1512       for (count=0; count < iterations; count++)
1513         {
1514           gcry_sexp_release (sig);
1515           err = gcry_pk_sign (&sig, data, sec_key);
1516           if (err)
1517             {
1518               if (verbose)
1519                 {
1520                   putc ('\n', stderr);
1521                   show_sexp ("signing key:\n", sec_key);
1522                   show_sexp ("signed data:\n", data);
1523                 }
1524               die ("signing failed: %s\n", gpg_strerror (err));
1525             }
1526         }
1527       stop_timer ();
1528       printf ("   %s", elapsed_time (1));
1529       fflush (stdout);
1530
1531       start_timer ();
1532       for (count=0; count < iterations; count++)
1533         {
1534           err = gcry_pk_verify (sig, data, pub_key);
1535           if (err)
1536             {
1537               putchar ('\n');
1538               show_sexp ("seckey:\n", sec_key);
1539               show_sexp ("data:\n", data);
1540               show_sexp ("sig:\n", sig);
1541               die ("verify failed: %s\n", gpg_strerror (err));
1542             }
1543         }
1544       stop_timer ();
1545       printf ("     %s\n", elapsed_time (1));
1546       fflush (stdout);
1547
1548       gcry_sexp_release (sig);
1549       gcry_sexp_release (data);
1550       gcry_sexp_release (sec_key);
1551       gcry_sexp_release (pub_key);
1552     }
1553 #endif /*USE_ECC*/
1554 }
1555
1556
1557
1558 static void
1559 do_powm ( const char *n_str, const char *e_str, const char *m_str)
1560 {
1561   gcry_mpi_t e, n, msg, cip;
1562   gcry_error_t err;
1563   int i;
1564
1565   err = gcry_mpi_scan (&n, GCRYMPI_FMT_HEX, n_str, 0, 0);
1566   if (err) BUG ();
1567   err = gcry_mpi_scan (&e, GCRYMPI_FMT_HEX, e_str, 0, 0);
1568   if (err) BUG ();
1569   err = gcry_mpi_scan (&msg, GCRYMPI_FMT_HEX, m_str, 0, 0);
1570   if (err) BUG ();
1571
1572   cip = gcry_mpi_new (0);
1573
1574   start_timer ();
1575   for (i=0; i < 1000; i++)
1576     gcry_mpi_powm (cip, msg, e, n);
1577   stop_timer ();
1578   printf (" %s", elapsed_time (1)); fflush (stdout);
1579 /*    { */
1580 /*      char *buf; */
1581
1582 /*      if (gcry_mpi_aprint (GCRYMPI_FMT_HEX, (void**)&buf, NULL, cip)) */
1583 /*        BUG (); */
1584 /*      printf ("result: %s\n", buf); */
1585 /*      gcry_free (buf); */
1586 /*    } */
1587   gcry_mpi_release (cip);
1588   gcry_mpi_release (msg);
1589   gcry_mpi_release (n);
1590   gcry_mpi_release (e);
1591 }
1592
1593
1594 static void
1595 mpi_bench (void)
1596 {
1597   printf ("%-10s", "powm"); fflush (stdout);
1598
1599   do_powm (
1600 "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E4",
1601            "29",
1602 "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8"
1603            );
1604   do_powm (
1605            "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA40716",
1606            "29",
1607            "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847"
1608            );
1609   do_powm (
1610            "20A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA4071620A94417D4D5EF2B2DA99165C7DC87DADB3979B72961AF90D09D59BA24CB9A10166FDCCC9C659F2B9626EC23F3FA425F564A072BA941B03FA81767CC289E41071F0246879A442658FBD18C1771571E7073EEEB2160BA0CBFB3404D627069A6CFBD53867AD2D9D40231648000787B5C84176B4336144644AE71A403CA40716",
1611            "29",
1612            "B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847B870187A323F1ECD5B8A0B4249507335A1C4CE8394F38FD76B08C78A42C58F6EA136ACF90DFE8603697B1694A3D81114D6117AC1811979C51C4DD013D52F8FC4EE4BB446B83E48ABED7DB81CBF5E81DE4759E8D68AC985846D999F96B0D8A80E5C69D272C766AB8A23B40D50A4FA889FBC2BD2624222D8EB297F4BAEF8593847"
1613            );
1614
1615   putchar ('\n');
1616
1617
1618 }
1619
1620
1621 static void
1622 prime_bench (void)
1623 {
1624   gpg_error_t err;
1625   int i;
1626   gcry_mpi_t prime;
1627   int old_prog = single_char_progress;
1628
1629   single_char_progress = 1;
1630   if (!with_progress)
1631     printf ("%-10s", "prime");
1632   fflush (stdout);
1633   start_timer ();
1634   for (i=0; i < 10; i++)
1635     {
1636       if (with_progress)
1637         fputs ("primegen ", stdout);
1638       err = gcry_prime_generate (&prime,
1639                                  1024, 0,
1640                                  NULL,
1641                                  NULL, NULL,
1642                                  GCRY_WEAK_RANDOM,
1643                                  GCRY_PRIME_FLAG_SECRET);
1644       if (with_progress)
1645         {
1646           fputc ('\n', stdout);
1647           fflush (stdout);
1648         }
1649       if (err)
1650         {
1651           fprintf (stderr, PGM ": error creating prime: %s\n",
1652                    gpg_strerror (err));
1653           exit (1);
1654         }
1655       gcry_mpi_release (prime);
1656     }
1657   stop_timer ();
1658   if (with_progress)
1659     printf ("%-10s", "prime");
1660   printf (" %s\n", elapsed_time (1)); fflush (stdout);
1661
1662   single_char_progress = old_prog;
1663 }
1664
1665
1666 int
1667 main( int argc, char **argv )
1668 {
1669   int last_argc = -1;
1670   int no_blinding = 0;
1671   int use_random_daemon = 0;
1672   int use_secmem = 0;
1673   int debug = 0;
1674   int pk_count = 100;
1675
1676   buffer_alignment = 1;
1677
1678   if (argc)
1679     { argc--; argv++; }
1680
1681   /* We skip this test if we are running under the test suite (no args
1682      and srcdir defined) and GCRYPT_NO_BENCHMARKS is set.  */
1683   if (!argc && getenv ("srcdir") && getenv ("GCRYPT_NO_BENCHMARKS"))
1684     exit (77);
1685
1686   if (getenv ("GCRYPT_IN_REGRESSION_TEST"))
1687     {
1688       in_regression_test = 1;
1689       pk_count = 10;
1690     }
1691
1692   while (argc && last_argc != argc )
1693     {
1694       last_argc = argc;
1695       if (!strcmp (*argv, "--"))
1696         {
1697           argc--; argv++;
1698           break;
1699         }
1700       else if (!strcmp (*argv, "--help"))
1701         {
1702           fputs ("usage: benchmark "
1703                  "[md|mac|cipher|random|mpi|rsa|dsa|ecc|prime [algonames]]\n",
1704                  stdout);
1705           exit (0);
1706         }
1707       else if (!strcmp (*argv, "--verbose"))
1708         {
1709           verbose++;
1710           argc--; argv++;
1711         }
1712       else if (!strcmp (*argv, "--debug"))
1713         {
1714           verbose += 2;
1715           debug++;
1716           argc--; argv++;
1717         }
1718       else if (!strcmp (*argv, "--use-random-daemon"))
1719         {
1720           use_random_daemon = 1;
1721           argc--; argv++;
1722         }
1723       else if (!strcmp (*argv, "--use-secmem"))
1724         {
1725           use_secmem = 1;
1726           argc--; argv++;
1727         }
1728       else if (!strcmp (*argv, "--prefer-standard-rng"))
1729         {
1730           /* This is anyway the default, but we may want to use it for
1731              debugging. */
1732           gcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_STANDARD);
1733           argc--; argv++;
1734         }
1735       else if (!strcmp (*argv, "--prefer-fips-rng"))
1736         {
1737           gcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_FIPS);
1738           argc--; argv++;
1739         }
1740       else if (!strcmp (*argv, "--prefer-system-rng"))
1741         {
1742           gcry_control (GCRYCTL_SET_PREFERRED_RNG_TYPE, GCRY_RNG_TYPE_SYSTEM);
1743           argc--; argv++;
1744         }
1745       else if (!strcmp (*argv, "--no-blinding"))
1746         {
1747           no_blinding = 1;
1748           argc--; argv++;
1749         }
1750       else if (!strcmp (*argv, "--large-buffers"))
1751         {
1752           large_buffers = 1;
1753           argc--; argv++;
1754         }
1755       else if (!strcmp (*argv, "--cipher-repetitions"))
1756         {
1757           argc--; argv++;
1758           if (argc)
1759             {
1760               cipher_repetitions = atoi(*argv);
1761               argc--; argv++;
1762             }
1763         }
1764       else if (!strcmp (*argv, "--cipher-with-keysetup"))
1765         {
1766           cipher_with_keysetup = 1;
1767           argc--; argv++;
1768         }
1769       else if (!strcmp (*argv, "--hash-repetitions"))
1770         {
1771           argc--; argv++;
1772           if (argc)
1773             {
1774               hash_repetitions = atoi(*argv);
1775               argc--; argv++;
1776             }
1777         }
1778       else if (!strcmp (*argv, "--mac-repetitions"))
1779         {
1780           argc--; argv++;
1781           if (argc)
1782             {
1783               mac_repetitions = atoi(*argv);
1784               argc--; argv++;
1785             }
1786         }
1787       else if (!strcmp (*argv, "--pk-count"))
1788         {
1789           argc--; argv++;
1790           if (argc)
1791             {
1792               pk_count = atoi(*argv);
1793               argc--; argv++;
1794             }
1795         }
1796       else if (!strcmp (*argv, "--alignment"))
1797         {
1798           argc--; argv++;
1799           if (argc)
1800             {
1801               buffer_alignment = atoi(*argv);
1802               argc--; argv++;
1803             }
1804         }
1805       else if (!strcmp (*argv, "--disable-hwf"))
1806         {
1807           argc--; argv++;
1808           if (argc)
1809             {
1810               if (gcry_control (GCRYCTL_DISABLE_HWF, *argv, NULL))
1811                 fprintf (stderr, PGM ": unknown hardware feature `%s'"
1812                          " - option ignored\n", *argv);
1813               argc--; argv++;
1814             }
1815         }
1816       else if (!strcmp (*argv, "--fips"))
1817         {
1818           argc--; argv++;
1819           /* This command needs to be called before gcry_check_version.  */
1820           gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
1821         }
1822       else if (!strcmp (*argv, "--progress"))
1823         {
1824           argc--; argv++;
1825           with_progress = 1;
1826         }
1827     }
1828
1829   if (buffer_alignment < 1 || buffer_alignment > 16)
1830     die ("value for --alignment must be in the range 1 to 16\n");
1831
1832   gcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
1833
1834   if (!gcry_check_version (GCRYPT_VERSION))
1835     {
1836       fprintf (stderr, PGM ": version mismatch; pgm=%s, library=%s\n",
1837                GCRYPT_VERSION, gcry_check_version (NULL));
1838       exit (1);
1839     }
1840
1841   if (debug)
1842     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
1843
1844   if (gcry_fips_mode_active ())
1845     in_fips_mode = 1;
1846   else if (!use_secmem)
1847     gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
1848
1849   if (use_random_daemon)
1850     gcry_control (GCRYCTL_USE_RANDOM_DAEMON, 1);
1851
1852   if (with_progress)
1853     gcry_set_progress_handler (progress_cb, NULL);
1854
1855   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
1856
1857   if (cipher_repetitions < 1)
1858     cipher_repetitions = 1;
1859   if (hash_repetitions < 1)
1860     hash_repetitions = 1;
1861   if (mac_repetitions < 1)
1862     mac_repetitions = 1;
1863
1864   if (in_regression_test)
1865     fputs ("Note: " PGM " running in quick regression test mode.\n", stdout);
1866
1867   if ( !argc )
1868     {
1869       gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1870       md_bench (NULL);
1871       putchar ('\n');
1872       mac_bench (NULL);
1873       putchar ('\n');
1874       cipher_bench (NULL);
1875       putchar ('\n');
1876       rsa_bench (pk_count, 1, no_blinding);
1877       elg_bench (pk_count, 0);
1878       dsa_bench (pk_count, 0);
1879       ecc_bench (pk_count, 0);
1880       putchar ('\n');
1881       mpi_bench ();
1882       putchar ('\n');
1883       random_bench (0);
1884     }
1885   else if ( !strcmp (*argv, "random") || !strcmp (*argv, "strongrandom"))
1886     {
1887       if (argc == 1)
1888         random_bench ((**argv == 's'));
1889       else if (argc == 2)
1890         {
1891           gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, argv[1]);
1892           random_bench ((**argv == 's'));
1893           gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1894         }
1895       else
1896         fputs ("usage: benchmark [strong]random [seedfile]\n", stdout);
1897     }
1898   else if ( !strcmp (*argv, "md"))
1899     {
1900       if (argc == 1)
1901         md_bench (NULL);
1902       else
1903         for (argc--, argv++; argc; argc--, argv++)
1904           md_bench ( *argv );
1905     }
1906   else if ( !strcmp (*argv, "mac"))
1907     {
1908       if (argc == 1)
1909         mac_bench (NULL);
1910       else
1911         for (argc--, argv++; argc; argc--, argv++)
1912           mac_bench ( *argv );
1913     }
1914   else if ( !strcmp (*argv, "cipher"))
1915     {
1916       if (argc == 1)
1917         cipher_bench (NULL);
1918       else
1919         for (argc--, argv++; argc; argc--, argv++)
1920           cipher_bench ( *argv );
1921     }
1922   else if ( !strcmp (*argv, "mpi"))
1923     {
1924         mpi_bench ();
1925     }
1926   else if ( !strcmp (*argv, "pubkey"))
1927     {
1928         gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1929         rsa_bench (pk_count, 1, no_blinding);
1930         elg_bench (pk_count, 0);
1931         dsa_bench (pk_count, 0);
1932         ecc_bench (pk_count, 0);
1933     }
1934   else if ( !strcmp (*argv, "rsa"))
1935     {
1936         gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1937         rsa_bench (pk_count, 1, no_blinding);
1938     }
1939   else if ( !strcmp (*argv, "elg"))
1940     {
1941         gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1942         elg_bench (pk_count, 1);
1943     }
1944   else if ( !strcmp (*argv, "dsa"))
1945     {
1946         gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1947         dsa_bench (pk_count, 1);
1948     }
1949   else if ( !strcmp (*argv, "ecc"))
1950     {
1951         gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1952         ecc_bench (pk_count, 1);
1953     }
1954   else if ( !strcmp (*argv, "prime"))
1955     {
1956         gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1957         prime_bench ();
1958     }
1959   else
1960     {
1961       fprintf (stderr, PGM ": bad arguments\n");
1962       return 1;
1963     }
1964
1965
1966   if (in_fips_mode && !gcry_fips_mode_active ())
1967     fprintf (stderr, PGM ": FIPS mode is not anymore active\n");
1968
1969   return 0;
1970 }