attempt fix #5578
[oweals/gnunet.git] / src / util / test_crypto_ecdsa.c
1 /*
2      This file is part of GNUnet.
3      Copyright (C) 2002-2013 GNUnet e.V.
4
5      GNUnet is free software: you can redistribute it and/or modify it
6      under the terms of the GNU Affero General Public License as published
7      by the Free Software Foundation, either version 3 of the License,
8      or (at your option) any later version.
9
10      GNUnet is distributed in the hope that it will be useful, but
11      WITHOUT ANY WARRANTY; without even the implied warranty of
12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13      Affero General Public License for more details.
14     
15      You should have received a copy of the GNU Affero General Public License
16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
18      SPDX-License-Identifier: AGPL3.0-or-later
19
20 */
21 /**
22  * @file util/test_crypto_ecdsa.c
23  * @brief testcase for ECC ECDSA public key crypto
24  * @author Christian Grothoff
25  */
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "gnunet_signatures.h"
29 #include <gcrypt.h>
30
31 #define ITER 25
32
33 #define PERF GNUNET_YES
34
35
36 static struct GNUNET_CRYPTO_EcdsaPrivateKey *key;
37
38
39 static int
40 testSignVerify ()
41 {
42   struct GNUNET_CRYPTO_EcdsaSignature sig;
43   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
44   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
45   int i;
46   struct GNUNET_TIME_Absolute start;
47   int ok = GNUNET_OK;
48
49   FPRINTF (stderr, "%s",  "W");
50   GNUNET_CRYPTO_ecdsa_key_get_public (key, &pkey);
51   start = GNUNET_TIME_absolute_get ();
52   purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
53   purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
54
55   for (i = 0; i < ITER; i++)
56   {
57     FPRINTF (stderr, "%s",  "."); fflush (stderr);
58     if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_sign (key, &purp, &sig))
59     {
60       FPRINTF (stderr,
61                "%s",
62                "GNUNET_CRYPTO_ecdsa_sign returned SYSERR\n");
63       ok = GNUNET_SYSERR;
64       continue;
65     }
66     if (GNUNET_SYSERR ==
67         GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST, &purp, &sig,
68                                     &pkey))
69     {
70       printf ("GNUNET_CRYPTO_ecdsa_verify failed!\n");
71       ok = GNUNET_SYSERR;
72       continue;
73     }
74     if (GNUNET_SYSERR !=
75         GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
76                                     &purp, &sig, &pkey))
77     {
78       printf ("GNUNET_CRYPTO_ecdsa_verify failed to fail!\n");
79       ok = GNUNET_SYSERR;
80       continue;
81     }
82   }
83   printf ("%d ECDSA sign/verify operations %s\n", ITER,
84           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start), GNUNET_YES));
85   return ok;
86 }
87
88
89 static int
90 testDeriveSignVerify ()
91 {
92   struct GNUNET_CRYPTO_EcdsaSignature sig;
93   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
94   struct GNUNET_CRYPTO_EcdsaPrivateKey *dpriv;
95   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
96   struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
97
98   dpriv = GNUNET_CRYPTO_ecdsa_private_key_derive (key, "test-derive", "test-CTX");
99   GNUNET_CRYPTO_ecdsa_key_get_public (key, &pkey);
100   GNUNET_CRYPTO_ecdsa_public_key_derive (&pkey, "test-derive", "test-CTX", &dpub);
101   purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
102   purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
103
104   if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_sign (dpriv, &purp, &sig))
105   {
106     FPRINTF (stderr, "%s",  "GNUNET_CRYPTO_ecdsa_sign returned SYSERR\n");
107     GNUNET_free (dpriv);
108     return GNUNET_SYSERR;
109   }
110   if (GNUNET_SYSERR ==
111       GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
112                                   &purp, &sig,
113                                   &dpub))
114   {
115     printf ("GNUNET_CRYPTO_ecdsa_verify failed!\n");
116     GNUNET_free (dpriv);
117     return GNUNET_SYSERR;
118   }
119   if (GNUNET_SYSERR !=
120       GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
121                                   &purp, &sig,
122                                   &pkey))
123   {
124     printf ("GNUNET_CRYPTO_ecdsa_verify failed to fail!\n");
125     GNUNET_free (dpriv);
126     return GNUNET_SYSERR;
127   }
128   if (GNUNET_SYSERR !=
129       GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
130                                   &purp, &sig, &dpub))
131   {
132     printf ("GNUNET_CRYPTO_ecdsa_verify failed to fail!\n");
133     GNUNET_free (dpriv);
134     return GNUNET_SYSERR;
135   }
136   GNUNET_free (dpriv);
137   return GNUNET_OK;
138 }
139
140
141 #if PERF
142 static int
143 testSignPerformance ()
144 {
145   struct GNUNET_CRYPTO_EccSignaturePurpose purp;
146   struct GNUNET_CRYPTO_EcdsaSignature sig;
147   struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
148   int i;
149   struct GNUNET_TIME_Absolute start;
150   int ok = GNUNET_OK;
151
152   purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose));
153   purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
154   FPRINTF (stderr, "%s",  "W");
155   GNUNET_CRYPTO_ecdsa_key_get_public (key, &pkey);
156   start = GNUNET_TIME_absolute_get ();
157   for (i = 0; i < ITER; i++)
158   {
159     FPRINTF (stderr, "%s",  "."); fflush (stderr);
160     if (GNUNET_SYSERR == GNUNET_CRYPTO_ecdsa_sign (key, &purp, &sig))
161     {
162       FPRINTF (stderr, "%s",
163                "GNUNET_CRYPTO_ecdsa_sign returned SYSERR\n");
164       ok = GNUNET_SYSERR;
165       continue;
166     }
167   }
168   printf ("%d ECC sign operations %s\n", ITER,
169           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start),
170                                                   GNUNET_YES));
171   return ok;
172 }
173 #endif
174
175
176 static void
177 perf_keygen ()
178 {
179   struct GNUNET_TIME_Absolute start;
180   struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
181   int i;
182
183   FPRINTF (stderr, "%s",  "W");
184   start = GNUNET_TIME_absolute_get ();
185   for (i=0;i<10;i++)
186   {
187     fprintf (stderr, "."); fflush (stderr);
188     pk = GNUNET_CRYPTO_ecdsa_key_create ();
189     GNUNET_free (pk);
190   }
191   for (;i<25;i++)
192     fprintf (stderr, ".");
193   fflush (stderr);
194   printf ("10 ECDSA keys created in %s\n",
195           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start), GNUNET_YES));
196 }
197
198
199 int
200 main (int argc, char *argv[])
201 {
202   int failure_count = 0;
203
204   if (! gcry_check_version ("1.6.0"))
205   {
206     FPRINTF (stderr,
207              _
208              ("libgcrypt has not the expected version (version %s is required).\n"),
209              "1.6.0");
210     return 0;
211   }
212   if (getenv ("GNUNET_GCRYPT_DEBUG"))
213     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
214   GNUNET_log_setup ("test-crypto-ecc", "WARNING", NULL);
215   key = GNUNET_CRYPTO_ecdsa_key_create ();
216   if (GNUNET_OK != testDeriveSignVerify ())
217   {
218     failure_count++;
219     fprintf (stderr,
220              "\n\n%d TESTS FAILED!\n\n", failure_count);
221     return -1;
222   }
223 #if PERF
224   if (GNUNET_OK != testSignPerformance ())
225     failure_count++;
226 #endif
227   if (GNUNET_OK != testSignVerify ())
228     failure_count++;
229   GNUNET_free (key);
230   perf_keygen ();
231
232   if (0 != failure_count)
233   {
234     fprintf (stderr,
235              "\n\n%d TESTS FAILED!\n\n",
236              failure_count);
237     return -1;
238   }
239   return 0;
240 }
241
242 /* end of test_crypto_ecdsa.c */