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