ChangeLog:
[libgcrypt.git] / tests / tsexp.c
1 /* tsexp.c  -  S-expression regression tests
2  *      Copyright (C) 2001, 2002, 2003, 2005 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <stdarg.h>
28 #include "../src/gcrypt.h"
29
30 #define PGMNAME "tsexp"
31
32 static int verbose;
33 static int error_count;
34
35 static void
36 info (const char *format, ...)
37 {
38   va_list arg_ptr;
39
40   if (verbose)
41     {
42       va_start( arg_ptr, format ) ;
43       vfprintf (stderr, format, arg_ptr );
44       va_end(arg_ptr);
45     }
46 }
47
48 static void
49 fail ( const char *format, ... )
50 {
51     va_list arg_ptr ;
52
53     fputs (PGMNAME ": ", stderr);
54     va_start( arg_ptr, format ) ;
55     vfprintf (stderr, format, arg_ptr );
56     va_end(arg_ptr);
57     error_count++;
58 }
59
60
61 /* fixme: we need better tests */
62 static void
63 basic (void)
64 {
65   int pass;
66   gcry_sexp_t sexp;
67   int idx;
68   char *secure_buffer;
69   size_t secure_buffer_len;
70   const char *string;
71   static struct {
72     const char *token;
73     const char *parm;
74   } values[] = {
75     { "public-key", NULL },
76     { "dsa", NULL },
77     { "dsa", "p" },
78     { "dsa", "y" },
79     { "dsa", "q" },
80     { "dsa", "g" },
81     { NULL }
82   };
83
84   info ("doing some pretty pointless tests\n"); 
85
86   secure_buffer_len = 99;
87   secure_buffer = gcry_xmalloc_secure (secure_buffer_len);
88   memset (secure_buffer, 'G', secure_buffer_len);
89
90   for (pass=0;;pass++)
91     {
92       switch (pass)
93         {
94         case 0:
95           string = ("(public-key (dsa (p #41424344#) (y this_is_y) "
96                     "(q #61626364656667#) (g %m)))");
97           
98           if ( gcry_sexp_build (&sexp, NULL, string,
99                                 gcry_mpi_set_ui (NULL, 42)) )
100             {
101               fail (" scanning `%s' failed\n", string);
102               return;
103             }
104           break;
105           
106         case 1:
107           string = ("(public-key (dsa (p #41424344#) (y this_is_y) "
108                     "(q %b) (g %m)))");
109       
110           if ( gcry_sexp_build (&sexp, NULL, string, 
111                                 15, "foo\0\x01\0x02789012345",
112                                 gcry_mpi_set_ui (NULL, 42)) )
113             {
114               fail (" scanning `%s' failed\n", string);
115               return;
116             }
117           break;
118
119         case 2:
120           string = ("(public-key (dsa (p #41424344#) (y silly_y_value) "
121                     "(q %b) (g %m)))");
122       
123           if ( gcry_sexp_build (&sexp, NULL, string, 
124                                 secure_buffer_len, secure_buffer,
125                                 gcry_mpi_set_ui (NULL, 17)) )
126             {
127               fail (" scanning `%s' failed\n", string);
128               return;
129             }
130           if (!gcry_is_secure (sexp))
131             fail ("gcry_sexp_build did not switch to secure memory\n");
132           break;
133           
134         default:
135           return; /* Ready. */
136         }
137
138
139       /* now find something */
140       for (idx=0; values[idx].token; idx++)
141         {
142           const char *token = values[idx].token;
143           const char *parm = values[idx].parm;
144           gcry_sexp_t s1, s2;
145           gcry_mpi_t a;
146           const char *p;
147           size_t n;
148
149           s1 = gcry_sexp_find_token (sexp, token, strlen(token) );
150           if (!s1)
151             {
152               fail ("didn't found `%s'\n", token);
153               continue;
154             }
155
156           p = gcry_sexp_nth_data (s1, 0, &n);
157           if (!p)
158             {
159               fail ("no car for `%s'\n", token);
160               continue;
161             }
162           info ("car=`%.*s'\n", (int)n, p);
163
164           s2 = gcry_sexp_cdr (s1);
165           if (!s2) 
166             {
167               fail ("no cdr for `%s'\n", token);
168               continue;
169             }
170
171           p = gcry_sexp_nth_data (s2, 0, &n);
172           if (p)
173             {
174               fail ("data at car of `%s'\n", token);
175               continue;
176             }
177
178           if (parm)
179             {
180               s2 = gcry_sexp_find_token (s1, parm, strlen (parm));
181               if (!s2)
182                 {
183                   fail ("didn't found `%s'\n", parm);
184                   continue;
185                 }
186               p = gcry_sexp_nth_data (s2, 0, &n);
187               if (!p) 
188                 {
189                   fail("no car for `%s'\n", parm );
190                   continue;
191                 }
192               info ("car=`%.*s'\n", (int)n, p);
193               p = gcry_sexp_nth_data (s2, 1, &n);
194               if (!p) 
195                 {
196                   fail("no cdr for `%s'\n", parm );
197                   continue;
198                 }
199               info ("cdr=`%.*s'\n", (int)n, p);
200           
201               a = gcry_sexp_nth_mpi (s2, 0, GCRYMPI_FMT_USG);
202               if (!a)
203                 {
204                   fail("failed to cdr the mpi for `%s'\n", parm);
205                   continue;
206                 }
207             }
208         }
209      
210       gcry_sexp_release (sexp);
211       sexp = NULL;
212     }
213   gcry_free (secure_buffer);
214 }
215
216
217 static void
218 canon_len (void)
219 {
220   static struct {
221     size_t textlen; /* length of the buffer */
222     size_t expected;/* expected length or 0 on error and then ... */
223     size_t erroff;  /* ... and at this offset */
224     gcry_error_t errcode;    /* ... with this error code */
225     unsigned char *text; 
226   } values[] = {
227     { 14, 13, 0, GPG_ERR_NO_ERROR, "(9:abcdefghi) " },
228     { 16, 15, 0, GPG_ERR_NO_ERROR, "(10:abcdefghix)" },
229     { 14,  0,14, GPG_ERR_SEXP_STRING_TOO_LONG, "(10:abcdefghi)" },
230     { 15,  0, 1, GPG_ERR_SEXP_ZERO_PREFIX, "(010:abcdefghi)" },
231     {  2,  0, 0, GPG_ERR_SEXP_NOT_CANONICAL, "1:"},
232     {  4,  0, 4, GPG_ERR_SEXP_STRING_TOO_LONG, "(1:)"},
233     {  5,  5, 0, GPG_ERR_NO_ERROR, "(1:x)"},
234     {  2,  2, 0, GPG_ERR_NO_ERROR, "()"},
235     {  4,  2, 0, GPG_ERR_NO_ERROR, "()()"},
236     {  4,  4, 0, GPG_ERR_NO_ERROR, "(())"},
237     {  3,  0, 3, GPG_ERR_SEXP_STRING_TOO_LONG, "(()"},
238     {  3,  0, 1, GPG_ERR_SEXP_BAD_CHARACTER, "( )"},
239     {  9,  9, 0, GPG_ERR_NO_ERROR, "(3:abc())"},
240     { 10,  0, 6, GPG_ERR_SEXP_BAD_CHARACTER, "(3:abc ())"},
241     /* fixme: we need much more cases */
242     { 0 },
243   };
244   int idx;
245   gcry_error_t errcode;
246   size_t n, erroff;
247
248   info ("checking canoncial length test function\n");
249   for (idx=0; values[idx].text; idx++)
250     {
251       n = gcry_sexp_canon_len (values[idx].text, values[idx].textlen, 
252                                &erroff, &errcode);
253       
254       if (n && n == values[idx].expected)
255         ; /* success */
256       else if (!n && !values[idx].expected)
257         { /* we expected an error - check that this is the right one */
258           if (values[idx].erroff != erroff)
259             fail ("canonical length test %d - wrong error offset %u\n",
260                   idx, (unsigned int)erroff);
261           if (gcry_err_code (errcode) != values[idx].errcode)
262             fail ("canonical length test %d - wrong error code %d\n",
263                   idx, errcode);
264         }
265       else
266         fail ("canonical length test %d failed - n=%u, off=%u, err=%d\n",
267               idx, (unsigned int)n, (unsigned int)erroff, errcode);
268     }
269 }
270
271
272 static void
273 back_and_forth_one (int testno, const char *buffer, size_t length)
274 {
275   gcry_error_t rc;
276   gcry_sexp_t se, se1;
277   size_t n, n1;
278   char *p1;
279
280   rc = gcry_sexp_new (&se, buffer, length, 1);
281   if (rc)
282     {
283       fail ("baf %d: gcry_sexp_new failed: %s\n", testno, gpg_strerror (rc));
284       return;
285     }
286   n1 = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, NULL, 0);
287   if (!n1)
288     {
289       fail ("baf %d: get required length for canon failed\n", testno);
290       return;
291     }
292   p1 = gcry_xmalloc (n1);
293   n = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, p1, n1);
294   if (n1 != n+1) /* sprints adds an extra 0 but dies not return it */
295     {
296       fail ("baf %d: length mismatch for canon\n", testno);
297       return;
298     }
299   rc = gcry_sexp_create (&se1, p1, n, 0, gcry_free);
300   if (rc)
301     {
302       fail ("baf %d: gcry_sexp_create failed: %s\n",
303             testno, gpg_strerror (rc));
304       return;
305     }
306   gcry_sexp_release (se1);
307   
308   /* FIXME: we need a lot more tests */
309
310   gcry_sexp_release (se);
311 }
312
313
314
315 static void
316 back_and_forth (void)
317 {
318   static struct { char *buf; int len; } tests[] = {
319     { "(7:g34:fgh1::2:())", 0 },
320     { "(7:g34:fgh1::2:())", 18 },
321     { NULL, 0 }
322   };
323   int idx;
324
325   for (idx=0; tests[idx].buf; idx++)
326     back_and_forth_one (idx, tests[idx].buf, tests[idx].len);
327 }
328
329
330 static void
331 check_sscan (void)
332 {
333   static struct {
334     const char *text;
335     gcry_error_t expected_err;  
336   } values[] = {
337     /* Bug reported by Olivier L'Heureux 2003-10-07 */
338     { "(7:sig-val(3:dsa"
339       "(1:r20:\x7e\xff\xd5\xba\xc9\xc9\xa4\x9b\xd4\x26\x8b\x64"
340       "\x06\x7a\xcf\x42\x7b\x6c\x51\xfb)"
341       "(1:s21:\x01\x8c\x6c\x6f\x37\x1a\x8d\xfd\x5a\xb3\x2a\x3d"
342       "\xc5\xae\x23\xed\x32\x62\x30\x62\x3e)))",
343       GPG_ERR_NO_ERROR },
344     { "(7:sig-val(3:dsa"
345       "(1:r20:\x7e\xff\xd5\xba\xc9\xc9\xa4\x9b\xd4\x26\x8b\x64"
346       "\x06\x7a\xcf\x42\x7b\x6c\x51\xfb)"
347       "(1:s21:\x01\x8c\x6c\x6f\x37\x1a\x8d\xfd\x5a\xb3\x2a\x3d"
348       "\xc5\xae\x23\xed\x32\x62\x30\x62\x3e))",
349       GPG_ERR_SEXP_UNMATCHED_PAREN },
350     { "(7:sig-val(3:dsa"
351       "(1:r20:\x7e\xff\xd5\xba\xc9\xc9\xa4\x9b\xd4\x26\x8b\x64"
352       "\x06\x7a\xcf\x42\x7b\x6c\x51\xfb)"
353       "(1:s21:\x01\x8c\x6c\x6f\x37\x1a\x8d\xfd\x5a\xb3\x2a\x3d"
354       "\xc5\xae\x23\xed\x32\x62\x30\x62\x3e))))",
355       GPG_ERR_SEXP_UNMATCHED_PAREN },
356     { NULL, 0 }
357   };
358   int idx;
359   gcry_error_t err;
360   gcry_sexp_t s;
361
362   info ("checking gcry_sexp_sscan\n");
363   for (idx=0; values[idx].text; idx++)
364     {
365       err = gcry_sexp_sscan (&s, NULL,
366                              values[idx].text,
367                              strlen (values[idx].text));
368       if (gpg_err_code (err) != values[idx].expected_err)
369         fail ("gcry_sexp_sscan test %d failed: %s\n", idx, gpg_strerror (err));
370       gcry_sexp_release (s);
371     }
372 }
373
374
375
376
377 int
378 main (int argc, char **argv)
379 {
380   if (argc > 1 && !strcmp (argv[1], "-v"))
381     verbose = 1;
382
383   gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
384   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
385
386   basic ();
387   canon_len ();
388   back_and_forth ();
389   check_sscan ();
390   
391   return error_count? 1:0;
392 }
393
394
395
396
397
398