Line data Source code
1 : /* t-sexp.c - S-expression regression tests
2 : * Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
3 : * Copyright (C) 2014 g10 Code GmbH
4 : *
5 : * This file is part of Libgcrypt.
6 : *
7 : * Libgcrypt is free software; you can redistribute it and/or modify
8 : * it under the terms of the GNU Lesser General Public License as
9 : * published by the Free Software Foundation; either version 2.1 of
10 : * the License, or (at your option) any later version.
11 : *
12 : * Libgcrypt is distributed in the hope that it will be useful,
13 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : * GNU Lesser General Public License for more details.
16 : *
17 : * You should have received a copy of the GNU Lesser General Public
18 : * License along with this program; if not, see <http://www.gnu.org/licenses/>.
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 <assert.h>
29 : #include "../src/gcrypt-int.h"
30 :
31 : #define PGMNAME "t-sexp"
32 : #include "t-common.h"
33 :
34 :
35 : /* Convert STRING consisting of hex characters into its binary
36 : representation and return it as an allocated buffer. The valid
37 : length of the buffer is returned at R_LENGTH. The string is
38 : delimited by end of string. The function returns NULL on
39 : error. */
40 : static void *
41 8 : hex2buffer (const char *string, size_t *r_length)
42 : {
43 : const char *s;
44 : unsigned char *buffer;
45 : size_t length;
46 :
47 8 : buffer = xmalloc (strlen(string)/2+1);
48 8 : length = 0;
49 266 : for (s=string; *s; s +=2 )
50 : {
51 258 : if (!hexdigitp (s) || !hexdigitp (s+1))
52 0 : return NULL; /* Invalid hex digits. */
53 258 : ((unsigned char*)buffer)[length++] = xtoi_2 (s);
54 : }
55 8 : *r_length = length;
56 8 : return buffer;
57 : }
58 :
59 :
60 : static gcry_mpi_t
61 55 : hex2mpi (const char *string)
62 : {
63 : gpg_error_t err;
64 : gcry_mpi_t val;
65 :
66 55 : err = gcry_mpi_scan (&val, GCRYMPI_FMT_HEX, string, 0, NULL);
67 55 : if (err)
68 0 : die ("hex2mpi '%s' failed: %s\n", string, gpg_strerror (err));
69 55 : return val;
70 : }
71 :
72 : static gcry_mpi_t
73 5 : hex2mpiopa (const char *string)
74 : {
75 : char *buffer;
76 : size_t buflen;
77 : gcry_mpi_t val;
78 :
79 5 : buffer = hex2buffer (string, &buflen);
80 5 : if (!buffer)
81 0 : die ("hex2mpiopa '%s' failed: parser error\n", string);
82 5 : val = gcry_mpi_set_opaque (NULL, buffer, buflen*8);
83 5 : if (!buffer)
84 0 : die ("hex2mpiopa '%s' failed: set_opaque error\n", string);
85 5 : return val;
86 : }
87 :
88 :
89 : /* Compare A to B, where B is given as a hex string. */
90 : static int
91 60 : cmp_mpihex (gcry_mpi_t a, const char *b)
92 : {
93 : gcry_mpi_t bval;
94 : int res;
95 :
96 60 : if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
97 5 : bval = hex2mpiopa (b);
98 : else
99 55 : bval = hex2mpi (b);
100 60 : res = gcry_mpi_cmp (a, bval);
101 60 : gcry_mpi_release (bval);
102 60 : return res;
103 : }
104 :
105 : /* Compare A to B, where A is a buffer and B a hex string. */
106 : static int
107 3 : cmp_bufhex (const void *a, size_t alen, const char *b)
108 : {
109 : void *bbuf;
110 : size_t blen;
111 : int res;
112 :
113 3 : if (!a && !b)
114 0 : return 0;
115 3 : if (a && !b)
116 0 : return 1;
117 3 : if (!a && b)
118 0 : return -1;
119 :
120 3 : bbuf = hex2buffer (b, &blen);
121 3 : if (!bbuf)
122 0 : die ("cmp_bufhex: error converting hex string\n");
123 3 : if (alen != blen)
124 0 : return alen < blen? -1 : 1;
125 3 : res = memcmp (a, bbuf, alen);
126 3 : xfree (bbuf);
127 3 : return res;
128 : }
129 :
130 :
131 :
132 : /* fixme: we need better tests */
133 : static void
134 1 : basic (void)
135 : {
136 : int pass;
137 : gcry_sexp_t sexp;
138 : int idx;
139 : char *secure_buffer;
140 : size_t secure_buffer_len;
141 : const char *string;
142 : static struct {
143 : const char *token;
144 : const char *parm;
145 : } values[] = {
146 : { "public-key", NULL },
147 : { "dsa", NULL },
148 : { "dsa", "p" },
149 : { "dsa", "y" },
150 : { "dsa", "q" },
151 : { "dsa", "g" },
152 : { NULL }
153 : };
154 :
155 1 : info ("doing some pretty pointless tests\n");
156 :
157 1 : secure_buffer_len = 99;
158 1 : secure_buffer = gcry_xmalloc_secure (secure_buffer_len);
159 1 : memset (secure_buffer, 'G', secure_buffer_len);
160 :
161 5 : for (pass=0;;pass++)
162 : {
163 : gcry_mpi_t m;
164 :
165 5 : switch (pass)
166 : {
167 : case 0:
168 1 : string = ("(public-key (dsa (p #41424344#) (y this_is_y) "
169 : "(q #61626364656667#) (g %m)))");
170 :
171 1 : m = gcry_mpi_set_ui (NULL, 42);
172 1 : if ( gcry_sexp_build (&sexp, NULL, string, m ) )
173 : {
174 0 : gcry_mpi_release (m);
175 0 : fail (" scanning `%s' failed\n", string);
176 0 : return;
177 : }
178 1 : gcry_mpi_release (m);
179 1 : break;
180 :
181 : case 1:
182 1 : string = ("(public-key (dsa (p #41424344#) (y this_is_y) "
183 : "(q %b) (g %m)))");
184 :
185 1 : m = gcry_mpi_set_ui (NULL, 42);
186 1 : if ( gcry_sexp_build (&sexp, NULL, string,
187 : 15, "foo\0\x01\0x02789012345", m) )
188 : {
189 0 : gcry_mpi_release (m);
190 0 : fail (" scanning `%s' failed\n", string);
191 0 : return;
192 : }
193 1 : gcry_mpi_release (m);
194 1 : break;
195 :
196 : case 2:
197 1 : string = ("(public-key (dsa (p #41424344#) (y silly_y_value) "
198 : "(q %b) (g %m)))");
199 :
200 1 : m = gcry_mpi_set_ui (NULL, 17);
201 1 : if ( gcry_sexp_build (&sexp, NULL, string,
202 : secure_buffer_len, secure_buffer, m) )
203 : {
204 0 : gcry_mpi_release (m);
205 0 : fail (" scanning `%s' failed\n", string);
206 0 : return;
207 : }
208 1 : gcry_mpi_release (m);
209 1 : if (!gcry_is_secure (sexp))
210 0 : fail ("gcry_sexp_build did not switch to secure memory\n");
211 1 : break;
212 :
213 : case 3:
214 : {
215 : gcry_sexp_t help_sexp;
216 :
217 1 : if (gcry_sexp_new (&help_sexp,
218 : "(foobar-parms (xp #1234#)(xq #03#))", 0, 1))
219 : {
220 0 : fail (" scanning fixed string failed\n");
221 0 : return;
222 : }
223 :
224 1 : string = ("(public-key (dsa (p #41424344#) (parm %S) "
225 : "(y dummy)(q %b) (g %m)))");
226 1 : m = gcry_mpi_set_ui (NULL, 17);
227 1 : if ( gcry_sexp_build (&sexp, NULL, string, help_sexp,
228 : secure_buffer_len, secure_buffer, m) )
229 : {
230 0 : gcry_mpi_release (m);
231 0 : fail (" scanning `%s' failed\n", string);
232 0 : return;
233 : }
234 1 : gcry_mpi_release (m);
235 1 : gcry_sexp_release (help_sexp);
236 : }
237 1 : break;
238 :
239 :
240 : default:
241 1 : return; /* Ready. */
242 : }
243 :
244 :
245 : /* now find something */
246 28 : for (idx=0; values[idx].token; idx++)
247 : {
248 24 : const char *token = values[idx].token;
249 24 : const char *parm = values[idx].parm;
250 : gcry_sexp_t s1, s2;
251 : gcry_mpi_t a;
252 : const char *p;
253 : size_t n;
254 :
255 24 : s1 = gcry_sexp_find_token (sexp, token, strlen(token) );
256 24 : if (!s1)
257 : {
258 0 : fail ("didn't found `%s'\n", token);
259 0 : continue;
260 : }
261 :
262 24 : p = gcry_sexp_nth_data (s1, 0, &n);
263 24 : if (!p)
264 : {
265 0 : gcry_sexp_release (s1);
266 0 : fail ("no car for `%s'\n", token);
267 0 : continue;
268 : }
269 : /* info ("car=`%.*s'\n", (int)n, p); */
270 :
271 24 : s2 = gcry_sexp_cdr (s1);
272 24 : if (!s2)
273 : {
274 0 : gcry_sexp_release (s1);
275 0 : fail ("no cdr for `%s'\n", token);
276 0 : continue;
277 : }
278 :
279 24 : p = gcry_sexp_nth_data (s2, 0, &n);
280 24 : gcry_sexp_release (s2);
281 24 : if (p)
282 : {
283 0 : gcry_sexp_release (s1);
284 0 : fail ("data at car of `%s'\n", token);
285 0 : continue;
286 : }
287 :
288 24 : if (parm)
289 : {
290 16 : s2 = gcry_sexp_find_token (s1, parm, strlen (parm));
291 16 : gcry_sexp_release (s1);
292 16 : if (!s2)
293 : {
294 0 : fail ("didn't found `%s'\n", parm);
295 0 : continue;
296 : }
297 16 : p = gcry_sexp_nth_data (s2, 0, &n);
298 16 : if (!p)
299 : {
300 0 : gcry_sexp_release (s2);
301 0 : fail("no car for `%s'\n", parm );
302 0 : continue;
303 : }
304 : /* info ("car=`%.*s'\n", (int)n, p); */
305 16 : p = gcry_sexp_nth_data (s2, 1, &n);
306 16 : if (!p)
307 : {
308 0 : gcry_sexp_release (s2);
309 0 : fail("no cdr for `%s'\n", parm );
310 0 : continue;
311 : }
312 : /* info ("cdr=`%.*s'\n", (int)n, p); */
313 :
314 16 : a = gcry_sexp_nth_mpi (s2, 0, GCRYMPI_FMT_USG);
315 16 : gcry_sexp_release (s2);
316 16 : if (!a)
317 : {
318 0 : fail("failed to cdr the mpi for `%s'\n", parm);
319 0 : continue;
320 : }
321 16 : gcry_mpi_release (a);
322 : }
323 : else
324 8 : gcry_sexp_release (s1);
325 : }
326 :
327 4 : gcry_sexp_release (sexp);
328 4 : sexp = NULL;
329 4 : }
330 : gcry_free (secure_buffer);
331 : }
332 :
333 :
334 : static void
335 1 : canon_len (void)
336 : {
337 : static struct {
338 : size_t textlen; /* length of the buffer */
339 : size_t expected;/* expected length or 0 on error and then ... */
340 : size_t erroff; /* ... and at this offset */
341 : gcry_error_t errcode; /* ... with this error code */
342 : const char *text;
343 : } values[] = {
344 : { 14, 13, 0, GPG_ERR_NO_ERROR, "(9:abcdefghi) " },
345 : { 16, 15, 0, GPG_ERR_NO_ERROR, "(10:abcdefghix)" },
346 : { 14, 0,14, GPG_ERR_SEXP_STRING_TOO_LONG, "(10:abcdefghi)" },
347 : { 15, 0, 1, GPG_ERR_SEXP_ZERO_PREFIX, "(010:abcdefghi)" },
348 : { 2, 0, 0, GPG_ERR_SEXP_NOT_CANONICAL, "1:"},
349 : { 4, 0, 4, GPG_ERR_SEXP_STRING_TOO_LONG, "(1:)"},
350 : { 5, 5, 0, GPG_ERR_NO_ERROR, "(1:x)"},
351 : { 2, 2, 0, GPG_ERR_NO_ERROR, "()"},
352 : { 4, 2, 0, GPG_ERR_NO_ERROR, "()()"},
353 : { 4, 4, 0, GPG_ERR_NO_ERROR, "(())"},
354 : { 3, 0, 3, GPG_ERR_SEXP_STRING_TOO_LONG, "(()"},
355 : { 3, 0, 1, GPG_ERR_SEXP_BAD_CHARACTER, "( )"},
356 : { 9, 9, 0, GPG_ERR_NO_ERROR, "(3:abc())"},
357 : { 10, 0, 6, GPG_ERR_SEXP_BAD_CHARACTER, "(3:abc ())"},
358 : /* fixme: we need much more cases */
359 : { 0 },
360 : };
361 : int idx;
362 : gcry_error_t errcode;
363 : size_t n, erroff;
364 :
365 1 : info ("checking canoncial length test function\n");
366 15 : for (idx=0; values[idx].text; idx++)
367 : {
368 14 : n = gcry_sexp_canon_len ((const unsigned char*)values[idx].text,
369 : values[idx].textlen,
370 : &erroff, &errcode);
371 :
372 14 : if (n && n == values[idx].expected)
373 : ; /* success */
374 7 : else if (!n && !values[idx].expected)
375 : { /* we expected an error - check that this is the right one */
376 7 : if (values[idx].erroff != erroff)
377 0 : fail ("canonical length test %d - wrong error offset %u\n",
378 : idx, (unsigned int)erroff);
379 14 : if (gcry_err_code (errcode) != values[idx].errcode)
380 0 : fail ("canonical length test %d - wrong error code %d\n",
381 : idx, errcode);
382 : }
383 : else
384 0 : fail ("canonical length test %d failed - n=%u, off=%u, err=%d\n",
385 : idx, (unsigned int)n, (unsigned int)erroff, errcode);
386 : }
387 1 : }
388 :
389 :
390 : /* Compare SE to the canonical formatted expression in
391 : * (CANON,CANONLEN). This is done by a converting SE to canonical
392 : * format and doing a byte compare. Returns 0 if they match. */
393 : static int
394 10 : compare_to_canon (gcry_sexp_t se, const unsigned char *canon, size_t canonlen)
395 : {
396 : size_t n, n1;
397 : char *p1;
398 :
399 10 : n1 = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, NULL, 0);
400 10 : if (!n1)
401 : {
402 0 : fail ("get required length in compare_to_canon failed\n");
403 0 : return -1;
404 : }
405 10 : p1 = gcry_xmalloc (n1);
406 10 : n = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, p1, n1);
407 10 : if (n1 != n+1)
408 : {
409 0 : fail ("length mismatch in compare_to_canon detected\n");
410 0 : xfree (p1);
411 0 : return -1;
412 : }
413 10 : if (n1 != canonlen || memcmp (p1, canon, canonlen))
414 : {
415 0 : xfree (p1);
416 0 : return -1;
417 : }
418 10 : xfree (p1);
419 10 : return 0;
420 : }
421 :
422 :
423 : static void
424 10 : back_and_forth_one (int testno, const char *buffer, size_t length)
425 : {
426 : gcry_error_t rc;
427 : gcry_sexp_t se, se1;
428 : unsigned char *canon;
429 : size_t canonlen; /* Including the hidden nul suffix. */
430 : size_t n, n1;
431 : char *p1;
432 :
433 10 : rc = gcry_sexp_new (&se, buffer, length, 1);
434 10 : if (rc)
435 : {
436 0 : fail ("baf %d: gcry_sexp_new failed: %s\n", testno, gpg_strerror (rc));
437 0 : return;
438 : }
439 10 : n1 = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, NULL, 0);
440 10 : if (!n1)
441 : {
442 0 : fail ("baf %d: get required length for canon failed\n", testno);
443 0 : return;
444 : }
445 10 : p1 = gcry_xmalloc (n1);
446 10 : n = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, p1, n1);
447 10 : if (n1 != n+1) /* sprints adds an extra 0 but does not return it. */
448 : {
449 0 : fail ("baf %d: length mismatch for canon\n", testno);
450 0 : return;
451 : }
452 10 : canonlen = n1;
453 10 : canon = gcry_malloc (canonlen);
454 10 : memcpy (canon, p1, canonlen);
455 10 : rc = gcry_sexp_create (&se1, p1, n, 0, gcry_free);
456 10 : if (rc)
457 : {
458 0 : fail ("baf %d: gcry_sexp_create failed: %s\n",
459 : testno, gpg_strerror (rc));
460 0 : return;
461 : }
462 10 : gcry_sexp_release (se1);
463 :
464 : /* Again but with memory checking. */
465 10 : p1 = gcry_xmalloc (n1+2);
466 10 : *p1 = '\x55';
467 10 : p1[n1+1] = '\xaa';
468 10 : n = gcry_sexp_sprint (se, GCRYSEXP_FMT_CANON, p1+1, n1);
469 10 : if (n1 != n+1) /* sprints adds an extra 0 but does not return it */
470 : {
471 0 : fail ("baf %d: length mismatch for canon\n", testno);
472 0 : return;
473 : }
474 10 : if (*p1 != '\x55' || p1[n1+1] != '\xaa')
475 0 : fail ("baf %d: memory corrupted (1)\n", testno);
476 10 : rc = gcry_sexp_create (&se1, p1+1, n, 0, NULL);
477 10 : if (rc)
478 : {
479 0 : fail ("baf %d: gcry_sexp_create failed: %s\n",
480 : testno, gpg_strerror (rc));
481 0 : return;
482 : }
483 10 : if (*p1 != '\x55' || p1[n1+1] != '\xaa')
484 0 : fail ("baf %d: memory corrupted (2)\n", testno);
485 10 : gcry_sexp_release (se1);
486 10 : if (*p1 != '\x55' || p1[n1+1] != '\xaa')
487 0 : fail ("baf %d: memory corrupted (3)\n", testno);
488 10 : gcry_free (p1);
489 :
490 : /* Check converting to advanced format. */
491 10 : n1 = gcry_sexp_sprint (se, GCRYSEXP_FMT_ADVANCED, NULL, 0);
492 10 : if (!n1)
493 : {
494 0 : fail ("baf %d: get required length for advanced failed\n", testno);
495 0 : return;
496 : }
497 10 : p1 = gcry_xmalloc (n1);
498 10 : n = gcry_sexp_sprint (se, GCRYSEXP_FMT_ADVANCED, p1, n1);
499 10 : if (n1 != n+1) /* sprints adds an extra 0 but does not return it */
500 : {
501 0 : fail ("baf %d: length mismatch for advanced\n", testno);
502 0 : return;
503 : }
504 10 : rc = gcry_sexp_create (&se1, p1, n, 0, gcry_free);
505 10 : if (rc)
506 : {
507 0 : fail ("baf %d: gcry_sexp_create failed: %s\n",
508 : testno, gpg_strerror (rc));
509 0 : return;
510 : }
511 10 : if (compare_to_canon (se1, canon, canonlen))
512 : {
513 0 : fail ("baf %d: converting to advanced failed: %s\n",
514 : testno, gpg_strerror (rc));
515 0 : return;
516 : }
517 10 : gcry_sexp_release (se1);
518 :
519 :
520 : /* FIXME: we need a lot more tests */
521 :
522 10 : gcry_sexp_release (se);
523 10 : xfree (canon);
524 : }
525 :
526 :
527 :
528 : static void
529 1 : back_and_forth (void)
530 : {
531 : static struct { const char *buf; int len; } tests[] = {
532 : { "(7:g34:fgh1::2:())", 0 },
533 : { "(7:g34:fgh1::2:())", 18 },
534 : {
535 : "(protected-private-key \n"
536 : " (rsa \n"
537 : " (n #00BE8A536204687149A48FF9F1715FF3530AD9A836D62102BF4065E5CF5953236DB94F1DF2FF4D525CD4CE7966DDC3C839968E8BAC2948934DF047CC65287CD79F6C23C93E55D7F9231E3942BD496DE383469977635A51ADF4AF747DB958CA02E9940DFC1DC0FC7FC755E7EB6618FEE6DA54B8A06E0CBF9D9257443F9992261435#)\n"
538 : " (e #010001#)\n"
539 : " (protected openpgp-s2k3-sha1-aes-cbc \n"
540 : " (\n"
541 : " (sha1 #C2A5673BD3882405# \"96\")\n"
542 : " #8D08AAF6A9209ED69D71EB7E64D78715#)\n"
543 : " #F7B0B535F8F8E22F4F3DA031224070303F82F9207D42952F1ACF21A4AB1C50304EBB25527992C7B265A9E9FF702826FB88759BDD55E4759E9FCA6C879538C9D043A9C60A326CB6681090BAA731289BD880A7D5774D9999F026E5E7963BFC8C0BDC9F061393CB734B4F259725C0A0A0B15BA39C39146EF6A1B3DC4DF30A22EBE09FD05AE6CB0C8C6532951A925F354F4E26A51964F5BBA50081690C421C8385C4074E9BAB9297D081B857756607EAE652415275A741C89E815558A50AC638EDC5F5030210B4395E3E1A40FF38DCCCB333A19EA88EFE7E4D51B54128C6DF27395646836679AC21B1B25C1DA6F0A7CE9F9BE078EFC7934FA9AE202CBB0AA06C20DFAF9A66FAB7E9073FBE96B9A7F25C3BA45EC3EECA65796AEE313BA148DE5314F30345B452B50B17C4D841A7F27397126E8C10BD0CE3B50A82C0425AAEE7798031671407B681F52916256F78CAF92A477AC27BCBE26DAFD1BCE386A853E2A036F8314BB2E8E5BB1F196434232EFB0288331C2AB16DBC5457CC295EB966CAC5CE73D5DA5D566E469F0EFA82F9A12B8693E0#)\n"
544 : " )\n"
545 : " )\n", 0 },
546 : { "((sha1 #8B98CBF4A9823CA7# \"2097\") #3B6FC9#)", 0 },
547 : { "((4:sha18:\x8B\x98\xCB\xF4\xA9\x82\x3C\xA7""4:2097)3:\x3B\x6F\xC9)", 0},
548 : { "((4:sha18:\x8B\x98\xCB\x22\xA9\x82\x3C\xA7""4:2097)3:\x3B\x6F\xC9)", 0},
549 : { "((sha1 #64652267686970C9# \"2097\") #3B6FC9#)", 0 },
550 : { "((4:sha18:\x64\x65\x22\x67\x68\xc3\xa4\x71""4:2097)3:\x3B\x6F\xC9)", 0},
551 : { "((sha1 \"defghäq\" \"2097\") #3B6FC9#)", 0 },
552 : { "((sha1 \"de\\\"ghäq\" \"2097\") #3B6FC9#)", 0 },
553 : { NULL, 0 }
554 : };
555 : int idx;
556 :
557 11 : for (idx=0; tests[idx].buf; idx++)
558 10 : back_and_forth_one (idx, tests[idx].buf, tests[idx].len);
559 1 : }
560 :
561 :
562 : static void
563 1 : check_sscan (void)
564 : {
565 : static struct {
566 : const char *text;
567 : gcry_error_t expected_err;
568 : } values[] = {
569 : /* Bug reported by Olivier L'Heureux 2003-10-07 */
570 : { "(7:sig-val(3:dsa"
571 : "(1:r20:\x7e\xff\xd5\xba\xc9\xc9\xa4\x9b\xd4\x26\x8b\x64"
572 : "\x06\x7a\xcf\x42\x7b\x6c\x51\xfb)"
573 : "(1:s21:\x01\x8c\x6c\x6f\x37\x1a\x8d\xfd\x5a\xb3\x2a\x3d"
574 : "\xc5\xae\x23\xed\x32\x62\x30\x62\x3e)))",
575 : GPG_ERR_NO_ERROR },
576 : { "(7:sig-val(3:dsa"
577 : "(1:r20:\x7e\xff\xd5\xba\xc9\xc9\xa4\x9b\xd4\x26\x8b\x64"
578 : "\x06\x7a\xcf\x42\x7b\x6c\x51\xfb)"
579 : "(1:s21:\x01\x8c\x6c\x6f\x37\x1a\x8d\xfd\x5a\xb3\x2a\x3d"
580 : "\xc5\xae\x23\xed\x32\x62\x30\x62\x3e))",
581 : GPG_ERR_SEXP_UNMATCHED_PAREN },
582 : { "(7:sig-val(3:dsa"
583 : "(1:r20:\x7e\xff\xd5\xba\xc9\xc9\xa4\x9b\xd4\x26\x8b\x64"
584 : "\x06\x7a\xcf\x42\x7b\x6c\x51\xfb)"
585 : "(1:s21:\x01\x8c\x6c\x6f\x37\x1a\x8d\xfd\x5a\xb3\x2a\x3d"
586 : "\xc5\xae\x23\xed\x32\x62\x30\x62\x3e))))",
587 : GPG_ERR_SEXP_UNMATCHED_PAREN },
588 : { NULL, 0 }
589 : };
590 : int idx;
591 : gcry_error_t err;
592 : gcry_sexp_t s;
593 :
594 1 : info ("checking gcry_sexp_sscan\n");
595 4 : for (idx=0; values[idx].text; idx++)
596 : {
597 3 : err = gcry_sexp_sscan (&s, NULL,
598 : values[idx].text,
599 : strlen (values[idx].text));
600 3 : if (gpg_err_code (err) != values[idx].expected_err)
601 0 : fail ("gcry_sexp_sscan test %d failed: %s\n", idx, gpg_strerror (err));
602 3 : gcry_sexp_release (s);
603 : }
604 1 : }
605 :
606 :
607 : static void
608 1 : check_extract_param (void)
609 : {
610 : /* This sample data is a real key but with some parameters of the
611 : public key modified. */
612 : static char sample1[] =
613 : "(key-data"
614 : " (public-key"
615 : " (ecc"
616 : " (curve Ed25519)"
617 : " (p #6FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED#)"
618 : " (a #EF#)"
619 : " (b #C2036CEE2B6FFE738CC740797779E89800700A4D4141D8AB75EB4DCA135978B6#)"
620 : " (g #14"
621 : " 216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A"
622 : " 6666666666666666666666666666666666666666666666666666666666666658#)"
623 : " (n #0000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED#)"
624 : " (q #20B37806015CA06B3AEB9423EE84A41D7F31AA65F4148553755206D679F8BF62#)"
625 : "))"
626 : " (private-key"
627 : " (ecc"
628 : " (curve Ed25519)"
629 : " (p #7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED#)"
630 : " (a #FF#)"
631 : " (b #D2036CEE2B6FFE738CC740797779E89800700A4D4141D8AB75EB4DCA135978B6#)"
632 : " (g #04"
633 : " 216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A"
634 : " 6666666666666666666666666666666666666666666666666666666666666658#)"
635 : " (n #1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED#)"
636 : " (q #30B37806015CA06B3AEB9423EE84A41D7F31AA65F4148553755206D679F8BF62#)"
637 : " (d #56BEA284A22F443A7AEA8CEFA24DA5055CDF1D490C94D8C568FE0802C9169276#)"
638 : ")))";
639 :
640 : static char sample1_p[] =
641 : "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED";
642 : static char sample1_px[] =
643 : "6FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED";
644 : static char sample1_a[] = "FF";
645 : static char sample1_ax[] = "EF";
646 : static char sample1_b[] =
647 : "D2036CEE2B6FFE738CC740797779E89800700A4D4141D8AB75EB4DCA135978B6";
648 : static char sample1_bx[] =
649 : "C2036CEE2B6FFE738CC740797779E89800700A4D4141D8AB75EB4DCA135978B6";
650 : static char sample1_g[] =
651 : "04"
652 : "216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A"
653 : "6666666666666666666666666666666666666666666666666666666666666658";
654 : static char sample1_gx[] =
655 : "14"
656 : "216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A"
657 : "6666666666666666666666666666666666666666666666666666666666666658";
658 : static char sample1_n[] =
659 : "1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED";
660 : static char sample1_nx[] =
661 : "0000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED";
662 : static char sample1_q[] =
663 : "30B37806015CA06B3AEB9423EE84A41D7F31AA65F4148553755206D679F8BF62";
664 : static char sample1_qx[] =
665 : "20B37806015CA06B3AEB9423EE84A41D7F31AA65F4148553755206D679F8BF62";
666 : static char sample1_d[] =
667 : "56BEA284A22F443A7AEA8CEFA24DA5055CDF1D490C94D8C568FE0802C9169276";
668 :
669 : static struct {
670 : const char *sexp_str;
671 : const char *path;
672 : const char *list;
673 : int nparam;
674 : gpg_err_code_t expected_err;
675 : const char *exp_p;
676 : const char *exp_a;
677 : const char *exp_b;
678 : const char *exp_g;
679 : const char *exp_n;
680 : const char *exp_q;
681 : const char *exp_d;
682 : } tests[] = {
683 : {
684 : sample1,
685 : NULL,
686 : "pabgnqd", 6,
687 : GPG_ERR_MISSING_VALUE,
688 : },
689 : {
690 : sample1,
691 : NULL,
692 : "pabgnq", 7,
693 : GPG_ERR_INV_ARG
694 : },
695 : {
696 : sample1,
697 : NULL,
698 : "pab'gnq", 7,
699 : GPG_ERR_SYNTAX
700 : },
701 : {
702 : sample1,
703 : NULL,
704 : "pab''gnq", 7,
705 : GPG_ERR_SYNTAX
706 : },
707 : {
708 : sample1,
709 : NULL,
710 : "pabgnqd", 7,
711 : 0,
712 : sample1_px, sample1_ax, sample1_bx, sample1_gx, sample1_nx,
713 : sample1_qx, sample1_d
714 : },
715 : {
716 : sample1,
717 : NULL,
718 : " pab\tg nq\nd ", 7,
719 : 0,
720 : sample1_px, sample1_ax, sample1_bx, sample1_gx, sample1_nx,
721 : sample1_qx, sample1_d
722 : },
723 : {
724 : sample1,
725 : NULL,
726 : "abg", 3,
727 : 0,
728 : sample1_ax, sample1_bx, sample1_gx
729 : },
730 : {
731 : sample1,
732 : NULL,
733 : "ab'g'", 3,
734 : 0,
735 : sample1_ax, sample1_bx, sample1_gx
736 : },
737 : {
738 : sample1,
739 : NULL,
740 : "x?abg", 4,
741 : 0,
742 : NULL, sample1_ax, sample1_bx, sample1_gx
743 : },
744 : {
745 : sample1,
746 : NULL,
747 : "p?abg", 4,
748 : GPG_ERR_USER_1,
749 : NULL, sample1_ax, sample1_bx, sample1_gx
750 : },
751 : {
752 : sample1,
753 : NULL,
754 : "pax?gnqd", 7,
755 : 0,
756 : sample1_px, sample1_ax, NULL, sample1_gx, sample1_nx,
757 : sample1_qx, sample1_d
758 : },
759 : {
760 : sample1,
761 : "public-key",
762 : "pabgnqd", 7,
763 : GPG_ERR_NO_OBJ, /* d is not in public key. */
764 : sample1_px, sample1_ax, sample1_bx, sample1_gx, sample1_nx,
765 : sample1_qx, sample1_d
766 : },
767 : {
768 : sample1,
769 : "private-key",
770 : "pabgnqd", 7,
771 : 0,
772 : sample1_p, sample1_a, sample1_b, sample1_g, sample1_n,
773 : sample1_q, sample1_d
774 : },
775 : {
776 : sample1,
777 : "public-key!ecc",
778 : "pabgnq", 6,
779 : 0,
780 : sample1_px, sample1_ax, sample1_bx, sample1_gx, sample1_nx,
781 : sample1_qx
782 : },
783 : {
784 : sample1,
785 : "public-key!ecc!foo",
786 : "pabgnq", 6,
787 : GPG_ERR_NOT_FOUND
788 : },
789 : {
790 : sample1,
791 : "public-key!!ecc",
792 : "pabgnq", 6,
793 : GPG_ERR_NOT_FOUND
794 : },
795 : {
796 : sample1,
797 : "private-key",
798 : "pa/bgnqd", 7,
799 : 0,
800 : sample1_p, sample1_a, sample1_b, sample1_g, sample1_n,
801 : sample1_q, sample1_d
802 : },
803 : {
804 : sample1,
805 : "private-key",
806 : "p-a+bgnqd", 7,
807 : 0,
808 : sample1_p, "-01", sample1_b, sample1_g, sample1_n,
809 : sample1_q, sample1_d
810 : },
811 : {NULL}
812 : };
813 : int idx, i;
814 : const char *paramstr;
815 : int paramidx;
816 : gpg_error_t err;
817 : gcry_sexp_t sxp;
818 : gcry_mpi_t mpis[7];
819 : gcry_buffer_t ioarray[7];
820 : char iobuffer[200];
821 :
822 1 : info ("checking gcry_sexp_extract_param\n");
823 19 : for (idx=0; tests[idx].sexp_str; idx++)
824 : {
825 18 : err = gcry_sexp_new (&sxp, tests[idx].sexp_str, 0, 1);
826 18 : if (err)
827 0 : die ("converting string to sexp failed: %s", gpg_strerror (err));
828 :
829 18 : memset (mpis, 0, sizeof mpis);
830 18 : switch (tests[idx].nparam)
831 : {
832 : case 0:
833 0 : err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
834 : NULL);
835 0 : break;
836 : case 1:
837 0 : err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
838 : mpis+0, NULL);
839 0 : break;
840 : case 2:
841 0 : err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
842 : mpis+0, mpis+1, NULL);
843 0 : break;
844 : case 3:
845 2 : err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
846 : mpis+0, mpis+1, mpis+2, NULL);
847 2 : break;
848 : case 4:
849 2 : err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
850 : mpis+0, mpis+1, mpis+2, mpis+3, NULL);
851 2 : break;
852 : case 5:
853 0 : err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
854 : mpis+0, mpis+1, mpis+2, mpis+3, mpis+4,
855 : NULL);
856 0 : break;
857 : case 6:
858 4 : err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
859 : mpis+0, mpis+1, mpis+2, mpis+3, mpis+4,
860 : mpis+5, NULL);
861 4 : break;
862 : case 7:
863 10 : err = gcry_sexp_extract_param (sxp, tests[idx].path, tests[idx].list,
864 : mpis+0, mpis+1, mpis+2, mpis+3, mpis+4,
865 : mpis+5, mpis+6, NULL);
866 10 : break;
867 : default:
868 0 : die ("test %d: internal error", idx);
869 : }
870 :
871 18 : if (tests[idx].expected_err
872 8 : && tests[idx].expected_err != GPG_ERR_USER_1)
873 : {
874 14 : if (tests[idx].expected_err != gpg_err_code (err))
875 0 : fail ("gcry_sexp_extract_param test %d failed: "
876 : "expected error '%s' - got '%s'", idx,
877 0 : gpg_strerror (tests[idx].expected_err),gpg_strerror (err));
878 :
879 : }
880 11 : else if (err)
881 : {
882 0 : fail ("gcry_sexp_extract_param test %d failed: %s",
883 : idx, gpg_strerror (err));
884 : }
885 : else /* No error - check the extracted values. */
886 : {
887 88 : for (paramidx=0; paramidx < DIM (mpis); paramidx++)
888 : {
889 77 : switch (paramidx)
890 : {
891 11 : case 0: paramstr = tests[idx].exp_p; break;
892 11 : case 1: paramstr = tests[idx].exp_a; break;
893 11 : case 2: paramstr = tests[idx].exp_b; break;
894 11 : case 3: paramstr = tests[idx].exp_g; break;
895 11 : case 4: paramstr = tests[idx].exp_n; break;
896 11 : case 5: paramstr = tests[idx].exp_q; break;
897 11 : case 6: paramstr = tests[idx].exp_d; break;
898 : default:
899 0 : die ("test %d: internal error: bad param %d",
900 : idx, paramidx);
901 : }
902 :
903 77 : if (tests[idx].expected_err == GPG_ERR_USER_1
904 7 : && mpis[paramidx] && !paramstr && paramidx == 0)
905 : ; /* Okay Special case error for param 0. */
906 76 : else if (!mpis[paramidx] && !paramstr)
907 : ; /* Okay. */
908 59 : else if (!mpis[paramidx] && paramstr)
909 0 : fail ("test %d: value for param %d expected but not returned",
910 : idx, paramidx);
911 59 : else if (mpis[paramidx] && !paramstr)
912 0 : fail ("test %d: value for param %d not expected",
913 : idx, paramidx);
914 59 : else if (cmp_mpihex (mpis[paramidx], paramstr))
915 : {
916 0 : fail ("test %d: param %d mismatch", idx, paramidx);
917 0 : gcry_log_debug ("expected: %s\n", paramstr);
918 0 : gcry_log_debugmpi (" got", mpis[paramidx]);
919 : }
920 59 : else if (tests[idx].expected_err && paramidx == 0)
921 0 : fail ("test %d: param %d: expected error '%s' - got 'Success'",
922 0 : idx, paramidx, gpg_strerror (tests[idx].expected_err));
923 : }
924 :
925 : }
926 :
927 144 : for (i=0; i < DIM (mpis); i++)
928 126 : gcry_mpi_release (mpis[i]);
929 18 : gcry_sexp_release (sxp);
930 : }
931 :
932 1 : info ("checking gcry_sexp_extract_param/desc\n");
933 :
934 1 : memset (ioarray, 0, sizeof ioarray);
935 :
936 1 : err = gcry_sexp_new (&sxp, sample1, 0, 1);
937 1 : if (err)
938 0 : die ("converting string to sexp failed: %s", gpg_strerror (err));
939 :
940 1 : ioarray[1].size = sizeof iobuffer;
941 1 : ioarray[1].data = iobuffer;
942 1 : ioarray[1].off = 0;
943 1 : ioarray[2].size = sizeof iobuffer;
944 1 : ioarray[2].data = iobuffer;
945 1 : ioarray[2].off = 50;
946 1 : assert (ioarray[2].off < sizeof iobuffer);
947 1 : err = gcry_sexp_extract_param (sxp, "key-data!private-key", "&pab",
948 : ioarray+0, ioarray+1, ioarray+2, NULL);
949 1 : if (err)
950 0 : fail ("gcry_sexp_extract_param with desc failed: %s", gpg_strerror (err));
951 : else
952 : {
953 1 : if (!ioarray[0].data)
954 0 : fail ("gcry_sexp_extract_param/desc failed: no P");
955 1 : else if (ioarray[0].size != 32)
956 0 : fail ("gcry_sexp_extract_param/desc failed: P has wrong size");
957 1 : else if (ioarray[0].len != 32)
958 0 : fail ("gcry_sexp_extract_param/desc failed: P has wrong length");
959 1 : else if (ioarray[0].off)
960 0 : fail ("gcry_sexp_extract_param/desc failed: P has OFF set");
961 1 : else if (cmp_bufhex (ioarray[0].data, ioarray[0].len, sample1_p))
962 : {
963 0 : fail ("gcry_sexp_extract_param/desc failed: P mismatch");
964 0 : gcry_log_debug ("expected: %s\n", sample1_p);
965 0 : gcry_log_debughex (" got", ioarray[0].data, ioarray[0].len);
966 : }
967 :
968 1 : if (!ioarray[1].data)
969 0 : fail ("gcry_sexp_extract_param/desc failed: A buffer lost");
970 1 : else if (ioarray[1].size != sizeof iobuffer)
971 0 : fail ("gcry_sexp_extract_param/desc failed: A size changed");
972 1 : else if (ioarray[1].off != 0)
973 0 : fail ("gcry_sexp_extract_param/desc failed: A off changed");
974 1 : else if (ioarray[1].len != 1)
975 0 : fail ("gcry_sexp_extract_param/desc failed: A has wrong length");
976 1 : else if (cmp_bufhex ((char *)ioarray[1].data + ioarray[1].off,
977 : ioarray[1].len, sample1_a))
978 : {
979 0 : fail ("gcry_sexp_extract_param/desc failed: A mismatch");
980 0 : gcry_log_debug ("expected: %s\n", sample1_a);
981 0 : gcry_log_debughex (" got",
982 0 : (char *)ioarray[1].data + ioarray[1].off,
983 : ioarray[1].len);
984 : }
985 :
986 1 : if (!ioarray[2].data)
987 0 : fail ("gcry_sexp_extract_param/desc failed: B buffer lost");
988 1 : else if (ioarray[2].size != sizeof iobuffer)
989 0 : fail ("gcry_sexp_extract_param/desc failed: B size changed");
990 1 : else if (ioarray[2].off != 50)
991 0 : fail ("gcry_sexp_extract_param/desc failed: B off changed");
992 1 : else if (ioarray[2].len != 32)
993 0 : fail ("gcry_sexp_extract_param/desc failed: B has wrong length");
994 1 : else if (cmp_bufhex ((char *)ioarray[2].data + ioarray[2].off,
995 : ioarray[2].len, sample1_b))
996 : {
997 0 : fail ("gcry_sexp_extract_param/desc failed: B mismatch");
998 0 : gcry_log_debug ("expected: %s\n", sample1_b);
999 0 : gcry_log_debughex (" got",
1000 0 : (char *)ioarray[2].data + ioarray[2].off,
1001 : ioarray[2].len);
1002 : }
1003 :
1004 1 : xfree (ioarray[0].data);
1005 : }
1006 :
1007 1 : gcry_sexp_release (sxp);
1008 :
1009 1 : info ("checking gcry_sexp_extract_param long name\n");
1010 :
1011 1 : memset (ioarray, 0, sizeof ioarray);
1012 1 : memset (mpis, 0, sizeof mpis);
1013 :
1014 1 : err = gcry_sexp_new (&sxp, sample1, 0, 1);
1015 1 : if (err)
1016 0 : die ("converting string to sexp failed: %s", gpg_strerror (err));
1017 :
1018 1 : err = gcry_sexp_extract_param (sxp, "key-data!private-key",
1019 : "&'curve'+p",
1020 : ioarray+0, mpis+0, NULL);
1021 1 : if (err)
1022 0 : fail ("gcry_sexp_extract_param long name failed: %s", gpg_strerror (err));
1023 :
1024 1 : if (!ioarray[0].data)
1025 0 : fail ("gcry_sexp_extract_param long name failed: no curve");
1026 1 : else if (ioarray[0].size != 7)
1027 0 : fail ("gcry_sexp_extract_param long name failed: curve has wrong size");
1028 1 : else if (ioarray[0].len != 7)
1029 0 : fail ("gcry_sexp_extract_param long name failed: curve has wrong length");
1030 1 : else if (ioarray[0].off)
1031 0 : fail ("gcry_sexp_extract_param long name failed: curve has OFF set");
1032 1 : else if (strncmp (ioarray[0].data, "Ed25519", 7))
1033 : {
1034 0 : fail ("gcry_sexp_extract_param long name failed: curve mismatch");
1035 0 : gcry_log_debug ("expected: %s\n", "Ed25519");
1036 0 : gcry_log_debug (" got: %.*s\n",
1037 0 : (int)ioarray[0].len, (char*)ioarray[0].data);
1038 : }
1039 :
1040 1 : if (!mpis[0])
1041 0 : fail ("gcry_sexp_extract_param long name failed: p not returned");
1042 1 : else if (cmp_mpihex (mpis[0], sample1_p))
1043 : {
1044 0 : fail ("gcry_sexp_extract_param long name failed: p mismatch");
1045 0 : gcry_log_debug ("expected: %s\n", sample1_p);
1046 0 : gcry_log_debugmpi (" got", mpis[0]);
1047 : }
1048 :
1049 1 : gcry_free (ioarray[0].data);
1050 1 : gcry_mpi_release (mpis[0]);
1051 :
1052 1 : gcry_sexp_release (sxp);
1053 :
1054 1 : }
1055 :
1056 :
1057 : /* A test based on bug 1594. */
1058 : static void
1059 1 : bug_1594 (void)
1060 : {
1061 : static char thing[] =
1062 : "(signature"
1063 : " (public-key"
1064 : " (rsa"
1065 : " (n #00A53A6B3A50BE571F805BD98ECE1FCE4CE291C3D4D3E971740E1EE6D447F526"
1066 : " 6AC8973DDC82F0ADD234CC82E0A0A3F48B81ACC8B038DB8ACC3E78DC2ED2642F"
1067 : " 6BA353FCA60F47C2801DEB477B37FB8B2F5508AA1C6D922780DB142DEA19B812"
1068 : " C4E64F1138AD3BD61C58DB2D2591BE0BF36A1AC588AA45763BCDFF581050ABA8"
1069 : " CA47BD9723ADD6A308AE28471EDD2B16D03C941D4F2B7E019C43AF8972880633"
1070 : " 54E97B7E19F1677D84B69A26B184A77B719DD72C48E0EE36107046F786566A9D"
1071 : " 13BAD724D6D78F24700FC22FC000E1B2A8C1B08ED62008395B0764CD9B55E80D"
1072 : " A0A2B61C698DC27EA98E68BB576ACFC2B91B4D7283E7D960948D049D6E3C4CB1"
1073 : " F489B460A120A4BB6C04A843FD3A67454136DE61CF68A927871EFFA9141BD372"
1074 : " A748593C703E0301F039A9E674C50301BFC385BABE5B154250E7D57B82DB31F1"
1075 : " E1AC696F870DCD8FE8DEC75608B988FCA3B484F1FD7755BF452F99597269AF02"
1076 : " E8AF87D0F93DB427291659183D077254C835BFB6DDFD87CD0B5E0738682FCD34"
1077 : " 923F22551F73944E6CBE3ED6879B4414676B5DA0F30ED21DFA12BD2230C3C5D2"
1078 : " EA116A3EFEB4AEC21C58E63FAFA549A63190F01859445E9B80F427B80FD4C884"
1079 : " 2AD41FE760A3E9DEDFB56CEBE8EA783838B2B392CACDDC760CCE212E388AFBC1"
1080 : " 95DC6D0ED87E9091F82A82CE372738C8DE8ABD76ACD06AC8B80AA0597162DF59"
1081 : " 67#)"
1082 : " (e #010001#))))";
1083 : gcry_sexp_t sig, pubkey, n, n_val;
1084 :
1085 1 : info ("checking fix for bug 1594\n");
1086 :
1087 1 : if (gcry_sexp_new (&sig, thing, 0, 1))
1088 0 : die ("scanning fixed string failed\n");
1089 1 : pubkey = gcry_sexp_find_token (sig, "public-key", 0);
1090 1 : gcry_sexp_release (sig);
1091 1 : if (!pubkey)
1092 : {
1093 0 : fail ("'public-key' token not found");
1094 0 : return;
1095 : }
1096 1 : n = gcry_sexp_find_token (pubkey, "n", 0);
1097 1 : if (!n)
1098 : {
1099 0 : fail ("'n' token not found");
1100 0 : gcry_sexp_release (pubkey);
1101 0 : return;
1102 : }
1103 1 : n_val = gcry_sexp_nth (n, 1);
1104 : /* Bug 1594 would require the following test:
1105 : * if (n_val)
1106 : * fail ("extracting 1-th of 'n' list did not fail");
1107 : * However, we meanwhile modified the S-expression functions to
1108 : * behave like Scheme to allow the access of any element of a list.
1109 : */
1110 1 : if (!n_val)
1111 0 : fail ("extracting 1-th of 'n' list failed");
1112 : /*gcry_log_debugsxp ("1-th", n_val); => "(#00A5...#)" */
1113 1 : gcry_sexp_release (n_val);
1114 1 : n_val = gcry_sexp_nth (n, 2);
1115 1 : if (n_val)
1116 0 : fail ("extracting 2-th of 'n' list did not fail");
1117 1 : n_val = gcry_sexp_nth (n, 0);
1118 1 : if (!n_val)
1119 0 : fail ("extracting 0-th of 'n' list failed");
1120 : /*gcry_log_debugsxp ("0-th", n_val); => "(n)" */
1121 1 : if (gcry_sexp_nth (n_val, 1))
1122 0 : fail ("extracting 1-th of car of 'n' list did not fail");
1123 1 : gcry_sexp_release (n_val);
1124 1 : gcry_sexp_release (n);
1125 1 : gcry_sexp_release (pubkey);
1126 : }
1127 :
1128 :
1129 : int
1130 1 : main (int argc, char **argv)
1131 : {
1132 1 : int last_argc = -1;
1133 :
1134 1 : if (argc)
1135 : {
1136 1 : argc--; argv++;
1137 : }
1138 2 : while (argc && last_argc != argc )
1139 : {
1140 0 : last_argc = argc;
1141 0 : if (!strcmp (*argv, "--"))
1142 : {
1143 0 : argc--; argv++;
1144 0 : break;
1145 : }
1146 0 : else if (!strcmp (*argv, "--help"))
1147 : {
1148 0 : puts (
1149 : "usage: " PGMNAME " [options]\n"
1150 : "\n"
1151 : "Options:\n"
1152 : " --verbose Show what is going on\n"
1153 : " --debug Flyswatter\n"
1154 : );
1155 0 : exit (0);
1156 : }
1157 0 : else if (!strcmp (*argv, "--verbose"))
1158 : {
1159 0 : verbose = 1;
1160 0 : argc--; argv++;
1161 : }
1162 0 : else if (!strcmp (*argv, "--debug"))
1163 : {
1164 0 : verbose = debug = 1;
1165 0 : argc--; argv++;
1166 : }
1167 0 : else if (!strncmp (*argv, "--", 2))
1168 0 : die ("unknown option '%s'", *argv);
1169 : }
1170 :
1171 1 : if (debug)
1172 0 : gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
1173 1 : gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
1174 1 : gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
1175 1 : if (!gcry_check_version (GCRYPT_VERSION))
1176 0 : die ("version mismatch");
1177 : /* #include "../src/gcrypt-int.h" indicates that internal interfaces
1178 : may be used; thus better do an exact version check. */
1179 1 : if (strcmp (gcry_check_version (NULL), GCRYPT_VERSION))
1180 0 : die ("exact version match failed");
1181 1 : gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1182 1 : gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
1183 :
1184 1 : basic ();
1185 1 : canon_len ();
1186 1 : back_and_forth ();
1187 1 : check_sscan ();
1188 1 : check_extract_param ();
1189 1 : bug_1594 ();
1190 :
1191 1 : return errorcount? 1:0;
1192 : }
|
