2005-04-11 Moritz Schulte <moritz@g10code.com>
[libgcrypt.git] / tests / ac-schemes.c
1 /* ac-schemes.c - Tests for ES/SSA
2    Copyright (C) 2003, 2005 Free Software Foundation, Inc.
3
4    This file is part of Libgcrypt.
5
6    This program is free software; you can redistribute it and/or
7    modify it under the terms of the GNU General Public License as
8    published by the Free Software Foundation; either version 2 of the
9    License, or (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful, but
12    WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19    USA.  */
20
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <errno.h>
27
28 #include "../src/gcrypt.h"
29
30 static unsigned int verbose;
31
32 static void
33 die (const char *format, ...)
34 {
35   va_list arg_ptr ;
36
37   va_start( arg_ptr, format ) ;
38   vfprintf (stderr, format, arg_ptr );
39   va_end(arg_ptr);
40   exit (1);
41 }
42
43 typedef struct scheme_spec
44 {
45   unsigned int idx;
46   gcry_ac_scheme_t scheme;
47   unsigned int flags;
48   unsigned char *m;
49   size_t m_n;
50 } scheme_spec_t;
51
52 #define SCHEME_SPEC_FLAG_GET_OPTS (1 << 0)
53
54 #define FILL(idx, scheme, flags, m) \
55     { idx, GCRY_AC_##scheme, flags, m, sizeof (m) }
56
57 scheme_spec_t es_specs[] =
58   {
59     FILL (0, ES_PKCS_V1_5, 0, "foobar"),
60     FILL (1, ES_PKCS_V1_5, 0, "")
61   };
62
63 scheme_spec_t ssa_specs[] =
64   {
65     FILL (0, SSA_PKCS_V1_5, SCHEME_SPEC_FLAG_GET_OPTS, "foobar")
66   };
67
68 #undef FILL
69
70 gcry_err_code_t
71 scheme_get_opts (scheme_spec_t specs, void **opts)
72 {
73   gcry_err_code_t err = GPG_ERR_NO_ERROR;
74   void *opts_new = NULL;
75
76   switch (specs.scheme)
77     {
78     case GCRY_AC_SSA_PKCS_V1_5:
79       {
80         gcry_ac_ssa_pkcs_v1_5_t *opts_pkcs_v1_5 = NULL;
81         
82         opts_new = gcry_malloc (sizeof (gcry_ac_ssa_pkcs_v1_5_t));
83         if (! opts_new)
84           err = gpg_err_code_from_errno (ENOMEM);
85         else
86           {
87             opts_pkcs_v1_5 = (gcry_ac_ssa_pkcs_v1_5_t *) opts_new;
88
89             switch (specs.idx)
90               {
91               case 0:
92                 opts_pkcs_v1_5->md = GCRY_MD_SHA1;
93                 break;
94               case 1:
95                 opts_pkcs_v1_5->md = GCRY_MD_MD5;
96                 break;
97               }
98           }
99       }
100     case GCRY_AC_ES_PKCS_V1_5:
101       break;
102     }
103
104   if (! err)
105     *opts = opts_new;
106
107   return err;
108 }
109
110 gcry_error_t
111 es_check (gcry_ac_handle_t handle, scheme_spec_t spec,
112           gcry_ac_key_t key_public, gcry_ac_key_t key_secret)
113 {
114   gcry_error_t err = GPG_ERR_NO_ERROR;
115   unsigned char *c = NULL, *m2 = NULL;
116   size_t c_n = 0, m2_n = 0;
117   void *opts = NULL;
118   gcry_ac_io_t io_m;
119   gcry_ac_io_t io_c;
120   gcry_ac_io_t io_m2;
121   
122   if (spec.flags & SCHEME_SPEC_FLAG_GET_OPTS)
123     err = scheme_get_opts (spec, &opts);
124   if (! err)
125     {
126       c = NULL;
127       m2 = NULL;
128
129       gcry_ac_io_init (&io_m, GCRY_AC_IO_READABLE,
130                        GCRY_AC_IO_STRING, spec.m, spec.m_n);
131       gcry_ac_io_init (&io_c, GCRY_AC_IO_WRITABLE,
132                        GCRY_AC_IO_STRING, &c, &c_n);
133
134       err = gcry_ac_data_encrypt_scheme (handle, GCRY_AC_ES_PKCS_V1_5, 0, opts, key_public,
135                                          &io_m, &io_c);
136       if (! err)
137         {
138           gcry_ac_io_init (&io_c, GCRY_AC_IO_READABLE,
139                            GCRY_AC_IO_STRING, c, c_n);
140           gcry_ac_io_init (&io_m2, GCRY_AC_IO_WRITABLE,
141                            GCRY_AC_IO_STRING, &m2, &m2_n);
142
143           err = gcry_ac_data_decrypt_scheme (handle, GCRY_AC_ES_PKCS_V1_5, 0,
144                                              opts, key_secret, &io_c, &io_m2);
145         }
146       if (! err)
147         assert ((spec.m_n == m2_n) && (! strncmp (spec.m, m2, spec.m_n)));
148
149       if (c)
150         gcry_free (c);
151       if (m2)
152         gcry_free (m2);
153     }
154
155   if (opts)
156     gcry_free (opts);
157
158   return err;
159 }
160
161 gcry_error_t
162 ssa_check (gcry_ac_handle_t handle, scheme_spec_t spec,
163            gcry_ac_key_t key_public, gcry_ac_key_t key_secret)
164 {
165   gcry_error_t err = GPG_ERR_NO_ERROR;
166   unsigned char *s = NULL;
167   size_t s_n = 0;
168   void *opts = NULL;
169   gcry_ac_io_t io_m;
170   gcry_ac_io_t io_s;
171   
172   if (spec.flags & SCHEME_SPEC_FLAG_GET_OPTS)
173     err = scheme_get_opts (spec, &opts);
174   if (! err)
175     {
176       gcry_ac_io_init (&io_m, GCRY_AC_IO_READABLE,
177                        GCRY_AC_IO_STRING, spec.m, spec.m_n);
178       gcry_ac_io_init (&io_s, GCRY_AC_IO_WRITABLE,
179                        GCRY_AC_IO_STRING, &s, &s_n);
180
181       err = gcry_ac_data_sign_scheme (handle, GCRY_AC_SSA_PKCS_V1_5, 0, opts, key_secret,
182                                       &io_m, &io_s);
183       if (! err)
184         {
185           gcry_ac_io_init (&io_m, GCRY_AC_IO_READABLE,
186                            GCRY_AC_IO_STRING, spec.m, spec.m_n);
187           gcry_ac_io_init (&io_s, GCRY_AC_IO_READABLE,
188                            GCRY_AC_IO_STRING, s, s_n);
189           err = gcry_ac_data_verify_scheme (handle, GCRY_AC_SSA_PKCS_V1_5, 0, opts, key_public,
190                                             &io_m, &io_s);
191         }
192       assert (! err);
193
194       if (s)
195         gcry_free (s);
196     }
197
198   if (opts)
199     gcry_free (opts);
200
201   return err;
202 }
203
204 void
205 es_checks (gcry_ac_handle_t handle, gcry_ac_key_t key_public, gcry_ac_key_t key_secret)
206 {
207   gcry_error_t err = GPG_ERR_NO_ERROR;
208   unsigned int i = 0;
209
210   for (i = 0; (i < (sizeof (es_specs) / sizeof (*es_specs))) && (! err); i++)
211     err = es_check (handle, es_specs[i], key_public, key_secret);
212
213   assert (! err);
214 }
215
216 void
217 ssa_checks (gcry_ac_handle_t handle, gcry_ac_key_t key_public, gcry_ac_key_t key_secret)
218 {
219   gcry_error_t err = GPG_ERR_NO_ERROR;
220   unsigned int i = 0;
221
222   for (i = 0; (i < (sizeof (ssa_specs) / sizeof (*ssa_specs))) && (! err); i++)
223     err = ssa_check (handle, ssa_specs[i], key_public, key_secret);
224
225   assert (! err);
226 }
227
228 #define KEY_TYPE_PUBLIC (1 << 0)
229 #define KEY_TYPE_SECRET (1 << 1)
230
231 typedef struct key_spec
232 {
233   const char *name;
234   unsigned int flags;
235   const char *mpi_string;
236 } key_spec_t;
237
238 key_spec_t key_specs[] =
239   {
240     { "n", KEY_TYPE_PUBLIC | KEY_TYPE_SECRET,
241       "e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
242       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
243       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
244       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251" },
245     { "e", KEY_TYPE_PUBLIC | KEY_TYPE_SECRET,
246       "010001" },
247     { "d", KEY_TYPE_SECRET,
248       "046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
249       "7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
250       "C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
251       "C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781" },
252     { "p", KEY_TYPE_SECRET,
253       "00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
254       "fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424f1" },
255     { "q", KEY_TYPE_SECRET,
256       "00f7a7ca5367c661f8e62df34f0d05c10c88e5492348dd7bddc942c9a8f369f9"
257       "35a07785d2db805215ed786e4285df1658eed3ce84f469b81b50d358407b4ad361" },
258     { "u", KEY_TYPE_SECRET,
259       "304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
260       "ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b" },
261     { NULL },
262   };
263
264 gcry_error_t
265 key_init (gcry_ac_key_type_t type, gcry_ac_key_t *key)
266 {
267   gcry_error_t err = GPG_ERR_NO_ERROR;
268   gcry_ac_data_t key_data = NULL;
269   gcry_ac_key_t key_new = NULL;
270   gcry_mpi_t mpi = NULL;
271   unsigned int i = 0;
272
273   err = gcry_ac_data_new (&key_data);
274   for (i = 0; key_specs[i].name && (! err); i++)
275     {
276       if (((type == GCRY_AC_KEY_PUBLIC) && (key_specs[i].flags & KEY_TYPE_PUBLIC))
277           || ((type == GCRY_AC_KEY_SECRET) && (key_specs[i].flags & KEY_TYPE_SECRET)))
278         {
279           err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, key_specs[i].mpi_string, 0, NULL);
280           if (! err)
281             {
282               gcry_ac_data_set (key_data, GCRY_AC_FLAG_COPY | GCRY_AC_FLAG_DEALLOC,
283                                 key_specs[i].name, mpi);
284               gcry_mpi_release (mpi);
285             }
286         }
287     }
288   if (! err)
289     err = gcry_ac_key_init (&key_new, NULL, type, key_data);
290
291   if (key_data)
292     gcry_ac_data_destroy (key_data);
293   
294   if (! err)
295     *key = key_new;
296
297   return err;
298 }
299
300 static void
301 check_run (void)
302 {
303   gcry_ac_handle_t handle = NULL;
304   gcry_error_t err = GPG_ERR_NO_ERROR;
305   gcry_ac_key_t key_public = NULL, key_secret = NULL;
306
307   err = key_init (GCRY_AC_KEY_PUBLIC, &key_public);
308   if (! err)
309     err = key_init (GCRY_AC_KEY_SECRET, &key_secret);
310   
311   if (! err)
312     err = gcry_ac_open (&handle, GCRY_AC_RSA, 0);
313   if (! err)
314     {
315       es_checks (handle, key_public, key_secret);
316       ssa_checks (handle, key_public, key_secret);
317     }
318   
319   assert (! err);
320 }
321
322 int
323 main (int argc, char **argv)
324 {
325   unsigned int debug = 0;
326
327   if ((argc > 1) && (! strcmp (argv[1], "--verbose")))
328     verbose = 1;
329   else if ((argc > 1) && (! strcmp (argv[1], "--debug")))
330     verbose = debug = 1;
331
332   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
333   if (! gcry_check_version (GCRYPT_VERSION))
334     die ("version mismatch\n");
335   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
336   if (debug)
337     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
338
339   check_run ();
340   
341   return 0;
342 }