* basic.c (check_aes128_cbc_cts_cipher): New function.
[libgcrypt.git] / tests / tsexp.c
1 /* tsexp.c  -  S-expression regression tests
2  *      Copyright (C) 2001, 2002 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 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <stdarg.h>
25 #include "../src/gcrypt.h"
26
27 #define PGMNAME "tsexp"
28
29 static int verbose;
30 static int error_count;
31
32 static void
33 info (const char *format, ...)
34 {
35   va_list arg_ptr;
36
37   if (verbose)
38     {
39       va_start( arg_ptr, format ) ;
40       vfprintf (stderr, format, arg_ptr );
41       va_end(arg_ptr);
42     }
43 }
44
45 static void
46 fail ( const char *format, ... )
47 {
48     va_list arg_ptr ;
49
50     fputs (PGMNAME ": ", stderr);
51     va_start( arg_ptr, format ) ;
52     vfprintf (stderr, format, arg_ptr );
53     va_end(arg_ptr);
54     error_count++;
55 }
56
57
58 /* fixme: we need better tests */
59 static void
60 basic (void)
61 {
62   GCRY_SEXP sexp;
63   int idx;
64   const char *string;
65   static struct {
66     const char *token;
67     const char *parm;
68   } values[] = {
69     { "public-key", NULL },
70     { "dsa", NULL },
71     { "dsa", "p" },
72     { "dsa", "y" },
73     { "dsa", "q" },
74     { "dsa", "g" },
75     { NULL }
76   };
77
78   info ("doing some pretty pointless tests\n"); 
79   string = ("(public-key (dsa (p #41424344#) (y this_is_y) "
80             "(q #61626364656667#) (g %m)))");
81      
82   if ( gcry_sexp_build (&sexp, NULL, string, gcry_mpi_set_ui (NULL, 42)) )
83     {
84       fail (" scanning `%s' failed\n", string);
85       return;
86     }
87
88   /* now find something */
89   for (idx=0; values[idx].token; idx++)
90     {
91       const char *token = values[idx].token;
92       const char *parm = values[idx].parm;
93       GCRY_SEXP s1, s2;
94       GCRY_MPI a;
95       const char *p;
96       size_t n;
97
98       s1 = gcry_sexp_find_token (sexp, token, strlen(token) );
99       if (!s1)
100         {
101           fail ("didn't found `%s'\n", token);
102           continue;
103         }
104
105       p = gcry_sexp_nth_data (s1, 0, &n);
106       if (!p)
107         {
108           fail ("no car for `%s'\n", token);
109           continue;
110         }
111       info ("car=`%.*s'\n", (int)n, p);
112
113       s2 = gcry_sexp_cdr (s1);
114       if (!s2) 
115         {
116           fail ("no cdr for `%s'\n", token);
117           continue;
118         }
119
120       p = gcry_sexp_nth_data (s2, 0, &n);
121       if (p)
122         {
123           fail ("data at car of `%s'\n", token);
124           continue;
125         }
126
127       if (parm)
128         {
129           s2 = gcry_sexp_find_token (s1, parm, strlen (parm));
130           if (!s2)
131             {
132               fail ("didn't found `%s'\n", parm);
133               continue;
134             }
135           p = gcry_sexp_nth_data (s2, 0, &n);
136           if (!p) 
137             {
138               fail("no car for `%s'\n", parm );
139               continue;
140             }
141           info ("car=`%.*s'\n", (int)n, p);
142           p = gcry_sexp_nth_data (s2, 1, &n);
143           if (!p) 
144             {
145               fail("no cdr for `%s'\n", parm );
146               continue;
147             }
148           info ("cdr=`%.*s'\n", (int)n, p);
149           
150           a = gcry_sexp_nth_mpi (s2, 0, GCRYMPI_FMT_USG);
151           if (!a)
152             {
153               fail("failed to cdr the mpi for `%s'\n", parm);
154               continue;
155             }
156         }
157     }
158 }
159
160
161 static void
162 canon_len (void)
163 {
164   static struct {
165     size_t textlen; /* length of the buffer */
166     size_t expected;/* expected length or 0 on error and then ... */
167     size_t erroff;  /* ... and at this offset */
168     int errcode;    /* ... with this error code */
169     unsigned char *text; 
170   } values[] = {
171     { 14, 13, 0,  0, "(9:abcdefghi) " },
172     { 16, 15, 0,  0, "(10:abcdefghix)" },
173     { 14,  0,14, -2, "(10:abcdefghi)" },
174     { 15,  0, 1, -7, "(010:abcdefghi)" },
175     {  2,  0, 0, -4, "1:"},
176     {  4,  0, 4, -2, "(1:)"},
177     {  5,  5, 0,  0, "(1:x)"},
178     {  2,  2, 0,  0, "()"},
179     {  4,  2, 0,  0, "()()"},
180     {  4,  4, 0,  0, "(())"},
181     {  3,  0, 3, -2, "(()"},
182     {  3,  0, 1, -5, "( )"},
183     {  9,  9, 0,  0, "(3:abc())"},
184     { 10,  0, 6, -5, "(3:abc ())"},
185     /* fixme: we need much more cases */
186     { 0 },
187   };
188   int idx;
189   int errcode;
190   size_t n, erroff;
191
192   info ("checking canoncial length test function\n");
193   for (idx=0; values[idx].text; idx++)
194     {
195       n = gcry_sexp_canon_len (values[idx].text, values[idx].textlen, 
196                                &erroff, &errcode);
197       
198       if (n && n == values[idx].expected)
199         ; /* success */
200       else if (!n && !values[idx].expected)
201         { /* we expected an error - check that this is the right one */
202           if (values[idx].erroff != erroff)
203             fail ("canonical length test %d - wrong error offset %u\n",
204                   idx, (unsigned int)erroff);
205           if (values[idx].errcode != errcode)
206             fail ("canonical length test %d - wrong error code %d\n",
207                   idx, errcode);
208         }
209       else
210         fail ("canonical length test %d failed - n=%u, off=%u, err=%d\n",
211               idx, (unsigned int)n, (unsigned int)erroff, errcode);
212     }
213 }
214
215
216 static void
217 back_and_forth_one (int testno, const char *buffer, size_t length)
218 {
219   int rc;
220   GcrySexp se, se1;
221   size_t n, n1;
222   char *p1;
223
224   rc = gcry_sexp_new (&se, buffer, length, 1);
225   if (rc)
226     {
227       fail ("baf %d: gcry_sexp_new failed: %s\n", testno, gcry_strerror (rc));
228       return;
229     }
230   n1 = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, NULL, 0);
231   if (!n1)
232     {
233       fail ("baf %d: get required length for canon failed\n", testno);
234       return;
235     }
236   p1 = gcry_xmalloc (n1);
237   n = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, p1, n1);
238   if (n1 != n+1) /* sprints adds an extra 0 but dies not return it */
239     {
240       fail ("baf %d: length mismatch for canon\n", testno);
241       return;
242     }
243   rc = gcry_sexp_create (&se1, p1, n, 0, gcry_free);
244   if (rc)
245     {
246       fail ("baf %d: gcry_sexp_create failed: %s\n",
247             testno, gcry_strerror (rc));
248       return;
249     }
250   gcry_sexp_release (se1);
251   
252   /* FIXME: we need a lot more tests */
253
254   gcry_sexp_release (se);
255 }
256
257
258
259 static void
260 back_and_forth (void)
261 {
262   static struct { char *buf; int len; } tests[] = {
263     { "(7:g34:fgh1::2:())", 0 },
264     { "(7:g34:fgh1::2:())", 18 },
265     { NULL, 0 }
266   };
267   int idx;
268
269   for (idx=0; tests[idx].buf; idx++)
270     back_and_forth_one (idx, tests[idx].buf, tests[idx].len);
271 }
272
273
274 int
275 main (int argc, char **argv)
276 {
277   if (argc > 1 && !strcmp (argv[1], "-v"))
278     verbose = 1;
279
280   basic ();
281   canon_len ();
282   back_and_forth ();
283   
284   return error_count? 1:0;
285 }
286
287
288
289
290
291