Line data Source code
1 : /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2 : /* test-asn1.c: Test ASN1 stuf
3 :
4 : Copyright (C) 2009 Stefan Walter
5 :
6 : The Gnome Keyring Library is free software; you can redistribute it and/or
7 : modify it under the terms of the GNU Library 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 : The Gnome Keyring Library 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 GNU
14 : Library General Public License for more details.
15 :
16 : You should have received a copy of the GNU Library General Public
17 : License along with the Gnome Library; see the file COPYING.LIB. If not,
18 : <http://www.gnu.org/licenses/>.
19 :
20 : Author: Stef Walter <stef@memberwebs.com>
21 : */
22 :
23 : #include "config.h"
24 :
25 : #include "egg/egg-asn1x.h"
26 : #include "egg/egg-asn1-defs.h"
27 : #include "egg/egg-testing.h"
28 :
29 : #include <glib.h>
30 :
31 : #include <stdlib.h>
32 : #include <stdio.h>
33 : #include <string.h>
34 :
35 : typedef struct _EggAsn1xDef ASN1_ARRAY_TYPE;
36 : typedef struct _EggAsn1xDef asn1_static_node;
37 : #include "test.asn.h"
38 :
39 : const gchar I33[] = "\x02\x01\x2A";
40 : const gchar I253[] = "\x02\x02\x00\xFD";
41 : const gchar BFALSE[] = "\x01\x01\x00";
42 : const gchar BTRUE[] = "\x01\x01\xFF";
43 : const gchar SFARNSWORTH[] = "\x04\x0A""farnsworth";
44 : const gchar SIMPLICIT[] = "\x85\x08""implicit";
45 : const gchar SEXPLICIT[] = "\xA5\x0A\x04\x08""explicit";
46 : const gchar SUNIVERSAL[] = "\x05\x09""universal";
47 : const gchar TGENERALIZED[] = "\x18\x0F""20070725130528Z";
48 : const gchar BITS_TEST[] = "\x03\x04\x06\x6e\x5d\xc0";
49 : const gchar BITS_BAD[] = "\x03\x04\x06\x6e\x5d\xc1";
50 : const gchar BITS_ZERO[] = "\x03\x01\x00";
51 : const gchar NULL_TEST[] = "\x05\x00";
52 :
53 : /* ENUM with value = 2 */
54 : const gchar ENUM_TWO[] = "\x0A\x01\x02";
55 :
56 : /* ENUM with value = 3 */
57 : const gchar ENUM_THREE[] = "\x0A\x01\x03";
58 :
59 : #define XL(x) G_N_ELEMENTS (x) - 1
60 :
61 : static void
62 1 : test_boolean (void)
63 : {
64 : GBytes *bytes;
65 : GNode *asn;
66 : gboolean value;
67 :
68 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBoolean");
69 1 : g_assert (asn);
70 :
71 1 : g_assert_cmpint (EGG_ASN1X_BOOLEAN, ==, egg_asn1x_type (asn));
72 :
73 : /* Shouldn't succeed */
74 1 : if (egg_asn1x_get_boolean (asn, &value))
75 0 : g_assert_not_reached ();
76 :
77 : /* Decode a false */
78 1 : bytes = g_bytes_new_static (BFALSE, XL (BFALSE));
79 1 : if (!egg_asn1x_decode (asn, bytes))
80 0 : g_assert_not_reached ();
81 1 : value = TRUE;
82 1 : if (!egg_asn1x_get_boolean (asn, &value))
83 0 : g_assert_not_reached ();
84 1 : g_assert (value == FALSE);
85 1 : g_bytes_unref (bytes);
86 :
87 : /* Decode a true */
88 1 : bytes = g_bytes_new_static (BTRUE, XL (BTRUE));
89 1 : if (!egg_asn1x_decode (asn, bytes))
90 0 : g_assert_not_reached ();
91 1 : value = FALSE;
92 1 : if (!egg_asn1x_get_boolean (asn, &value))
93 0 : g_assert_not_reached ();
94 1 : g_assert (value == TRUE);
95 1 : g_bytes_unref (bytes);
96 :
97 1 : egg_asn1x_clear (asn);
98 :
99 : /* Shouldn't suceed after clear */
100 1 : if (egg_asn1x_get_boolean (asn, &value))
101 0 : g_assert_not_reached ();
102 :
103 1 : egg_asn1x_destroy (asn);
104 1 : }
105 :
106 : static void
107 1 : test_boolean_decode_bad (void)
108 : {
109 1 : const gchar BOOLEAN_INVALID_LENGTH[] = "\x01\x02\x00\x00";
110 1 : const gchar BOOLEAN_BAD_VALUE[] = "\x01\x01\x05";
111 :
112 : GBytes *bytes;
113 : GNode *asn;
114 : gboolean ret;
115 :
116 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBoolean");
117 1 : g_assert (asn != NULL);
118 :
119 1 : bytes = g_bytes_new_static (BOOLEAN_INVALID_LENGTH, XL (BOOLEAN_INVALID_LENGTH));
120 1 : ret = egg_asn1x_decode (asn, bytes);
121 1 : g_assert (ret == FALSE);
122 1 : g_assert (strstr (egg_asn1x_message (asn), "invalid length boolean") != NULL);
123 1 : g_bytes_unref (bytes);
124 :
125 1 : bytes = g_bytes_new_static (BOOLEAN_BAD_VALUE, XL (BOOLEAN_BAD_VALUE));
126 1 : ret = egg_asn1x_decode (asn, bytes);
127 1 : g_assert (ret == FALSE);
128 1 : g_assert (strstr (egg_asn1x_message (asn), "boolean must be true or false") != NULL);
129 1 : g_bytes_unref (bytes);
130 :
131 1 : egg_asn1x_destroy (asn);
132 1 : }
133 :
134 : static void
135 1 : test_boolean_default (void)
136 : {
137 : GNode *asn;
138 : GBytes *bytes;
139 :
140 1 : const gchar BOOLEAN[] = "\x30\x00";
141 :
142 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBooleanDefault");
143 : /* This is equal to the default value, and shouldn't be included */
144 1 : egg_asn1x_set_boolean (egg_asn1x_node (asn, "boolean", NULL), TRUE);
145 :
146 1 : bytes = egg_asn1x_encode (asn, NULL);
147 1 : egg_asn1x_assert (bytes != NULL, asn);
148 1 : egg_assert_cmpbytes (bytes, ==, BOOLEAN, XL (BOOLEAN));
149 1 : g_bytes_unref (bytes);
150 :
151 1 : egg_asn1x_destroy (asn);
152 1 : }
153 :
154 : static void
155 1 : test_null (void)
156 : {
157 : GNode *asn;
158 : GBytes *data;
159 :
160 1 : asn = egg_asn1x_create (test_asn1_tab, "TestNull");
161 1 : g_assert (asn);
162 :
163 1 : g_assert_cmpint (EGG_ASN1X_NULL, ==, egg_asn1x_type (asn));
164 :
165 1 : egg_asn1x_set_null (asn);
166 :
167 1 : data = egg_asn1x_encode (asn, g_realloc);
168 1 : egg_assert_cmpmem (NULL_TEST, XL (NULL_TEST), ==, g_bytes_get_data (data, NULL), g_bytes_get_size (data));
169 :
170 1 : if (!egg_asn1x_decode (asn, data))
171 0 : g_assert_not_reached ();
172 :
173 1 : egg_asn1x_destroy (asn);
174 1 : g_bytes_unref (data);
175 1 : }
176 :
177 : static void
178 1 : test_integer (void)
179 : {
180 : GNode *asn;
181 : gulong value;
182 : GBytes *bytes;
183 :
184 1 : asn = egg_asn1x_create (test_asn1_tab, "TestInteger");
185 1 : g_assert (asn);
186 :
187 1 : g_assert_cmpint (EGG_ASN1X_INTEGER, ==, egg_asn1x_type (asn));
188 :
189 : /* Shouldn't succeed */
190 1 : if (egg_asn1x_get_integer_as_ulong (asn, &value))
191 0 : g_assert_not_reached ();
192 :
193 : /* Should suceed now */
194 1 : bytes = g_bytes_new_static (I33, XL (I33));
195 1 : if (!egg_asn1x_decode (asn, bytes))
196 0 : g_assert_not_reached ();
197 1 : if (!egg_asn1x_get_integer_as_ulong (asn, &value))
198 0 : g_assert_not_reached ();
199 1 : g_assert (value == 42);
200 1 : g_bytes_unref (bytes);
201 :
202 1 : egg_asn1x_clear (asn);
203 :
204 : /* Shouldn't suceed after clear */
205 1 : if (egg_asn1x_get_integer_as_ulong (asn, &value))
206 0 : g_assert_not_reached ();
207 :
208 1 : egg_asn1x_destroy (asn);
209 1 : }
210 :
211 : static void
212 1 : test_integer_zero_length (void)
213 : {
214 1 : const gchar INTEGER_EMPTY[] = "\x02\x00";
215 :
216 : GBytes *bytes;
217 : GNode *asn;
218 : gboolean ret;
219 :
220 1 : asn = egg_asn1x_create (test_asn1_tab, "TestInteger");
221 1 : g_assert (asn != NULL);
222 :
223 1 : bytes = g_bytes_new_static (INTEGER_EMPTY, XL (INTEGER_EMPTY));
224 1 : ret = egg_asn1x_decode (asn, bytes);
225 1 : g_assert (ret == FALSE);
226 1 : g_assert (strstr (egg_asn1x_message (asn), "zero length integer") != NULL);
227 1 : g_bytes_unref (bytes);
228 :
229 1 : egg_asn1x_destroy (asn);
230 1 : }
231 :
232 : static void
233 1 : test_unsigned (void)
234 : {
235 : GNode *asn;
236 : gulong value;
237 : GBytes *check;
238 : guchar val;
239 : GBytes *bytes;
240 : GBytes *usg;
241 :
242 1 : asn = egg_asn1x_create (test_asn1_tab, "TestInteger");
243 1 : g_assert (asn);
244 :
245 1 : g_assert_cmpint (EGG_ASN1X_INTEGER, ==, egg_asn1x_type (asn));
246 :
247 : /* Check with ulong */
248 1 : bytes = g_bytes_new_static (I253, XL (I253));
249 1 : if (!egg_asn1x_decode (asn, bytes))
250 0 : g_assert_not_reached ();
251 1 : if (!egg_asn1x_get_integer_as_ulong (asn, &value))
252 0 : g_assert_not_reached ();
253 1 : g_assert (value == 253);
254 1 : g_bytes_unref (bytes);
255 :
256 1 : egg_asn1x_clear (asn);
257 :
258 1 : egg_asn1x_set_integer_as_ulong (asn, 253);
259 :
260 1 : check = egg_asn1x_encode (asn, NULL);
261 1 : egg_assert_cmpmem (I253, XL (I253), ==, g_bytes_get_data (check, NULL), g_bytes_get_size (check));
262 1 : g_bytes_unref (check);
263 :
264 : /* Now check with usg */
265 1 : bytes = g_bytes_new_static (I253, XL (I253));
266 1 : if (!egg_asn1x_decode (asn, bytes))
267 0 : g_assert_not_reached ();
268 1 : g_bytes_unref (bytes);
269 :
270 1 : val = 0xFD; /* == 253 */
271 1 : usg = egg_asn1x_get_integer_as_usg (asn);
272 1 : egg_assert_cmpmem (&val, 1, ==, g_bytes_get_data (usg, NULL), g_bytes_get_size (usg));
273 1 : g_bytes_unref (usg);
274 :
275 1 : egg_asn1x_clear (asn);
276 :
277 1 : egg_asn1x_take_integer_as_usg (asn, g_bytes_new_static (&val, 1));
278 :
279 1 : check = egg_asn1x_encode (asn, NULL);
280 1 : egg_assert_cmpsize (g_bytes_get_size (check), ==, XL (I253));
281 1 : egg_assert_cmpmem (I253, XL (I253), ==, g_bytes_get_data (check, NULL), g_bytes_get_size (check));
282 1 : g_bytes_unref (check);
283 :
284 1 : egg_asn1x_destroy (asn);
285 1 : }
286 :
287 : static void
288 1 : test_unsigned_not_set (void)
289 : {
290 : GNode *asn;
291 : GBytes *bytes;
292 :
293 1 : asn = egg_asn1x_create (test_asn1_tab, "TestInteger");
294 1 : g_assert (asn);
295 :
296 1 : bytes = egg_asn1x_get_integer_as_usg (asn);
297 1 : g_assert (bytes == NULL);
298 :
299 1 : egg_asn1x_destroy (asn);
300 1 : }
301 :
302 : static void
303 1 : test_unsigned_default (void)
304 : {
305 : GNode *asn;
306 : GBytes *bytes;
307 :
308 1 : const gchar INTEGERS[] = "\x30\x06\x02\x01\x01\x02\x01\x02";
309 :
310 1 : asn = egg_asn1x_create (test_asn1_tab, "TestIntegers");
311 1 : egg_asn1x_set_integer_as_ulong (egg_asn1x_node (asn, "uint1", NULL), 1);
312 1 : egg_asn1x_set_integer_as_ulong (egg_asn1x_node (asn, "uint2", NULL), 2);
313 : /* This is equal to the default value, and shouldn't be included */
314 1 : egg_asn1x_set_integer_as_ulong (egg_asn1x_node (asn, "uint3", NULL), 8888);
315 :
316 1 : bytes = egg_asn1x_encode (asn, NULL);
317 1 : egg_assert_cmpbytes (bytes, ==, INTEGERS, XL (INTEGERS));
318 1 : g_bytes_unref (bytes);
319 :
320 1 : egg_asn1x_destroy (asn);
321 1 : }
322 :
323 : static void
324 1 : test_unsigned_constant (void)
325 : {
326 : gulong value;
327 : GNode *asn;
328 :
329 : /* const gchar SEQ[] = "\x30\x00"; */
330 :
331 1 : asn = egg_asn1x_create (test_asn1_tab, "TestConstant");
332 1 : if (!egg_asn1x_get_integer_as_ulong (egg_asn1x_node (asn, "version", NULL), &value))
333 0 : g_assert_not_reached ();
334 1 : g_assert_cmpint (value, ==, 3);
335 :
336 1 : egg_asn1x_destroy (asn);
337 1 : }
338 :
339 : static void
340 1 : test_unsigned_zero (void)
341 : {
342 : GBytes *bytes;
343 : GNode *asn;
344 :
345 1 : const gchar DER[] = "\x02\x01\x00";
346 :
347 : /* No bits set in 0 but should still be 1 byte */
348 1 : asn = egg_asn1x_create (test_asn1_tab, "TestInteger");
349 1 : egg_asn1x_set_integer_as_ulong (asn, 0);
350 :
351 1 : bytes = egg_asn1x_encode (asn, NULL);
352 1 : egg_asn1x_assert (bytes != NULL, asn);
353 1 : egg_assert_cmpbytes (bytes, ==, DER, XL (DER));
354 1 : g_bytes_unref (bytes);
355 :
356 1 : egg_asn1x_destroy (asn);
357 1 : }
358 :
359 : static void
360 1 : test_integer_raw (void)
361 : {
362 : GNode *asn;
363 : GBytes *bytes;
364 :
365 1 : asn = egg_asn1x_create (test_asn1_tab, "TestInteger");
366 1 : g_assert (asn != NULL);
367 :
368 1 : bytes = g_bytes_new_static ("\x01\x02\x03", 3);
369 1 : egg_asn1x_set_integer_as_raw (asn, bytes);
370 1 : g_bytes_unref (bytes);
371 :
372 1 : bytes = egg_asn1x_encode (asn, NULL);
373 1 : egg_assert_cmpbytes (bytes, ==, "\x02\x03\x01\x02\x03", 5);
374 1 : g_bytes_unref (bytes);
375 :
376 1 : bytes = egg_asn1x_get_integer_as_raw (asn);
377 1 : egg_assert_cmpbytes (bytes, ==, "\x01\x02\x03", 3);
378 1 : g_bytes_unref (bytes);
379 :
380 1 : egg_asn1x_destroy (asn);
381 1 : }
382 :
383 : static void
384 1 : test_integer_raw_not_twos_complement (void)
385 : {
386 : /* Ugh ... g_test_trap_subprocess */
387 1 : g_test_trap_subprocess ("/asn1/integer/raw-not-twos-complement/subprocess", 0,
388 : G_TEST_SUBPROCESS_INHERIT_STDOUT);
389 1 : g_test_trap_assert_failed ();
390 1 : g_test_trap_assert_stderr ("*not two's complement*");
391 1 : }
392 :
393 : static void
394 0 : test_integer_raw_not_twos_complement_subprocess (void)
395 : {
396 : GNode *asn;
397 : GBytes *bytes;
398 :
399 0 : asn = egg_asn1x_create (test_asn1_tab, "TestInteger");
400 0 : g_assert (asn != NULL);
401 :
402 0 : bytes = g_bytes_new_static ("\x81\x02\x03", 3);
403 :
404 0 : egg_asn1x_set_integer_as_raw (asn, bytes); /* UNREACHABLE: */
405 0 : g_bytes_unref (bytes);
406 0 : egg_asn1x_destroy (asn);
407 0 : }
408 :
409 : static void
410 1 : test_octet_string (void)
411 : {
412 : GNode *asn;
413 : gchar *value;
414 : GBytes *bytes;
415 :
416 1 : asn = egg_asn1x_create (test_asn1_tab, "TestOctetString");
417 1 : g_assert (asn);
418 :
419 1 : g_assert_cmpint (EGG_ASN1X_OCTET_STRING, ==, egg_asn1x_type (asn));
420 :
421 : /* Shouldn't succeed */
422 1 : if (egg_asn1x_get_string_as_utf8 (asn, NULL))
423 0 : g_assert_not_reached ();
424 :
425 : /* Should work */
426 1 : bytes = g_bytes_new_static (SFARNSWORTH, XL (SFARNSWORTH));
427 1 : if (!egg_asn1x_decode (asn, bytes))
428 0 : g_assert_not_reached ();
429 1 : g_bytes_unref (bytes);
430 :
431 1 : value = egg_asn1x_get_string_as_utf8 (asn, NULL);
432 1 : g_assert_cmpstr (value, ==, "farnsworth");
433 1 : g_free (value);
434 :
435 1 : egg_asn1x_clear (asn);
436 :
437 : /* Shouldn't succeed */
438 1 : if (egg_asn1x_get_string_as_utf8 (asn, NULL))
439 0 : g_assert_not_reached ();
440 :
441 1 : egg_asn1x_destroy (asn);
442 1 : }
443 :
444 : static void
445 1 : test_octet_string_set_bad_utf8 (void)
446 : {
447 : GNode *asn;
448 :
449 1 : asn = egg_asn1x_create (test_asn1_tab, "TestOctetString");
450 1 : g_assert (asn);
451 :
452 1 : if (egg_asn1x_set_string_as_utf8 (asn, "\xFF\xFA", NULL))
453 0 : g_assert_not_reached ();
454 :
455 : /* Shouldn't succeed */
456 1 : if (egg_asn1x_get_string_as_utf8 (asn, NULL))
457 0 : g_assert_not_reached ();
458 :
459 1 : egg_asn1x_destroy (asn);
460 1 : }
461 :
462 : static void
463 1 : test_octet_string_bmp_as_utf8 (void)
464 : {
465 : GBytes *bytes;
466 : GNode *asn;
467 : gchar *data;
468 :
469 1 : const gchar SFUER[] = "\x04\x06""\x00\x46\x00\xfc\x00\x72";
470 :
471 1 : bytes = g_bytes_new_static (SFUER, XL (SFUER));
472 1 : asn = egg_asn1x_create_and_decode (test_asn1_tab, "TestOctetString", bytes);
473 1 : g_assert (asn != NULL);
474 1 : g_bytes_unref (bytes);
475 :
476 1 : data = egg_asn1x_get_bmpstring_as_utf8 (asn);
477 1 : g_assert_cmpstr (data, ==, "F\303\274r");
478 :
479 1 : g_free (data);
480 1 : egg_asn1x_destroy (asn);
481 1 : }
482 :
483 : static void
484 1 : test_octet_string_get_as_bytes (void)
485 : {
486 : GBytes *bytes;
487 : GNode *asn;
488 :
489 1 : bytes = g_bytes_new_static (SFARNSWORTH, XL (SFARNSWORTH));
490 1 : asn = egg_asn1x_create_and_decode (test_asn1_tab, "TestOctetString", bytes);
491 1 : g_assert (asn != NULL);
492 1 : g_bytes_unref (bytes);
493 :
494 1 : bytes = egg_asn1x_get_string_as_bytes (asn);
495 1 : g_assert (bytes != NULL);
496 1 : egg_assert_cmpbytes (bytes, ==, "farnsworth", 10);
497 1 : g_bytes_unref (bytes);
498 :
499 1 : egg_asn1x_destroy (asn);
500 1 : }
501 :
502 : static void
503 1 : test_octet_string_set_as_bytes (void)
504 : {
505 : GBytes *bytes;
506 : GNode *asn;
507 :
508 1 : asn = egg_asn1x_create (test_asn1_tab, "TestOctetString");
509 1 : g_assert (asn != NULL);
510 :
511 1 : bytes = g_bytes_new_static ("farnsworth", 10);
512 1 : egg_asn1x_set_string_as_bytes (asn, bytes);
513 1 : g_bytes_unref (bytes);
514 :
515 1 : bytes = egg_asn1x_encode (asn, NULL);
516 1 : g_assert (bytes != NULL);
517 1 : egg_assert_cmpbytes (bytes, ==, SFARNSWORTH, XL (SFARNSWORTH));
518 1 : g_bytes_unref (bytes);
519 :
520 1 : egg_asn1x_destroy (asn);
521 1 : }
522 :
523 : static void
524 1 : test_octet_string_structured (void)
525 : {
526 : GBytes *bytes;
527 : GNode *asn;
528 : guchar *string;
529 1 : gsize n_string = 0;
530 :
531 1 : const gchar STRUCTURED[] = "\x24\x0c"
532 : "\x04\x04""blah"
533 : "\x04\x04""blah";
534 :
535 1 : bytes = g_bytes_new_static (STRUCTURED, XL (STRUCTURED));
536 1 : asn = egg_asn1x_create_and_decode (test_asn1_tab, "TestOctetString", bytes);
537 1 : g_bytes_unref (bytes);
538 :
539 1 : string = egg_asn1x_get_string_as_raw (asn, NULL, &n_string);
540 1 : g_assert_cmpstr ((gchar *)string, ==, "blahblah");
541 1 : g_assert_cmpint (n_string, ==, 8);
542 1 : g_free (string);
543 :
544 1 : egg_asn1x_destroy (asn);
545 1 : }
546 :
547 : static void
548 1 : test_octet_string_structured_bad (void)
549 : {
550 : GBytes *bytes;
551 : GNode *asn;
552 : guchar *string;
553 1 : gsize n_string = 0;
554 :
555 1 : const gchar STRUCTURED[] = "\x24\x0c"
556 : "\x24\x04\x04\02""bl"
557 : "\x04\x04""blah";
558 :
559 1 : bytes = g_bytes_new_static (STRUCTURED, XL (STRUCTURED));
560 1 : asn = egg_asn1x_create_and_decode (test_asn1_tab, "TestOctetString", bytes);
561 1 : g_bytes_unref (bytes);
562 :
563 1 : string = egg_asn1x_get_string_as_raw (asn, NULL, &n_string);
564 1 : g_assert (string == NULL);
565 :
566 1 : egg_asn1x_destroy (asn);
567 1 : }
568 :
569 : static void
570 1 : test_generalized_time (void)
571 : {
572 : GBytes *bytes;
573 : GNode *asn;
574 : glong value;
575 :
576 1 : asn = egg_asn1x_create (test_asn1_tab, "TestGeneralized");
577 1 : g_assert (asn);
578 :
579 1 : g_assert_cmpint (EGG_ASN1X_TIME, ==, egg_asn1x_type (asn));
580 :
581 : /* Shouldn't succeed */
582 1 : value = egg_asn1x_get_time_as_long (asn);
583 1 : g_assert (value == -1);
584 :
585 : /* Should work */
586 1 : bytes = g_bytes_new_static (TGENERALIZED, XL (TGENERALIZED));
587 1 : if (!egg_asn1x_decode (asn, bytes))
588 0 : g_assert_not_reached ();
589 1 : g_bytes_unref (bytes);
590 1 : value = egg_asn1x_get_time_as_long (asn);
591 1 : g_assert (value == 1185368728);
592 :
593 1 : egg_asn1x_clear (asn);
594 :
595 : /* Shouldn't succeed */
596 1 : value = egg_asn1x_get_time_as_long (asn);
597 1 : g_assert (value == -1);
598 :
599 1 : egg_asn1x_destroy (asn);
600 1 : }
601 :
602 : static void
603 1 : test_time_get_missing (void)
604 : {
605 : GDate date;
606 : GNode *asn;
607 :
608 1 : asn = egg_asn1x_create (test_asn1_tab, "TestGeneralized");
609 1 : if (egg_asn1x_get_time_as_date (asn, &date))
610 0 : g_assert_not_reached ();
611 1 : g_assert (egg_asn1x_get_time_as_long (asn) == -1);
612 1 : egg_asn1x_destroy (asn);
613 1 : }
614 :
615 : static void
616 1 : test_implicit_encode (void)
617 : {
618 : GBytes *bytes;
619 : GNode *asn;
620 : gchar *value;
621 :
622 1 : asn = egg_asn1x_create (test_asn1_tab, "TestImplicit");
623 1 : g_assert (asn);
624 :
625 : /* Should work */
626 1 : bytes = g_bytes_new_static (SIMPLICIT, XL (SIMPLICIT));
627 1 : if (!egg_asn1x_decode (asn, bytes))
628 0 : g_assert_not_reached ();
629 1 : g_bytes_unref (bytes);
630 1 : value = egg_asn1x_get_string_as_utf8 (asn, NULL);
631 1 : g_assert_cmpstr (value, ==, "implicit");
632 1 : g_free (value);
633 :
634 1 : egg_asn1x_destroy (asn);
635 1 : }
636 :
637 : static void
638 1 : test_implicit_decode (void)
639 : {
640 : GBytes *bytes;
641 : GNode *asn;
642 :
643 1 : asn = egg_asn1x_create (test_asn1_tab, "TestImplicit");
644 1 : g_assert (asn);
645 :
646 1 : if (!egg_asn1x_set_string_as_utf8 (asn, g_strdup ("implicit"), g_free))
647 0 : g_assert_not_reached ();
648 :
649 1 : bytes = egg_asn1x_encode (asn, NULL);
650 1 : egg_assert_cmpbytes (bytes, ==, SIMPLICIT, XL (SIMPLICIT));
651 :
652 1 : egg_asn1x_destroy (asn);
653 1 : g_bytes_unref (bytes);
654 1 : }
655 :
656 : static void
657 1 : test_explicit_decode (void)
658 : {
659 : GBytes *bytes;
660 : GNode *asn;
661 : gchar *value;
662 :
663 1 : asn = egg_asn1x_create (test_asn1_tab, "TestExplicit");
664 1 : g_assert (asn);
665 :
666 : /* Should work */
667 1 : bytes = g_bytes_new_static (SEXPLICIT, XL (SEXPLICIT));
668 1 : if (!egg_asn1x_decode (asn, bytes))
669 0 : g_assert_not_reached ();
670 1 : g_bytes_unref (bytes);
671 :
672 1 : value = egg_asn1x_get_string_as_utf8 (asn, NULL);
673 1 : g_assert_cmpstr (value, ==, "explicit");
674 1 : g_free (value);
675 :
676 1 : egg_asn1x_destroy (asn);
677 1 : }
678 :
679 : static void
680 1 : test_explicit_no_context_specific (void)
681 : {
682 : GBytes *bytes;
683 : GNode *asn;
684 :
685 1 : const gchar DER[] = "\x45\x0A\x04\x08""explicit";
686 :
687 1 : asn = egg_asn1x_create (test_asn1_tab, "TestExplicit");
688 1 : g_assert (asn != NULL);
689 :
690 1 : bytes = g_bytes_new_static (DER, XL (DER));
691 1 : if (egg_asn1x_decode (asn, bytes))
692 0 : g_assert_not_reached ();
693 1 : g_assert (strstr (egg_asn1x_message (asn), "missing context specific tag"));
694 1 : g_bytes_unref (bytes);
695 :
696 1 : egg_asn1x_destroy (asn);
697 1 : }
698 :
699 : static void
700 1 : test_explicit_no_context_child (void)
701 : {
702 : GBytes *bytes;
703 : GNode *asn;
704 :
705 1 : const gchar DER[] = "\xA5\x00";
706 :
707 1 : asn = egg_asn1x_create (test_asn1_tab, "TestExplicit");
708 1 : g_assert (asn != NULL);
709 :
710 1 : bytes = g_bytes_new_static (DER, XL (DER));
711 1 : if (egg_asn1x_decode (asn, bytes))
712 0 : g_assert_not_reached ();
713 1 : g_assert (strstr (egg_asn1x_message (asn), "missing context specific child"));
714 1 : g_bytes_unref (bytes);
715 :
716 1 : egg_asn1x_destroy (asn);
717 1 : }
718 :
719 : static void
720 1 : test_explicit_extra_context_child (void)
721 : {
722 : GBytes *bytes;
723 : GNode *asn;
724 :
725 1 : const gchar DER[] = "\xA5\x14"
726 : "\x04\x08""explicit"
727 : "\x04\x08""explicit";
728 :
729 1 : asn = egg_asn1x_create (test_asn1_tab, "TestExplicit");
730 1 : g_assert (asn != NULL);
731 :
732 1 : bytes = g_bytes_new_static (DER, XL (DER));
733 1 : if (egg_asn1x_decode (asn, bytes))
734 0 : g_assert_not_reached ();
735 1 : g_assert (strstr (egg_asn1x_message (asn), "multiple context specific children"));
736 1 : g_bytes_unref (bytes);
737 :
738 1 : egg_asn1x_destroy (asn);
739 1 : }
740 :
741 : static void
742 1 : test_explicit_encode (void)
743 : {
744 : GBytes *bytes;
745 : GNode *asn;
746 :
747 1 : asn = egg_asn1x_create (test_asn1_tab, "TestExplicit");
748 1 : g_assert (asn);
749 :
750 1 : if (!egg_asn1x_set_string_as_utf8 (asn, g_strdup ("explicit"), g_free))
751 0 : g_assert_not_reached ();
752 :
753 1 : bytes = egg_asn1x_encode (asn, NULL);
754 1 : egg_assert_cmpbytes (bytes, ==, SEXPLICIT, XL (SEXPLICIT));
755 :
756 1 : egg_asn1x_destroy (asn);
757 1 : g_bytes_unref (bytes);
758 1 : }
759 :
760 : static void
761 1 : test_universal_decode (void)
762 : {
763 : GBytes *bytes;
764 : GNode *asn;
765 : gchar *value;
766 :
767 1 : asn = egg_asn1x_create (test_asn1_tab, "TestUniversal");
768 1 : g_assert (asn);
769 :
770 : /* Should work */
771 1 : bytes = g_bytes_new_static (SUNIVERSAL, XL (SUNIVERSAL));
772 1 : if (!egg_asn1x_decode (asn, bytes))
773 0 : g_assert_not_reached ();
774 1 : g_bytes_unref (bytes);
775 :
776 1 : value = egg_asn1x_get_string_as_utf8 (asn, NULL);
777 1 : g_assert_cmpstr (value, ==, "universal");
778 1 : g_free (value);
779 :
780 1 : egg_asn1x_destroy (asn);
781 1 : }
782 :
783 : static void
784 1 : test_universal_encode (void)
785 : {
786 : GBytes *bytes;
787 : GNode *asn;
788 :
789 1 : asn = egg_asn1x_create (test_asn1_tab, "TestUniversal");
790 1 : g_assert (asn);
791 :
792 1 : if (!egg_asn1x_set_string_as_utf8 (asn, g_strdup ("universal"), g_free))
793 0 : g_assert_not_reached ();
794 :
795 1 : bytes = egg_asn1x_encode (asn, NULL);
796 1 : egg_assert_cmpbytes (bytes, ==, SUNIVERSAL, XL (SUNIVERSAL));
797 :
798 1 : egg_asn1x_destroy (asn);
799 1 : g_bytes_unref (bytes);
800 1 : }
801 :
802 : static void
803 1 : test_bit_string_decode (void)
804 : {
805 : GBytes *bytes;
806 : GNode *asn;
807 : GBytes *bits;
808 : guint n_bits;
809 : const guchar *data;
810 :
811 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBitString");
812 1 : g_assert (asn);
813 :
814 1 : g_assert_cmpint (EGG_ASN1X_BIT_STRING, ==, egg_asn1x_type (asn));
815 :
816 : /* Should work */
817 1 : bytes = g_bytes_new_static (BITS_TEST, XL (BITS_TEST));
818 1 : if (!egg_asn1x_decode (asn, bytes))
819 0 : g_assert_not_reached ();
820 1 : g_bytes_unref (bytes);
821 :
822 1 : bits = egg_asn1x_get_bits_as_raw (asn, &n_bits);
823 1 : g_assert (bits != NULL);
824 1 : g_assert_cmpuint (n_bits, ==, 18);
825 1 : data = g_bytes_get_data (bits, NULL);
826 1 : g_assert_cmpint (data[0], ==, 0x6e);
827 1 : g_assert_cmpint (data[1], ==, 0x5d);
828 1 : g_assert_cmpint (data[2], ==, 0xc0);
829 :
830 1 : g_bytes_unref (bits);
831 1 : egg_asn1x_destroy (asn);
832 1 : }
833 :
834 : static void
835 1 : test_bit_string_decode_bad (void)
836 : {
837 : GBytes *bytes;
838 : GNode *asn;
839 :
840 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBitString");
841 1 : g_assert (asn);
842 :
843 : /* Should not work */
844 1 : bytes = g_bytes_new_static (BITS_BAD, XL (BITS_BAD));
845 1 : if (egg_asn1x_decode (asn, bytes))
846 0 : g_assert_not_reached ();
847 1 : g_bytes_unref (bytes);
848 :
849 1 : egg_asn1x_destroy (asn);
850 1 : }
851 :
852 : static void
853 1 : test_bit_string_decode_ulong (void)
854 : {
855 : GBytes *bytes;
856 : GNode *asn;
857 : gulong bits;
858 : guint n_bits;
859 :
860 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBitString");
861 1 : g_assert (asn);
862 :
863 : /* Should work */
864 1 : bytes = g_bytes_new_static (BITS_TEST, XL (BITS_TEST));
865 1 : if (!egg_asn1x_decode (asn, bytes))
866 0 : g_assert_not_reached ();
867 1 : g_bytes_unref (bytes);
868 :
869 1 : if (!egg_asn1x_get_bits_as_ulong (asn, &bits, &n_bits))
870 0 : g_assert_not_reached ();
871 :
872 1 : g_assert_cmpuint (n_bits, ==, 18);
873 1 : g_assert_cmphex (bits, ==, 0x1b977);
874 :
875 1 : egg_asn1x_destroy (asn);
876 1 : }
877 :
878 : static void
879 1 : test_bit_string_ulong_too_long (void)
880 : {
881 : GBytes *bytes;
882 : GNode *asn;
883 : gulong bits;
884 : guint n_bits;
885 :
886 1 : const gchar BITS_TEST[] = "\x03\x20\x00\x01\x02\x03\x04\x05\x06\x07"
887 : "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
888 : "\x00\x01\x02\x03\x04\x05\x06\x07"
889 : "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f";
890 :
891 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBitString");
892 1 : g_assert (asn);
893 :
894 : /* Should work */
895 :
896 1 : bytes = g_bytes_new_static (BITS_TEST, XL (BITS_TEST));
897 1 : if (!egg_asn1x_decode (asn, bytes))
898 0 : g_assert_not_reached ();
899 1 : g_bytes_unref (bytes);
900 :
901 1 : if (egg_asn1x_get_bits_as_ulong (asn, &bits, &n_bits))
902 0 : g_assert_not_reached ();
903 :
904 1 : egg_asn1x_destroy (asn);
905 1 : }
906 :
907 : static void
908 1 : test_bit_string_get_not_set (void)
909 : {
910 : GNode *asn;
911 : gulong bits;
912 : guint n_bits;
913 :
914 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBitString");
915 :
916 1 : if (egg_asn1x_get_bits_as_ulong (asn, &bits, &n_bits))
917 0 : g_assert_not_reached ();
918 1 : g_assert (egg_asn1x_get_bits_as_raw (asn, &n_bits) == NULL);
919 :
920 1 : egg_asn1x_destroy (asn);
921 1 : }
922 :
923 : static void
924 1 : test_bit_string_invalid_length (void)
925 : {
926 : GBytes *bytes;
927 : GNode *asn;
928 :
929 1 : const gchar DER[] = "\x03\x00";
930 :
931 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBitString");
932 1 : g_assert (asn);
933 :
934 : /* Should work */
935 :
936 1 : bytes = g_bytes_new_static (DER, XL (DER));
937 1 : if (egg_asn1x_decode (asn, bytes))
938 0 : g_assert_not_reached ();
939 1 : g_assert (strstr (egg_asn1x_message (asn), "invalid length bit string"));
940 1 : g_bytes_unref (bytes);
941 :
942 1 : egg_asn1x_destroy (asn);
943 1 : }
944 :
945 : static void
946 1 : test_bit_string_invalid_empty (void)
947 : {
948 : GBytes *bytes;
949 : GNode *asn;
950 :
951 1 : const gchar DER[] = "\x03\x01\x09";
952 :
953 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBitString");
954 1 : g_assert (asn);
955 :
956 : /* Should work */
957 :
958 1 : bytes = g_bytes_new_static (DER, XL (DER));
959 1 : if (egg_asn1x_decode (asn, bytes))
960 0 : g_assert_not_reached ();
961 1 : g_assert (strstr (egg_asn1x_message (asn), "invalid number of empty bits"));
962 1 : g_bytes_unref (bytes);
963 :
964 1 : egg_asn1x_destroy (asn);
965 1 : }
966 :
967 : static void
968 1 : test_bit_string_encode_decode (void)
969 : {
970 : GBytes *data;
971 : GNode *asn;
972 1 : guchar bits[] = { 0x5d, 0x6e, 0x83 };
973 : GBytes *check;
974 : GBytes *bytes;
975 : const guchar *ch;
976 1 : guint n_bits = 17;
977 : guint n_check;
978 :
979 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBitString");
980 1 : g_assert (asn);
981 :
982 1 : bytes = g_bytes_new (bits, 3);
983 1 : egg_asn1x_set_bits_as_raw (asn, bytes, n_bits);
984 1 : g_bytes_unref (bytes);
985 :
986 1 : data = egg_asn1x_encode (asn, NULL);
987 1 : g_assert (data);
988 :
989 1 : if (!egg_asn1x_decode (asn, data))
990 0 : g_assert_not_reached ();
991 :
992 1 : g_bytes_unref (data);
993 :
994 1 : check = egg_asn1x_get_bits_as_raw (asn, &n_check);
995 1 : g_assert (check != NULL);
996 1 : g_assert_cmpuint (n_check, ==, 17);
997 1 : ch = g_bytes_get_data (check, NULL);
998 1 : g_assert_cmpint (ch[0], ==, 0x5d);
999 1 : g_assert_cmpint (ch[1], ==, 0x6e);
1000 1 : g_assert_cmpint (ch[2], ==, 0x80);
1001 :
1002 1 : g_bytes_unref (check);
1003 1 : egg_asn1x_destroy (asn);
1004 1 : }
1005 :
1006 : static void
1007 1 : test_bit_string_encode_decode_ulong (void)
1008 : {
1009 : GBytes *data;
1010 : GNode *asn;
1011 1 : gulong check, bits = 0x0101b977;
1012 1 : guint n_check, n_bits = 18;
1013 :
1014 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBitString");
1015 1 : g_assert (asn);
1016 :
1017 1 : egg_asn1x_set_bits_as_ulong (asn, bits, n_bits);
1018 1 : data = egg_asn1x_encode (asn, NULL);
1019 1 : g_assert (data);
1020 :
1021 1 : if (!egg_asn1x_decode (asn, data))
1022 0 : g_assert_not_reached ();
1023 :
1024 1 : g_bytes_unref (data);
1025 :
1026 1 : if (!egg_asn1x_get_bits_as_ulong (asn, &check, &n_check))
1027 0 : g_assert_not_reached ();
1028 :
1029 1 : g_assert_cmpuint (n_check, ==, 18);
1030 1 : g_assert_cmphex (check, ==, 0x1b977);
1031 :
1032 1 : egg_asn1x_destroy (asn);
1033 1 : }
1034 :
1035 : static void
1036 1 : test_bit_string_encode_decode_zero (void)
1037 : {
1038 : GBytes *data;
1039 : GNode *asn;
1040 :
1041 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBitString");
1042 1 : g_assert (asn);
1043 :
1044 1 : egg_asn1x_take_bits_as_raw (asn, g_bytes_new_static ("", 0), 0);
1045 :
1046 1 : data = egg_asn1x_encode (asn, NULL);
1047 1 : g_assert (data);
1048 :
1049 1 : egg_assert_cmpmem (g_bytes_get_data (data, NULL), g_bytes_get_size (data), ==, BITS_ZERO, XL (BITS_ZERO));
1050 :
1051 1 : g_bytes_unref (data);
1052 1 : egg_asn1x_destroy (asn);
1053 1 : }
1054 :
1055 : static void
1056 1 : test_have (void)
1057 : {
1058 : GBytes *data;
1059 : GNode *asn;
1060 :
1061 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBoolean");
1062 1 : g_assert (asn);
1063 :
1064 1 : g_assert (!egg_asn1x_have (asn));
1065 :
1066 1 : egg_asn1x_set_boolean (asn, TRUE);
1067 :
1068 1 : g_assert (egg_asn1x_have (asn));
1069 :
1070 1 : data = egg_asn1x_encode (asn, NULL);
1071 1 : g_assert (data);
1072 :
1073 1 : g_assert (egg_asn1x_have (asn));
1074 :
1075 1 : g_bytes_unref (data);
1076 1 : egg_asn1x_destroy (asn);
1077 1 : }
1078 :
1079 : static gboolean is_freed = FALSE;
1080 :
1081 : static void
1082 6 : test_is_freed (gpointer unused)
1083 : {
1084 6 : g_assert (!is_freed);
1085 6 : is_freed = TRUE;
1086 6 : }
1087 :
1088 : static void
1089 1 : test_any_raw (void)
1090 : {
1091 : GBytes *bytes;
1092 : GNode *asn, *node;
1093 : GBytes *data;
1094 : GBytes *check;
1095 :
1096 : /* ENCODED SEQUENCE ANY with OCTET STRING */
1097 1 : const gchar SEQ_ENCODING[] = "\x30\x0C\x04\x0A""farnsworth";
1098 :
1099 1 : asn = egg_asn1x_create (test_asn1_tab, "TestAnySeq");
1100 1 : g_assert (asn);
1101 :
1102 1 : is_freed = FALSE;
1103 1 : node = egg_asn1x_node (asn, "contents", NULL);
1104 1 : g_assert (node);
1105 :
1106 1 : bytes = g_bytes_new_with_free_func (SFARNSWORTH, XL (SFARNSWORTH),
1107 : test_is_freed, NULL);
1108 1 : if (!egg_asn1x_set_any_raw (node, bytes))
1109 0 : g_assert_not_reached ();
1110 1 : g_bytes_unref (bytes);
1111 :
1112 1 : data = egg_asn1x_encode (asn, NULL);
1113 1 : g_assert (data != NULL);
1114 :
1115 1 : egg_assert_cmpbytes (data, ==, SEQ_ENCODING, XL (SEQ_ENCODING));
1116 :
1117 1 : check = egg_asn1x_get_element_raw (node);
1118 1 : g_assert (check != NULL);
1119 1 : egg_assert_cmpbytes (check, ==, SFARNSWORTH, XL (SFARNSWORTH));
1120 1 : g_bytes_unref (check);
1121 :
1122 1 : check = egg_asn1x_get_any_raw (node, NULL);
1123 1 : g_assert (check != NULL);
1124 1 : egg_assert_cmpbytes (check, ==, SFARNSWORTH, XL (SFARNSWORTH));
1125 1 : g_bytes_unref (check);
1126 :
1127 1 : g_bytes_unref (data);
1128 1 : egg_asn1x_destroy (asn);
1129 1 : g_assert (is_freed);
1130 1 : }
1131 :
1132 : static void
1133 1 : test_any_raw_explicit (void)
1134 : {
1135 : GBytes *bytes;
1136 : GNode *asn, *node;
1137 : GBytes *data;
1138 :
1139 : /* ENCODED SEQUENCE [89] ANY with OCTET STRING */
1140 1 : const gchar SEQ_ENCODING[] = "\x30\x0F\xBF\x59\x0C\x04\x0A""farnsworth";
1141 :
1142 1 : asn = egg_asn1x_create (test_asn1_tab, "TestAnyExp");
1143 1 : g_assert (asn);
1144 :
1145 1 : is_freed = FALSE;
1146 1 : node = egg_asn1x_node (asn, "contents", NULL);
1147 1 : g_assert (node);
1148 :
1149 1 : bytes = g_bytes_new_with_free_func (SFARNSWORTH, XL (SFARNSWORTH), test_is_freed, NULL);
1150 1 : if (!egg_asn1x_set_any_raw (node, bytes))
1151 0 : g_assert_not_reached ();
1152 1 : g_bytes_unref (bytes);
1153 :
1154 1 : data = egg_asn1x_encode (asn, NULL);
1155 1 : g_assert (data != NULL);
1156 :
1157 1 : egg_assert_cmpbytes (data, ==, SEQ_ENCODING, XL (SEQ_ENCODING));
1158 :
1159 1 : g_bytes_unref (data);
1160 1 : egg_asn1x_destroy (asn);
1161 1 : g_assert (is_freed);
1162 1 : }
1163 :
1164 : static void
1165 1 : test_any_raw_invalid (void)
1166 : {
1167 : GBytes *bytes;
1168 : GNode *asn, *node;
1169 :
1170 1 : const gchar TRUNCATED[] = "\x04\x0A""farns";
1171 :
1172 1 : asn = egg_asn1x_create (test_asn1_tab, "TestAnySeq");
1173 1 : g_assert (asn != NULL);
1174 :
1175 1 : node = egg_asn1x_node (asn, "contents", NULL);
1176 1 : g_assert (node != NULL);
1177 :
1178 1 : bytes = g_bytes_new_static (TRUNCATED, XL (TRUNCATED));
1179 1 : if (egg_asn1x_set_any_raw (node, bytes))
1180 0 : g_assert_not_reached ();
1181 1 : g_assert (strstr (egg_asn1x_message (node), "content is not encoded properly") != NULL);
1182 1 : g_bytes_unref (bytes);
1183 :
1184 1 : egg_asn1x_destroy (asn);
1185 1 : }
1186 :
1187 : static void
1188 1 : test_any_raw_not_set (void)
1189 : {
1190 : GBytes *check;
1191 : GNode *asn, *node;
1192 :
1193 1 : asn = egg_asn1x_create (test_asn1_tab, "TestAnySeq");
1194 1 : g_assert (asn != NULL);
1195 :
1196 1 : node = egg_asn1x_node (asn, "contents", NULL);
1197 1 : g_assert (node != NULL);
1198 :
1199 1 : check = egg_asn1x_get_any_raw (node, NULL);
1200 1 : g_assert (check == NULL);
1201 :
1202 1 : egg_asn1x_destroy (asn);
1203 1 : }
1204 :
1205 : static void
1206 1 : test_any_into (void)
1207 : {
1208 : GBytes *bytes;
1209 : GNode *asn, *node;
1210 : GNode *part;
1211 : GBytes *data;
1212 : GBytes *check;
1213 :
1214 : /* ENCODED SEQUENCE ANY with OCTET STRING */
1215 1 : const gchar SEQ_ENCODING[] = "\x30\x0C\x04\x0A""farnsworth";
1216 :
1217 1 : asn = egg_asn1x_create (test_asn1_tab, "TestAnySeq");
1218 1 : g_assert (asn != NULL);
1219 :
1220 1 : is_freed = FALSE;
1221 1 : node = egg_asn1x_node (asn, "contents", NULL);
1222 1 : g_assert (node);
1223 :
1224 1 : bytes = g_bytes_new_with_free_func (SFARNSWORTH, XL (SFARNSWORTH),
1225 : test_is_freed, NULL);
1226 1 : part = egg_asn1x_create_and_decode (test_asn1_tab, "TestOctetString", bytes);
1227 1 : g_assert (part != NULL);
1228 1 : g_bytes_unref (bytes);
1229 :
1230 1 : egg_asn1x_set_any_from (node, part);
1231 1 : egg_asn1x_destroy (part);
1232 :
1233 1 : data = egg_asn1x_encode (asn, NULL);
1234 1 : g_assert (data != NULL);
1235 1 : egg_assert_cmpbytes (data, ==, SEQ_ENCODING, XL (SEQ_ENCODING));
1236 :
1237 1 : part = egg_asn1x_create (test_asn1_tab, "TestOctetString");
1238 1 : if (!egg_asn1x_get_any_into (node, part))
1239 0 : g_assert_not_reached ();
1240 :
1241 1 : check = egg_asn1x_encode (part, NULL);
1242 1 : egg_asn1x_destroy (part);
1243 1 : g_assert (check != NULL);
1244 1 : egg_assert_cmpbytes (check, ==, SFARNSWORTH, XL (SFARNSWORTH));
1245 1 : g_bytes_unref (check);
1246 :
1247 1 : g_bytes_unref (data);
1248 1 : egg_asn1x_destroy (asn);
1249 1 : g_assert (is_freed);
1250 1 : }
1251 :
1252 : static void
1253 1 : test_any_into_explicit (void)
1254 : {
1255 : GBytes *bytes;
1256 : GNode *asn, *node;
1257 : GNode *part;
1258 : GBytes *data;
1259 : GBytes *check;
1260 :
1261 : /* ENCODED SEQUENCE [89] ANY with OCTET STRING */
1262 1 : const gchar SEQ_ENCODING[] = "\x30\x0F\xBF\x59\x0C\x04\x0A""farnsworth";
1263 :
1264 1 : asn = egg_asn1x_create (test_asn1_tab, "TestAnyExp");
1265 1 : g_assert (asn != NULL);
1266 :
1267 1 : is_freed = FALSE;
1268 1 : node = egg_asn1x_node (asn, "contents", NULL);
1269 1 : g_assert (node);
1270 :
1271 1 : bytes = g_bytes_new_with_free_func (SFARNSWORTH, XL (SFARNSWORTH),
1272 : test_is_freed, NULL);
1273 1 : part = egg_asn1x_create_and_decode (test_asn1_tab, "TestOctetString", bytes);
1274 1 : g_assert (part != NULL);
1275 1 : g_bytes_unref (bytes);
1276 :
1277 1 : egg_asn1x_set_any_from (node, part);
1278 1 : egg_asn1x_destroy (part);
1279 :
1280 1 : data = egg_asn1x_encode (asn, NULL);
1281 1 : g_assert (data != NULL);
1282 1 : egg_assert_cmpbytes (data, ==, SEQ_ENCODING, XL (SEQ_ENCODING));
1283 :
1284 1 : part = egg_asn1x_create (test_asn1_tab, "TestOctetString");
1285 1 : if (!egg_asn1x_get_any_into (node, part))
1286 0 : g_assert_not_reached ();
1287 :
1288 1 : check = egg_asn1x_encode (part, NULL);
1289 1 : egg_asn1x_destroy (part);
1290 1 : g_assert (check != NULL);
1291 1 : egg_assert_cmpbytes (check, ==, SFARNSWORTH, XL (SFARNSWORTH));
1292 1 : g_bytes_unref (check);
1293 :
1294 1 : g_bytes_unref (data);
1295 1 : egg_asn1x_destroy (asn);
1296 1 : g_assert (is_freed);
1297 1 : }
1298 :
1299 : static void
1300 1 : test_any_into_explicit_not_set (void)
1301 : {
1302 : GNode *asn, *node;
1303 : GNode *part;
1304 :
1305 1 : asn = egg_asn1x_create (test_asn1_tab, "TestAnyExp");
1306 1 : g_assert (asn != NULL);
1307 :
1308 1 : node = egg_asn1x_node (asn, "contents", NULL);
1309 1 : g_assert (node);
1310 :
1311 1 : part = egg_asn1x_create (test_asn1_tab, "TestOctetString");
1312 1 : if (egg_asn1x_get_any_into (node, part))
1313 0 : g_assert_not_reached ();
1314 :
1315 1 : egg_asn1x_destroy (part);
1316 1 : egg_asn1x_destroy (asn);
1317 1 : }
1318 :
1319 : static void
1320 1 : test_choice_not_chosen (void)
1321 : {
1322 : GBytes *bytes;
1323 : GNode *asn, *node;
1324 : GBytes *data;
1325 :
1326 1 : asn = egg_asn1x_create (test_asn1_tab, "TestAnyChoice");
1327 1 : g_assert (asn);
1328 :
1329 1 : g_assert_cmpint (EGG_ASN1X_CHOICE, ==, egg_asn1x_type (asn));
1330 :
1331 1 : node = egg_asn1x_node (asn, "choiceShortTag", NULL);
1332 1 : g_assert (node);
1333 :
1334 1 : bytes = g_bytes_new_static (SFARNSWORTH, XL (SFARNSWORTH));
1335 1 : if (!egg_asn1x_set_any_raw (node, bytes))
1336 0 : g_assert_not_reached ();
1337 1 : g_bytes_unref (bytes);
1338 :
1339 : /* egg_asn1x_set_choice() was not called */
1340 1 : data = egg_asn1x_encode (asn, NULL);
1341 1 : g_assert (data == NULL);
1342 1 : g_assert (egg_asn1x_message (asn));
1343 1 : g_assert (strstr (egg_asn1x_message (asn), "TestAnyChoice") != NULL);
1344 :
1345 1 : egg_asn1x_destroy (asn);
1346 1 : }
1347 :
1348 : static void
1349 2 : perform_asn1_any_choice_set_raw (const gchar *choice, const gchar *encoding, gsize n_encoding)
1350 : {
1351 : GBytes *bytes;
1352 : GNode *asn, *node;
1353 : GBytes *data;
1354 : GBytes *check;
1355 :
1356 2 : asn = egg_asn1x_create (test_asn1_tab, "TestAnyChoice");
1357 2 : g_assert (asn);
1358 :
1359 2 : g_assert_cmpint (EGG_ASN1X_CHOICE, ==, egg_asn1x_type (asn));
1360 :
1361 2 : is_freed = FALSE;
1362 2 : node = egg_asn1x_node (asn, choice, NULL);
1363 2 : g_assert (node);
1364 :
1365 2 : if (!egg_asn1x_set_choice (asn, node))
1366 0 : g_assert_not_reached ();
1367 :
1368 2 : bytes = g_bytes_new_with_free_func (SFARNSWORTH, XL (SFARNSWORTH), test_is_freed, NULL);
1369 2 : if (!egg_asn1x_set_any_raw (node, bytes))
1370 0 : g_assert_not_reached ();
1371 2 : g_bytes_unref (bytes);
1372 :
1373 2 : data = egg_asn1x_encode (asn, NULL);
1374 2 : if (data == NULL) {
1375 0 : g_printerr ("%s\n", egg_asn1x_message (asn));
1376 0 : g_assert_not_reached ();
1377 : }
1378 2 : g_assert (data != NULL);
1379 :
1380 2 : egg_assert_cmpbytes (data, ==, encoding, n_encoding);
1381 :
1382 2 : check = egg_asn1x_get_element_raw (node);
1383 2 : g_assert (check != NULL);
1384 :
1385 2 : egg_assert_cmpbytes (check, ==, SFARNSWORTH, XL (SFARNSWORTH));
1386 :
1387 2 : g_bytes_unref (data);
1388 2 : g_bytes_unref (check);
1389 2 : egg_asn1x_destroy (asn);
1390 2 : g_assert (is_freed);
1391 2 : }
1392 :
1393 : static void
1394 1 : test_any_choice_set_raw_short_tag (void)
1395 : {
1396 1 : const gchar ENCODING[] = "\xBE\x0C\x04\x0A""farnsworth";
1397 1 : perform_asn1_any_choice_set_raw ("choiceShortTag", ENCODING, XL (ENCODING));
1398 1 : }
1399 :
1400 : static void
1401 1 : test_any_choice_set_raw_long_tag (void)
1402 : {
1403 1 : const gchar ENCODING[] = "\xBF\x1F\x0C\x04\x0A""farnsworth";
1404 1 : perform_asn1_any_choice_set_raw ("choiceLongTag", ENCODING, XL (ENCODING));
1405 1 : }
1406 :
1407 : static void
1408 1 : test_seq_of_any (void)
1409 : {
1410 : GNode *asn;
1411 : GNode *integer;
1412 : GBytes *bytes;
1413 : gboolean ret;
1414 : gulong value;
1415 :
1416 1 : const gchar DER[] = "\x30\x06"
1417 : "\x02\x01\x88"
1418 : "\x02\x01\x33";
1419 :
1420 1 : asn = egg_asn1x_create (test_asn1_tab, "TestSeqOfAny");
1421 1 : g_assert (asn != NULL);
1422 :
1423 1 : egg_asn1x_append (asn);
1424 1 : egg_asn1x_append (asn);
1425 :
1426 1 : bytes = g_bytes_new_static (DER, XL (DER));
1427 1 : ret = egg_asn1x_decode (asn, bytes);
1428 1 : egg_asn1x_assert (ret == TRUE, asn);
1429 1 : g_bytes_unref (bytes);
1430 :
1431 1 : integer = egg_asn1x_create (test_asn1_tab, "TestInteger");
1432 1 : g_assert (integer != NULL);
1433 :
1434 1 : ret = egg_asn1x_get_any_into (egg_asn1x_node (asn, 1, NULL), integer);
1435 1 : egg_asn1x_assert (ret == TRUE, integer);
1436 1 : if (!egg_asn1x_get_integer_as_ulong (integer, &value))
1437 0 : g_assert_not_reached ();
1438 1 : g_assert_cmpint (value, ==, 0x88);
1439 :
1440 1 : ret = egg_asn1x_get_any_into (egg_asn1x_node (asn, 2, NULL), integer);
1441 1 : egg_asn1x_assert (ret == TRUE, integer);
1442 1 : if (!egg_asn1x_get_integer_as_ulong (integer, &value))
1443 0 : g_assert_not_reached ();
1444 1 : g_assert_cmpint (value, ==, 0x33);
1445 :
1446 1 : egg_asn1x_destroy (integer);
1447 1 : egg_asn1x_destroy (asn);
1448 1 : }
1449 :
1450 : static void
1451 1 : test_seq_of_invalid (void)
1452 : {
1453 : GNode *asn;
1454 : GBytes *bytes;
1455 :
1456 1 : const gchar DER[] = "\x30\x05"
1457 : "\x04\x00"
1458 : "\x02\x01\x88";
1459 :
1460 1 : asn = egg_asn1x_create (test_asn1_tab, "TestSeqOf");
1461 1 : g_assert (asn != NULL);
1462 :
1463 1 : bytes = g_bytes_new_static (DER, XL (DER));
1464 1 : if (egg_asn1x_decode (asn, bytes))
1465 0 : g_assert_not_reached ();
1466 1 : g_bytes_unref (bytes);
1467 :
1468 1 : egg_asn1x_destroy (asn);
1469 1 : }
1470 :
1471 : static void
1472 1 : test_seq_of_different (void)
1473 : {
1474 : GNode *asn;
1475 : GBytes *bytes;
1476 :
1477 1 : const gchar DER[] = "\x30\x05"
1478 : "\x02\x01\x88"
1479 : "\x04\x00";
1480 :
1481 1 : asn = egg_asn1x_create (test_asn1_tab, "TestSeqOf");
1482 1 : g_assert (asn != NULL);
1483 :
1484 1 : bytes = g_bytes_new_static (DER, XL (DER));
1485 1 : if (egg_asn1x_decode (asn, bytes))
1486 0 : g_assert_not_reached ();
1487 1 : g_bytes_unref (bytes);
1488 :
1489 1 : egg_asn1x_destroy (asn);
1490 1 : }
1491 :
1492 : static void
1493 1 : test_set_order (void)
1494 : {
1495 : GNode *asn;
1496 : GBytes *bytes;
1497 :
1498 1 : const gchar DER[] = "\x31\x0f"
1499 : "\xA2\x03\x02\x01\x99"
1500 : "\xA1\x03\x02\x01\x88"
1501 : "\xA3\x03\x02\x01\x88";
1502 :
1503 1 : asn = egg_asn1x_create (test_asn1_tab, "TestSet");
1504 1 : g_assert (asn != NULL);
1505 :
1506 1 : bytes = g_bytes_new_static (DER, XL (DER));
1507 1 : if (egg_asn1x_decode (asn, bytes))
1508 0 : g_assert_not_reached ();
1509 1 : g_assert (strstr (egg_asn1x_message (asn), "content must be in ascending order"));
1510 1 : g_bytes_unref (bytes);
1511 :
1512 1 : egg_asn1x_destroy (asn);
1513 1 : }
1514 :
1515 : static void
1516 1 : test_append (void)
1517 : {
1518 : GBytes *bytes;
1519 : GNode *asn;
1520 : GNode *child;
1521 : GBytes *data;
1522 :
1523 : /* SEQUENCE OF with one INTEGER = 1 */
1524 1 : const gchar SEQOF_ONE[] = "\x30\x03\x02\x01\x01";
1525 :
1526 : /* SEQUENCE OF with two INTEGER = 1, 2 */
1527 1 : const gchar SEQOF_TWO[] = "\x30\x06\x02\x01\x01\x02\x01\x02";
1528 :
1529 1 : bytes = g_bytes_new_static (SEQOF_ONE, XL (SEQOF_ONE));
1530 1 : asn = egg_asn1x_create_and_decode (test_asn1_tab, "TestSeqOf", bytes);
1531 1 : g_assert (asn);
1532 1 : g_bytes_unref (bytes);
1533 :
1534 1 : g_assert_cmpint (EGG_ASN1X_SEQUENCE_OF, ==, egg_asn1x_type (asn));
1535 :
1536 1 : child = egg_asn1x_append (asn);
1537 1 : g_assert (child);
1538 :
1539 : /* Second integer is 2 */
1540 1 : egg_asn1x_set_integer_as_ulong (child, 2);
1541 :
1542 1 : data = egg_asn1x_encode (asn, NULL);
1543 1 : g_assert (data != NULL);
1544 :
1545 1 : egg_assert_cmpbytes (data, ==, SEQOF_TWO, XL (SEQOF_TWO));
1546 :
1547 1 : g_bytes_unref (data);
1548 1 : egg_asn1x_destroy (asn);
1549 1 : }
1550 :
1551 : static void
1552 1 : test_append_and_clear (void)
1553 : {
1554 : GBytes *data;
1555 : GNode *asn;
1556 :
1557 1 : asn = egg_asn1x_create (test_asn1_tab, "TestSeqOf");
1558 1 : g_assert (asn);
1559 :
1560 1 : g_assert_cmpuint (egg_asn1x_count (asn), ==, 0);
1561 :
1562 1 : egg_asn1x_set_integer_as_ulong (egg_asn1x_append (asn), 2);
1563 1 : egg_asn1x_set_integer_as_ulong (egg_asn1x_append (asn), 3);
1564 :
1565 1 : g_assert_cmpuint (egg_asn1x_count (asn), ==, 2);
1566 :
1567 1 : data = egg_asn1x_encode (asn, NULL);
1568 1 : g_assert (data != NULL);
1569 :
1570 1 : g_assert_cmpuint (egg_asn1x_count (asn), ==, 2);
1571 :
1572 1 : egg_asn1x_clear (asn);
1573 1 : g_assert_cmpuint (egg_asn1x_count (asn), ==, 0);
1574 :
1575 1 : egg_asn1x_destroy (asn);
1576 1 : g_bytes_unref (data);
1577 1 : }
1578 :
1579 : static void
1580 1 : test_setof (void)
1581 : {
1582 : GBytes *bytes;
1583 : GNode *asn;
1584 : GBytes *data;
1585 :
1586 : /* SEQUENCE OF with one INTEGER = 3 */
1587 1 : const gchar SETOF_ONE[] = "\x31\x03\x02\x01\x03";
1588 :
1589 : /* SET OF with two INTEGER = 1, 3, 8 */
1590 1 : const gchar SETOF_THREE[] = "\x31\x09\x02\x01\x01\x02\x01\x03\x02\x01\x08";
1591 :
1592 1 : bytes = g_bytes_new_static (SETOF_ONE, XL (SETOF_ONE));
1593 1 : asn = egg_asn1x_create_and_decode (test_asn1_tab, "TestSetOf", bytes);
1594 1 : g_assert (asn != NULL);
1595 1 : g_bytes_unref (bytes);
1596 :
1597 1 : g_assert_cmpint (EGG_ASN1X_SET_OF, ==, egg_asn1x_type (asn));
1598 :
1599 : /* Add integer 1, in SET OF DER should sort to front */
1600 1 : egg_asn1x_set_integer_as_ulong (egg_asn1x_append (asn), 1);
1601 :
1602 : /* Add integer 8, in SET OF DER should sort to back */
1603 1 : egg_asn1x_set_integer_as_ulong (egg_asn1x_append (asn), 8);
1604 :
1605 1 : data = egg_asn1x_encode (asn, NULL);
1606 1 : if (data == NULL) {
1607 0 : g_printerr ("%s\n", egg_asn1x_message (asn));
1608 0 : g_assert_not_reached ();
1609 : }
1610 :
1611 1 : egg_assert_cmpbytes (data, ==, SETOF_THREE, XL (SETOF_THREE));
1612 :
1613 1 : g_bytes_unref (data);
1614 1 : egg_asn1x_destroy (asn);
1615 1 : }
1616 :
1617 : static void
1618 1 : test_setof_empty (void)
1619 : {
1620 : GBytes *data;
1621 : GNode *asn;
1622 :
1623 : /* SEQUENCE OF with nothing */
1624 1 : const gchar SETOF_NONE[] = "\x31\x00";
1625 :
1626 1 : asn = egg_asn1x_create (test_asn1_tab, "TestSetOf");
1627 1 : g_assert (asn);
1628 :
1629 1 : data = egg_asn1x_encode (asn, NULL);
1630 1 : if (data == NULL) {
1631 0 : g_printerr ("%s\n", egg_asn1x_message (asn));
1632 0 : g_assert_not_reached ();
1633 : }
1634 :
1635 1 : egg_assert_cmpbytes (data, ==, SETOF_NONE, XL (SETOF_NONE));
1636 :
1637 1 : g_bytes_unref (data);
1638 1 : egg_asn1x_destroy (asn);
1639 1 : }
1640 :
1641 : static void
1642 1 : test_enumerated (void)
1643 : {
1644 : GBytes *bytes;
1645 : GNode *asn;
1646 : GBytes *data;
1647 : GQuark value;
1648 :
1649 1 : bytes = g_bytes_new_static (ENUM_TWO, XL (ENUM_TWO));
1650 1 : asn = egg_asn1x_create_and_decode (test_asn1_tab, "TestEnumerated", bytes);
1651 1 : g_assert (asn != NULL);
1652 1 : g_bytes_unref (bytes);
1653 :
1654 1 : g_assert_cmpint (EGG_ASN1X_ENUMERATED, ==, egg_asn1x_type (asn));
1655 :
1656 1 : value = egg_asn1x_get_enumerated (asn);
1657 1 : g_assert (value);
1658 1 : g_assert_cmpstr (g_quark_to_string (value), ==, "valueTwo");
1659 :
1660 1 : egg_asn1x_set_enumerated (asn, g_quark_from_static_string ("valueThree"));
1661 :
1662 1 : data = egg_asn1x_encode (asn, NULL);
1663 1 : g_assert (data != NULL);
1664 :
1665 1 : egg_assert_cmpbytes (data, ==, ENUM_THREE, XL (ENUM_THREE));
1666 :
1667 1 : g_bytes_unref (data);
1668 1 : egg_asn1x_destroy (asn);
1669 1 : }
1670 :
1671 : static void
1672 1 : test_enumerated_decode_bad (void)
1673 : {
1674 1 : const gchar ENUM_NEGATIVE[] = "\x0A\x01\x85";
1675 :
1676 : GBytes *bytes;
1677 : GNode *asn;
1678 : gboolean ret;
1679 :
1680 1 : asn = egg_asn1x_create (test_asn1_tab, "TestEnumerated");
1681 1 : g_assert (asn != NULL);
1682 :
1683 1 : bytes = g_bytes_new_static (ENUM_NEGATIVE, XL (ENUM_NEGATIVE));
1684 1 : ret = egg_asn1x_decode (asn, bytes);
1685 1 : g_assert (ret == FALSE);
1686 1 : g_assert (strstr (egg_asn1x_message (asn), "enumerated must be positive") != NULL);
1687 1 : g_bytes_unref (bytes);
1688 :
1689 1 : egg_asn1x_destroy (asn);
1690 1 : }
1691 :
1692 : static void
1693 1 : test_enumerated_not_in_list (void)
1694 : {
1695 1 : const gchar ENUM_OTHER[] = "\x0A\x01\x08";
1696 1 : const gchar ENUM_LARGE[] = "\x0A\x20\x00\x01\x02\x03\x04\x05\x06\x07"
1697 : "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
1698 : "\x00\x01\x02\x03\x04\x05\x06\x07"
1699 : "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f";
1700 :
1701 : GBytes *bytes;
1702 : GNode *asn;
1703 : gboolean ret;
1704 :
1705 1 : asn = egg_asn1x_create (test_asn1_tab, "TestEnumerated");
1706 1 : g_assert (asn != NULL);
1707 :
1708 1 : bytes = g_bytes_new_static (ENUM_OTHER, XL (ENUM_OTHER));
1709 1 : ret = egg_asn1x_decode (asn, bytes);
1710 1 : g_assert (ret == FALSE);
1711 1 : g_assert (strstr (egg_asn1x_message (asn), "not part of list") != NULL);
1712 1 : g_bytes_unref (bytes);
1713 :
1714 1 : bytes = g_bytes_new_static (ENUM_LARGE, XL (ENUM_LARGE));
1715 1 : ret = egg_asn1x_decode (asn, bytes);
1716 1 : g_assert (ret == FALSE);
1717 1 : g_assert (strstr (egg_asn1x_message (asn), "not part of list") != NULL);
1718 1 : g_bytes_unref (bytes);
1719 :
1720 1 : egg_asn1x_destroy (asn);
1721 1 : }
1722 :
1723 : static void
1724 1 : test_enumerated_not_set (void)
1725 : {
1726 : GNode *asn;
1727 : GQuark value;
1728 :
1729 1 : asn = egg_asn1x_create (test_asn1_tab, "TestEnumerated");
1730 1 : g_assert (asn != NULL);
1731 :
1732 1 : value = egg_asn1x_get_enumerated (asn);
1733 1 : g_assert (value == 0);
1734 :
1735 1 : egg_asn1x_destroy (asn);
1736 1 : }
1737 :
1738 :
1739 : typedef struct {
1740 : GNode *asn1;
1741 : guchar *data;
1742 : gsize n_data;
1743 : } Test;
1744 :
1745 : static void
1746 14 : setup (Test *test, gconstpointer unused)
1747 : {
1748 : GBytes *bytes;
1749 :
1750 14 : if (!g_file_get_contents (SRCDIR "/egg/fixtures/test-certificate-1.der",
1751 14 : (gchar**)&test->data, &test->n_data, NULL))
1752 0 : g_assert_not_reached ();
1753 :
1754 14 : test->asn1 = egg_asn1x_create (pkix_asn1_tab, "Certificate");
1755 14 : g_assert (test->asn1 != NULL);
1756 :
1757 14 : bytes = g_bytes_new_static (test->data, test->n_data);
1758 14 : if (!egg_asn1x_decode (test->asn1, bytes))
1759 0 : g_assert_not_reached ();
1760 14 : g_bytes_unref (bytes);
1761 14 : }
1762 :
1763 : static void
1764 14 : teardown (Test *test, gconstpointer unused)
1765 : {
1766 14 : egg_asn1x_destroy (test->asn1);
1767 14 : g_free (test->data);
1768 14 : }
1769 :
1770 : static void
1771 1 : test_node_name (Test* test, gconstpointer unused)
1772 : {
1773 1 : g_assert_cmpstr (egg_asn1x_name (test->asn1), ==, "Certificate");
1774 1 : }
1775 :
1776 : static void
1777 1 : test_asn1_integers (Test* test, gconstpointer unused)
1778 : {
1779 : GBytes *data;
1780 : GNode *asn;
1781 : gboolean ret;
1782 : gulong val;
1783 :
1784 1 : asn = egg_asn1x_create (test_asn1_tab, "TestIntegers");
1785 1 : g_assert ("asn test structure is null" && asn != NULL);
1786 :
1787 1 : egg_asn1x_set_integer_as_ulong (egg_asn1x_node (asn, "uint1", NULL), 35);
1788 1 : egg_asn1x_set_integer_as_ulong (egg_asn1x_node (asn, "uint2", NULL), 23456);
1789 1 : egg_asn1x_set_integer_as_ulong (egg_asn1x_node (asn, "uint3", NULL), 209384022);
1790 :
1791 : /* Now encode the whole caboodle */
1792 1 : data = egg_asn1x_encode (asn, NULL);
1793 1 : g_assert ("encoding asn1 didn't work" && data != NULL);
1794 :
1795 1 : egg_asn1x_destroy (asn);
1796 :
1797 : /* Now decode it all nicely */
1798 1 : asn = egg_asn1x_create_and_decode (test_asn1_tab, "TestIntegers", data);
1799 1 : g_return_if_fail (asn != NULL);
1800 :
1801 : /* And get out the values */
1802 1 : ret = egg_asn1x_get_integer_as_ulong (egg_asn1x_node (asn, "uint1", NULL), &val);
1803 1 : g_assert ("couldn't read integer from asn1" && ret);
1804 1 : g_assert_cmpuint (val, ==, 35);
1805 :
1806 1 : ret = egg_asn1x_get_integer_as_ulong (egg_asn1x_node (asn, "uint2", NULL), &val);
1807 1 : g_assert ("couldn't read integer from asn1" && ret);
1808 1 : g_assert_cmpuint (val, ==, 23456);
1809 :
1810 1 : ret = egg_asn1x_get_integer_as_ulong (egg_asn1x_node (asn, "uint3", NULL), &val);
1811 1 : g_assert ("couldn't read integer from asn1" && ret);
1812 1 : g_assert_cmpuint (val, ==, 209384022);
1813 :
1814 1 : egg_asn1x_destroy (asn);
1815 1 : g_bytes_unref (data);
1816 : }
1817 :
1818 : static void
1819 1 : test_boolean_seq (Test* test, gconstpointer unused)
1820 : {
1821 : GBytes *data;
1822 1 : GNode *asn = NULL;
1823 : gboolean value, ret;
1824 :
1825 : /* The first boolean has a default of FALSE, so doesn't get encoded if FALSE */
1826 1 : const gchar SEQ_BOOLEAN_TRUE_FALSE[] = "\x30\x06\x01\x01\xFF\x01\x01\x00";
1827 1 : const gchar SEQ_BOOLEAN_FALSE_FALSE[] = "\x30\x03\x01\x01\x00";
1828 :
1829 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBooleanSeq");
1830 1 : g_assert ("asn test structure is null" && asn != NULL);
1831 :
1832 : /* Get the default value */
1833 1 : value = TRUE;
1834 1 : ret = egg_asn1x_get_boolean (egg_asn1x_node (asn, "boolean", NULL), &value);
1835 1 : g_assert (ret == TRUE);
1836 1 : g_assert (value == FALSE);
1837 :
1838 1 : egg_asn1x_set_boolean (egg_asn1x_node (asn, "boolean", NULL), TRUE);
1839 1 : egg_asn1x_set_boolean (egg_asn1x_node (asn, "boolean2", NULL), FALSE);
1840 :
1841 1 : data = egg_asn1x_encode (asn, NULL);
1842 1 : g_assert (data != NULL);
1843 1 : egg_assert_cmpbytes (data, ==, SEQ_BOOLEAN_TRUE_FALSE, XL (SEQ_BOOLEAN_TRUE_FALSE));
1844 1 : g_bytes_unref (data);
1845 :
1846 1 : ret = egg_asn1x_get_boolean (egg_asn1x_node (asn, "boolean", NULL), &value);
1847 1 : g_assert (ret);
1848 1 : g_assert (value == TRUE);
1849 :
1850 1 : egg_asn1x_set_boolean (egg_asn1x_node (asn, "boolean", NULL), FALSE);
1851 :
1852 1 : data = egg_asn1x_encode (asn, NULL);
1853 1 : g_assert (data != NULL);
1854 1 : egg_assert_cmpbytes (data, ==, SEQ_BOOLEAN_FALSE_FALSE, XL (SEQ_BOOLEAN_FALSE_FALSE));
1855 :
1856 1 : ret = egg_asn1x_get_boolean (egg_asn1x_node (asn, "boolean", NULL), &value);
1857 1 : g_assert (ret);
1858 1 : g_assert (value == FALSE);
1859 :
1860 1 : g_bytes_unref (data);
1861 1 : egg_asn1x_destroy (asn);
1862 1 : }
1863 :
1864 : static void
1865 1 : test_write_value (Test* test, gconstpointer unused)
1866 : {
1867 : GBytes *encoded;
1868 1 : GNode *asn = NULL;
1869 : guchar *data;
1870 : gsize n_data;
1871 :
1872 1 : asn = egg_asn1x_create (test_asn1_tab, "TestData");
1873 1 : g_assert ("asn test structure is null" && asn != NULL);
1874 :
1875 1 : egg_asn1x_set_string_as_raw (egg_asn1x_node (asn, "data", NULL), (guchar*)"SOME DATA", 9, NULL);
1876 :
1877 1 : encoded = egg_asn1x_encode (asn, NULL);
1878 1 : g_assert (encoded);
1879 :
1880 1 : data = egg_asn1x_get_string_as_raw (egg_asn1x_node (asn, "data", NULL), NULL, &n_data);
1881 1 : g_assert (data != NULL);
1882 1 : g_assert_cmpuint (n_data, ==, 9);
1883 1 : g_assert (memcmp (data, "SOME DATA", 9) == 0);
1884 1 : g_free (data);
1885 :
1886 1 : g_bytes_unref (encoded);
1887 1 : egg_asn1x_destroy (asn);
1888 1 : }
1889 :
1890 : static void
1891 1 : test_element_length_content (Test* test, gconstpointer unused)
1892 : {
1893 : GBytes *buffer;
1894 1 : GNode *asn = NULL;
1895 : const guchar *content;
1896 : gsize n_content;
1897 : gssize length;
1898 :
1899 1 : asn = egg_asn1x_create (test_asn1_tab, "TestData");
1900 1 : g_assert ("asn test structure is null" && asn != NULL);
1901 :
1902 1 : egg_asn1x_set_string_as_raw (egg_asn1x_node (asn, "data", NULL), (guchar*)"SOME DATA", 9, NULL);
1903 :
1904 1 : buffer = egg_asn1x_encode (asn, NULL);
1905 1 : g_assert (buffer != NULL);
1906 :
1907 : /* Now the real test */
1908 1 : length = egg_asn1x_element_length (g_bytes_get_data (buffer, NULL),
1909 1 : g_bytes_get_size (buffer) + 1024);
1910 1 : g_assert_cmpint (length, ==, 13);
1911 :
1912 1 : content = egg_asn1x_element_content (g_bytes_get_data (buffer, NULL),
1913 : length, &n_content);
1914 1 : g_assert (content != NULL);
1915 1 : g_assert_cmpuint (n_content, ==, 11);
1916 :
1917 1 : content = egg_asn1x_element_content (content, n_content, &n_content);
1918 1 : g_assert (content);
1919 1 : g_assert_cmpuint (n_content, ==, 9);
1920 1 : g_assert (memcmp (content, "SOME DATA", 9) == 0);
1921 :
1922 1 : const guchar *BAD_ASN_TAG = (guchar *)"\x00";
1923 1 : content = egg_asn1x_element_content (BAD_ASN_TAG, 1, &n_content);
1924 1 : g_assert (content == NULL);
1925 :
1926 1 : const guchar *BAD_ASN_LENGTH = (guchar *)"\x30\x80";
1927 1 : content = egg_asn1x_element_content (BAD_ASN_LENGTH, 2, &n_content);
1928 1 : g_assert (content == NULL);
1929 :
1930 1 : egg_asn1x_destroy (asn);
1931 1 : g_bytes_unref (buffer);
1932 1 : }
1933 :
1934 : static void
1935 1 : test_read_element (Test* test, gconstpointer unused)
1936 : {
1937 : GBytes *buffer;
1938 1 : GNode *asn = NULL;
1939 : GBytes *data;
1940 :
1941 1 : asn = egg_asn1x_create (test_asn1_tab, "TestData");
1942 1 : g_assert ("asn test structure is null" && asn != NULL);
1943 :
1944 1 : egg_asn1x_set_string_as_raw (egg_asn1x_node (asn, "data", NULL), (guchar*)"SOME DATA", 9, NULL);
1945 :
1946 1 : buffer = egg_asn1x_encode (asn, NULL);
1947 1 : g_assert (buffer != NULL);
1948 :
1949 : /* Have to decode before we can get raw elements */
1950 1 : if (!egg_asn1x_decode (asn, buffer))
1951 0 : g_assert_not_reached ();
1952 :
1953 : /* Now the real test */
1954 1 : data = egg_asn1x_get_element_raw (egg_asn1x_node (asn, "data", NULL));
1955 1 : g_assert (data != NULL);
1956 1 : g_assert_cmpint (g_bytes_get_size (data), ==, 11);
1957 1 : g_bytes_unref (data);
1958 :
1959 1 : data = egg_asn1x_get_value_raw (egg_asn1x_node (asn, "data", NULL));
1960 1 : g_assert (data != NULL);
1961 1 : egg_assert_cmpbytes (data, ==, "SOME DATA", 9);
1962 1 : g_bytes_unref (data);
1963 :
1964 1 : egg_asn1x_destroy (asn);
1965 1 : g_bytes_unref (buffer);
1966 1 : }
1967 :
1968 : static void
1969 1 : test_oid (void)
1970 : {
1971 : GBytes *buffer;
1972 1 : GNode *asn = NULL;
1973 : GNode *node;
1974 : GQuark oid, check;
1975 :
1976 1 : asn = egg_asn1x_create (test_asn1_tab, "TestOid");
1977 1 : g_assert ("asn test structure is null" && asn != NULL);
1978 :
1979 1 : node = egg_asn1x_node (asn, "oid", NULL);
1980 1 : g_assert_cmpint (EGG_ASN1X_OBJECT_ID, ==, egg_asn1x_type (node));
1981 :
1982 1 : if (!egg_asn1x_set_oid_as_string (node, "1.2.34567.89"))
1983 0 : g_assert_not_reached ();
1984 :
1985 1 : buffer = egg_asn1x_encode (asn, NULL);
1986 1 : g_assert (buffer != NULL);
1987 :
1988 : /* Now a quark has been defined */
1989 1 : check = g_quark_from_static_string ("1.2.34567.89");
1990 1 : oid = egg_asn1x_get_oid_as_quark (egg_asn1x_node (asn, "oid", NULL));
1991 1 : g_assert (oid);
1992 1 : g_assert (check == oid);
1993 1 : g_assert_cmpstr (g_quark_to_string (oid), ==, "1.2.34567.89");
1994 :
1995 : /* Write a different OID */
1996 1 : if (!egg_asn1x_set_oid_as_quark (egg_asn1x_node (asn, "oid", NULL), g_quark_from_static_string ("5.4.3.2.1678")))
1997 0 : g_assert_not_reached ();
1998 :
1999 1 : g_bytes_unref (buffer);
2000 1 : buffer = egg_asn1x_encode (asn, NULL);
2001 1 : g_assert (buffer != NULL);
2002 :
2003 1 : oid = egg_asn1x_get_oid_as_quark (egg_asn1x_node (asn, "oid", NULL));
2004 1 : g_assert (oid);
2005 1 : g_assert_cmpstr (g_quark_to_string (oid), ==, "5.4.3.2.1678");
2006 :
2007 1 : g_bytes_unref (buffer);
2008 1 : egg_asn1x_destroy (asn);
2009 1 : }
2010 :
2011 : static void
2012 1 : test_oid_set_invalid (void)
2013 : {
2014 : GNode *asn;
2015 :
2016 1 : asn = egg_asn1x_create (test_asn1_tab, "TestOid");
2017 1 : g_assert ("asn test structure is null" && asn != NULL);
2018 :
2019 1 : if (egg_asn1x_set_oid_as_string (egg_asn1x_node (asn, "oid", NULL), "abcd"))
2020 0 : g_assert_not_reached ();
2021 :
2022 1 : egg_asn1x_destroy (asn);
2023 1 : }
2024 :
2025 : static void
2026 1 : test_oid_decode_bad (void)
2027 : {
2028 : GBytes *bytes;
2029 : GNode *asn;
2030 : gboolean ret;
2031 :
2032 : /* Has invalid leading integer in oid value */
2033 1 : const gchar INVALID_OID[] = "\x30\x07\x06\x05\x2b\x80\x83\x82\x1a";
2034 :
2035 1 : asn = egg_asn1x_create (test_asn1_tab, "TestOid");
2036 1 : g_assert ("asn test structure is null" && asn != NULL);
2037 :
2038 1 : bytes = g_bytes_new_static (INVALID_OID, XL (INVALID_OID));
2039 1 : ret = egg_asn1x_decode (asn, bytes);
2040 1 : g_assert (ret == FALSE);
2041 1 : g_assert (strstr (egg_asn1x_message (asn), "object id encoding is invalid") != NULL);
2042 :
2043 1 : g_bytes_unref (bytes);
2044 1 : egg_asn1x_destroy (asn);
2045 1 : }
2046 :
2047 : static void
2048 1 : test_oid_get_no_value (void)
2049 : {
2050 : GNode *asn;
2051 : gchar *oid;
2052 :
2053 1 : asn = egg_asn1x_create (test_asn1_tab, "TestOid");
2054 1 : g_assert ("asn test structure is null" && asn != NULL);
2055 :
2056 1 : oid = egg_asn1x_get_oid_as_string (egg_asn1x_node (asn, "oid", NULL));
2057 1 : g_assert (oid == NULL);
2058 :
2059 1 : egg_asn1x_destroy (asn);
2060 1 : }
2061 :
2062 : typedef struct _TimeTestData {
2063 : gchar *value;
2064 : time_t ref;
2065 : } TimeTestData;
2066 :
2067 : static const TimeTestData generalized_time_test_data[] = {
2068 : { "20070725130528Z", 1185368728 },
2069 : { "20070725130528.2134Z", 1185368728 },
2070 : { "20070725140528-0100", 1185368728 },
2071 : { "20070725040528+0900", 1185368728 },
2072 : { "20070725013528+1130", 1185368728 },
2073 : { "20070725Z", 1185321600 },
2074 : { "20070725+0000", 1185321600 },
2075 :
2076 : /* Bad ones */
2077 : { "200707", -1 },
2078 :
2079 : { NULL, 0 }
2080 : };
2081 :
2082 : static const TimeTestData utc_time_test_data[] = {
2083 : /* Test the Y2K style wrap arounds */
2084 : { "070725130528Z", 1185368728 }, /* The year 2007 */
2085 : { "020725130528Z", 1027602328 }, /* The year 2002 */
2086 : { "970725130528Z", 869835928 }, /* The year 1997 */
2087 : { "370725130528Z", 2132139928 }, /* The year 2037 */
2088 :
2089 : /* Test the time zones and other formats */
2090 : { "070725130528.2134Z", 1185368728 },
2091 : { "070725140528-0100", 1185368728 },
2092 : { "070725040528+0900", 1185368728 },
2093 : { "070725013528+1130", 1185368728 },
2094 : { "070725Z", 1185321600 },
2095 : { "070725+0000", 1185321600 },
2096 :
2097 : /* Bad ones */
2098 : { "0707", -1 },
2099 :
2100 : { NULL, 0 }
2101 : };
2102 :
2103 : static void
2104 1 : test_general_time (Test* test, gconstpointer unused)
2105 : {
2106 : time_t when;
2107 : const TimeTestData *data;
2108 :
2109 9 : for (data = generalized_time_test_data; data->value; ++data) {
2110 8 : when = egg_asn1x_parse_time_general (data->value, -1);
2111 8 : if (data->ref != when) {
2112 0 : printf ("%s", data->value);
2113 0 : printf ("%s != ", ctime (&when));
2114 0 : printf ("%s\n", ctime (&data->ref));
2115 0 : fflush (stdout);
2116 : }
2117 :
2118 8 : g_assert ("decoded time doesn't match reference" && data->ref == when);
2119 : }
2120 1 : }
2121 :
2122 : static void
2123 1 : test_utc_time (Test* test, gconstpointer unused)
2124 : {
2125 : time_t when;
2126 : const TimeTestData *data;
2127 :
2128 12 : for (data = utc_time_test_data; data->value; ++data) {
2129 11 : when = egg_asn1x_parse_time_utc (data->value, -1);
2130 11 : if (data->ref != when) {
2131 0 : printf ("%s", data->value);
2132 0 : printf ("%s != ", ctime (&when));
2133 0 : printf ("%s\n", ctime (&data->ref));
2134 0 : fflush (stdout);
2135 : }
2136 :
2137 11 : g_assert ("decoded time doesn't match reference" && data->ref == when);
2138 : }
2139 1 : }
2140 :
2141 : static void
2142 1 : test_read_time (Test* test, gconstpointer unused)
2143 : {
2144 : glong time;
2145 :
2146 1 : time = egg_asn1x_get_time_as_long (egg_asn1x_node (test->asn1, "tbsCertificate", "validity", "notBefore", NULL));
2147 1 : g_assert_cmpint (time, ==, 820454400);
2148 1 : }
2149 :
2150 : static void
2151 1 : test_read_date (Test* test, gconstpointer unused)
2152 : {
2153 : GDate date;
2154 1 : if (!egg_asn1x_get_time_as_date (egg_asn1x_node (test->asn1, "tbsCertificate", "validity", "notAfter", NULL), &date))
2155 0 : g_assert_not_reached ();
2156 1 : g_assert_cmpint (date.day, ==, 31);
2157 1 : g_assert_cmpint (date.month, ==, 12);
2158 1 : g_assert_cmpint (date.year, ==, 2020);
2159 1 : }
2160 :
2161 : static void
2162 1 : test_create_by_oid (Test* test, gconstpointer unused)
2163 : {
2164 : /* id-at-initials = X520initials */
2165 1 : GNode *node = egg_asn1x_create (pkix_asn1_tab, "2.5.4.43");
2166 1 : g_assert (node != NULL);
2167 1 : g_assert_cmpstr (egg_asn1x_name (node), ==, "X520initials");
2168 1 : egg_asn1x_destroy (node);
2169 1 : }
2170 :
2171 : static void
2172 1 : test_create_by_oid_invalid (Test* test, gconstpointer unused)
2173 : {
2174 1 : GNode *node = egg_asn1x_create (pkix_asn1_tab, "23.23.23.23");
2175 1 : g_assert (node == NULL);
2176 1 : }
2177 :
2178 : static void
2179 1 : test_create_by_bad_order (Test* test, gconstpointer unused)
2180 : {
2181 : /*
2182 : * In pkix.asn the definition for parts of this oid
2183 : * come in the wrong order. However this should still work.
2184 : */
2185 :
2186 : /* id-pe-authorityInfoAccess = AuthorityInfoAccessSyntax */
2187 1 : GNode *node = egg_asn1x_create (pkix_asn1_tab, "1.3.6.1.5.5.7.1.1");
2188 1 : g_assert (node != NULL);
2189 1 : g_assert_cmpstr (egg_asn1x_name (node), ==, "AuthorityInfoAccessSyntax");
2190 1 : egg_asn1x_destroy (node);
2191 1 : }
2192 :
2193 : static void
2194 1 : test_count (Test* test, gconstpointer unused)
2195 : {
2196 : GNode *node;
2197 :
2198 1 : node = egg_asn1x_node (test->asn1, "tbsCertificate", "issuer", "rdnSequence", NULL);
2199 1 : g_assert (node);
2200 1 : g_assert_cmpuint (egg_asn1x_count (node), ==, 7);
2201 1 : }
2202 :
2203 : static void
2204 1 : test_nested_fails_with_extra (void)
2205 : {
2206 : gboolean ret;
2207 : GBytes *bytes;
2208 : GNode *asn;
2209 :
2210 1 : const gchar SEQ_NESTED[] = "\x30\x0C"
2211 : "\x04\x03""one"
2212 : "\x04\x05""extra";
2213 :
2214 1 : asn = egg_asn1x_create (test_asn1_tab, "TestData");
2215 1 : g_assert ("asn test structure is null" && asn != NULL);
2216 :
2217 1 : bytes = g_bytes_new_static (SEQ_NESTED, XL (SEQ_NESTED));
2218 1 : ret = egg_asn1x_decode (asn, bytes);
2219 1 : egg_asn1x_assert (ret == FALSE, asn);
2220 1 : egg_asn1x_assert (strstr (egg_asn1x_message (asn), "encountered extra tag"), asn);
2221 1 : g_bytes_unref (bytes);
2222 :
2223 1 : egg_asn1x_destroy (asn);
2224 1 : }
2225 :
2226 : static void
2227 1 : test_nested_unexpected (void)
2228 : {
2229 : gboolean ret;
2230 : GBytes *bytes;
2231 : GNode *asn;
2232 :
2233 1 : const gchar SEQ_NESTED[] = "\x30\x03"
2234 : "\x02\x01\x2A";
2235 :
2236 1 : asn = egg_asn1x_create (test_asn1_tab, "TestData");
2237 1 : g_assert ("asn test structure is null" && asn != NULL);
2238 :
2239 1 : bytes = g_bytes_new_static (SEQ_NESTED, XL (SEQ_NESTED));
2240 1 : ret = egg_asn1x_decode (asn, bytes);
2241 1 : egg_asn1x_assert (ret == FALSE, asn);
2242 1 : egg_asn1x_assert (strstr (egg_asn1x_message (asn), "decoded tag did not match expected"), asn);
2243 1 : g_bytes_unref (bytes);
2244 :
2245 1 : egg_asn1x_destroy (asn);
2246 1 : }
2247 :
2248 : static void
2249 1 : test_create_and_decode_invalid (void)
2250 : {
2251 : GBytes *bytes;
2252 : GNode *asn;
2253 :
2254 1 : bytes = g_bytes_new_static ("", 0);
2255 1 : asn = egg_asn1x_create_and_decode (test_asn1_tab, "TestData", bytes);
2256 1 : g_assert (asn == NULL);
2257 1 : g_bytes_unref (bytes);
2258 1 : }
2259 :
2260 : static void
2261 1 : test_decode_extra (void)
2262 : {
2263 : GBytes *bytes;
2264 : GNode *asn;
2265 :
2266 1 : asn = egg_asn1x_create (test_asn1_tab, "TestSeqOf");
2267 1 : g_assert (asn != NULL);
2268 :
2269 1 : bytes = g_bytes_new_static ("\x30\x00\x11", 3);
2270 1 : if (egg_asn1x_decode (asn, bytes))
2271 0 : g_assert_not_reached ();
2272 1 : g_assert (strstr (egg_asn1x_message (asn), "extra unexpected trailing data"));
2273 1 : g_bytes_unref (bytes);
2274 1 : egg_asn1x_destroy (asn);
2275 1 : }
2276 :
2277 : static void
2278 1 : test_decode_nested_short (void)
2279 : {
2280 : GBytes *bytes;
2281 : GNode *asn;
2282 :
2283 1 : asn = egg_asn1x_create (test_asn1_tab, "TestSeqOfAny");
2284 1 : g_assert (asn != NULL);
2285 :
2286 1 : bytes = g_bytes_new_static ("\x30\x02\xA5\x08", 4);
2287 1 : if (egg_asn1x_decode (asn, bytes))
2288 0 : g_assert_not_reached ();
2289 1 : g_assert (strstr (egg_asn1x_message (asn), "content is not encoded properly"));
2290 1 : g_bytes_unref (bytes);
2291 :
2292 1 : bytes = g_bytes_new_static ("\x30\x04\x30\x02\xA5\x08", 6);
2293 1 : if (egg_asn1x_decode (asn, bytes))
2294 0 : g_assert_not_reached ();
2295 1 : g_assert (strstr (egg_asn1x_message (asn), "content is not encoded properly"));
2296 1 : g_bytes_unref (bytes);
2297 :
2298 1 : egg_asn1x_destroy (asn);
2299 1 : }
2300 :
2301 : static void
2302 1 : test_decode_indefinite_primitive (void)
2303 : {
2304 : GBytes *bytes;
2305 : GNode *asn;
2306 :
2307 1 : asn = egg_asn1x_create (test_asn1_tab, "TestInteger");
2308 1 : g_assert (asn != NULL);
2309 :
2310 1 : bytes = g_bytes_new_static ("\x04\x80\x04\x01\x55\x00\x00", 7);
2311 1 : if (egg_asn1x_decode (asn, bytes))
2312 0 : g_assert_not_reached ();
2313 1 : g_assert (strstr (egg_asn1x_message (asn), "indefinite length on non-structured type"));
2314 1 : g_bytes_unref (bytes);
2315 :
2316 1 : egg_asn1x_destroy (asn);
2317 1 : }
2318 :
2319 : static void
2320 1 : test_decode_invalid_long_length (void)
2321 : {
2322 : GBytes *bytes;
2323 : GNode *asn;
2324 :
2325 1 : const gchar DER[] = "\x04\xA0"
2326 : "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01"
2327 : "\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01";
2328 1 : asn = egg_asn1x_create (test_asn1_tab, "TestInteger");
2329 1 : g_assert (asn != NULL);
2330 :
2331 1 : bytes = g_bytes_new_static (DER, XL (DER));
2332 1 : if (egg_asn1x_decode (asn, bytes))
2333 0 : g_assert_not_reached ();
2334 1 : g_assert (strstr (egg_asn1x_message (asn), "content is not encoded properly"));
2335 1 : g_bytes_unref (bytes);
2336 :
2337 1 : egg_asn1x_destroy (asn);
2338 1 : }
2339 :
2340 : static void
2341 1 : test_decode_truncated_at_tag (void)
2342 : {
2343 : GBytes *bytes;
2344 : GNode *asn;
2345 :
2346 1 : const gchar DER[] = "\x04";
2347 1 : asn = egg_asn1x_create (test_asn1_tab, "TestInteger");
2348 1 : g_assert (asn != NULL);
2349 :
2350 1 : bytes = g_bytes_new_static (DER, XL (DER));
2351 1 : if (egg_asn1x_decode (asn, bytes))
2352 0 : g_assert_not_reached ();
2353 1 : g_assert (strstr (egg_asn1x_message (asn), "content is not encoded properly"));
2354 1 : g_bytes_unref (bytes);
2355 :
2356 1 : egg_asn1x_destroy (asn);
2357 1 : }
2358 :
2359 : static void
2360 1 : test_decode_long_tag (void)
2361 : {
2362 : GBytes *bytes;
2363 : GNode *asn;
2364 : gboolean ret;
2365 :
2366 1 : const gchar DER[] = "\xbf\x89\x52\x03\x04\x01\x33";
2367 :
2368 1 : asn = egg_asn1x_create (test_asn1_tab, "TestTagLong");
2369 1 : g_assert (asn != NULL);
2370 :
2371 1 : bytes = g_bytes_new_static (DER, XL (DER));
2372 1 : ret = egg_asn1x_decode (asn, bytes);
2373 1 : egg_asn1x_assert (ret == TRUE, asn);
2374 :
2375 1 : g_bytes_unref (bytes);
2376 1 : egg_asn1x_destroy (asn);
2377 :
2378 1 : }
2379 :
2380 : static void
2381 1 : test_create_quark (void)
2382 : {
2383 : GNode *asn;
2384 :
2385 1 : asn = egg_asn1x_create_quark (test_asn1_tab, g_quark_from_static_string ("1.5.13"));
2386 1 : g_assert (asn != NULL);
2387 1 : g_assert_cmpstr (egg_asn1x_name (asn), ==, "TestIntegers");
2388 1 : egg_asn1x_destroy (asn);
2389 1 : }
2390 :
2391 : static void
2392 1 : test_validate_default (void)
2393 : {
2394 : GNode *asn;
2395 :
2396 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBooleanSeq");
2397 : /* We leave first boolean field empty */
2398 1 : egg_asn1x_set_boolean (egg_asn1x_node (asn, "boolean2", NULL), TRUE);
2399 1 : if (!egg_asn1x_validate (asn, TRUE))
2400 0 : g_assert_not_reached ();
2401 1 : egg_asn1x_destroy (asn);
2402 1 : }
2403 :
2404 : static void
2405 1 : test_validate_missing (void)
2406 : {
2407 : GNode *asn;
2408 :
2409 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBooleanSeq");
2410 : /* No fields set */
2411 1 : if (egg_asn1x_validate (asn, TRUE))
2412 0 : g_assert_not_reached ();
2413 1 : g_assert (strstr (egg_asn1x_message (asn), "missing value") != NULL);
2414 1 : egg_asn1x_destroy (asn);
2415 1 : }
2416 :
2417 : static void
2418 1 : test_validate_seq_of_child_invalid (void)
2419 : {
2420 : GNode *asn;
2421 : GNode *child;
2422 :
2423 1 : asn = egg_asn1x_create (test_asn1_tab, "TestSeqOfSeq");
2424 1 : child = egg_asn1x_append (asn);
2425 1 : egg_asn1x_set_integer_as_ulong (egg_asn1x_node (child, "uint1", NULL), 5);
2426 : /* We didn't set uint2 or uint3 so the child is invalid */
2427 1 : if (egg_asn1x_validate (asn, TRUE))
2428 0 : g_assert_not_reached ();
2429 1 : g_assert (strstr (egg_asn1x_message (asn), "missing value") != NULL);
2430 1 : egg_asn1x_destroy (asn);
2431 :
2432 1 : }
2433 :
2434 : static void
2435 1 : test_validate_optional_seq (void)
2436 : {
2437 : GNode *asn;
2438 :
2439 1 : asn = egg_asn1x_create (test_asn1_tab, "TestSeqOptional");
2440 1 : if (!egg_asn1x_validate (asn, TRUE))
2441 0 : g_assert_not_reached ();
2442 1 : egg_asn1x_destroy (asn);
2443 1 : }
2444 :
2445 : static void
2446 1 : test_element_get_not_set (void)
2447 : {
2448 : GNode *asn;
2449 :
2450 1 : asn = egg_asn1x_create (test_asn1_tab, "TestBooleanSeq");
2451 1 : g_assert (egg_asn1x_get_element_raw (asn) == NULL);
2452 1 : egg_asn1x_destroy (asn);
2453 1 : }
2454 :
2455 : int
2456 1 : main (int argc, char **argv)
2457 : {
2458 1 : g_test_init (&argc, &argv, NULL);
2459 :
2460 1 : g_test_add_func ("/asn1/decode/extra", test_decode_extra);
2461 1 : g_test_add_func ("/asn1/decode/nested-short", test_decode_nested_short);
2462 1 : g_test_add_func ("/asn1/decode/indefinite-primitive", test_decode_indefinite_primitive);
2463 1 : g_test_add_func ("/asn1/decode/invalid-long-length", test_decode_invalid_long_length);
2464 1 : g_test_add_func ("/asn1/decode/truncated-at-tag", test_decode_truncated_at_tag);
2465 1 : g_test_add_func ("/asn1/decode/decode-long-tag", test_decode_long_tag);
2466 1 : g_test_add_func ("/asn1/boolean", test_boolean);
2467 1 : g_test_add_func ("/asn1/boolean-bad", test_boolean_decode_bad);
2468 1 : g_test_add_func ("/asn1/boolean-default", test_boolean_default);
2469 1 : g_test_add_func ("/asn1/null", test_null);
2470 1 : g_test_add_func ("/asn1/integer", test_integer);
2471 1 : g_test_add_func ("/asn1/integer-zero-length", test_integer_zero_length);
2472 1 : g_test_add_func ("/asn1/integer/raw", test_integer_raw);
2473 1 : g_test_add_func ("/asn1/integer/raw-not-twos-complement", test_integer_raw_not_twos_complement);
2474 1 : g_test_add_func ("/asn1/integer/raw-not-twos-complement/subprocess", test_integer_raw_not_twos_complement_subprocess);
2475 1 : g_test_add_func ("/asn1/unsigned", test_unsigned);
2476 1 : g_test_add_func ("/asn1/unsigned/not-set", test_unsigned_not_set);
2477 1 : g_test_add_func ("/asn1/unsigned/default", test_unsigned_default);
2478 1 : g_test_add_func ("/asn1/unsigned/constant", test_unsigned_constant);
2479 1 : g_test_add_func ("/asn1/unsigned/zero", test_unsigned_zero);
2480 1 : g_test_add_func ("/asn1/octet_string", test_octet_string);
2481 1 : g_test_add_func ("/asn1/octet-string/set-bad-utf8", test_octet_string_set_bad_utf8);
2482 1 : g_test_add_func ("/asn1/octet-string/bmp-as-utf8", test_octet_string_bmp_as_utf8);
2483 1 : g_test_add_func ("/asn1/octet-string/get-as-bytes", test_octet_string_get_as_bytes);
2484 1 : g_test_add_func ("/asn1/octet-string/set-as-bytes", test_octet_string_set_as_bytes);
2485 1 : g_test_add_func ("/asn1/octet-string/structured", test_octet_string_structured);
2486 1 : g_test_add_func ("/asn1/octet-string/structured-bad", test_octet_string_structured_bad);
2487 1 : g_test_add_func ("/asn1/generalized_time", test_generalized_time);
2488 1 : g_test_add_func ("/asn1/time-get-missing", test_time_get_missing);
2489 1 : g_test_add_func ("/asn1/implicit/decode", test_implicit_decode);
2490 1 : g_test_add_func ("/asn1/implicit/encode", test_implicit_encode);
2491 1 : g_test_add_func ("/asn1/explicit/decode", test_explicit_decode);
2492 1 : g_test_add_func ("/asn1/explicit/encode", test_explicit_encode);
2493 1 : g_test_add_func ("/asn1/explicit/no-context-specific", test_explicit_no_context_specific);
2494 1 : g_test_add_func ("/asn1/explicit/no-context-child", test_explicit_no_context_child);
2495 1 : g_test_add_func ("/asn1/explicit/extra-context-child", test_explicit_extra_context_child);
2496 1 : g_test_add_func ("/asn1/universal/decode", test_universal_decode);
2497 1 : g_test_add_func ("/asn1/universal/encode", test_universal_encode);
2498 1 : g_test_add_func ("/asn1/bit_string_decode", test_bit_string_decode);
2499 1 : g_test_add_func ("/asn1/bit_string_decode_bad", test_bit_string_decode_bad);
2500 1 : g_test_add_func ("/asn1/bit_string_decode_ulong", test_bit_string_decode_ulong);
2501 1 : g_test_add_func ("/asn1/bit_string_encode_decode", test_bit_string_encode_decode);
2502 1 : g_test_add_func ("/asn1/bit_string_encode_decode_ulong", test_bit_string_encode_decode_ulong);
2503 1 : g_test_add_func ("/asn1/bit_string_encode_decode_zero", test_bit_string_encode_decode_zero);
2504 1 : g_test_add_func ("/asn1/bit-string/ulong-too-long", test_bit_string_ulong_too_long);
2505 1 : g_test_add_func ("/asn1/bit-string/get-not-set", test_bit_string_get_not_set);
2506 1 : g_test_add_func ("/asn1/bit-string/invalid-length", test_bit_string_invalid_length);
2507 1 : g_test_add_func ("/asn1/bit-string/invalid-empty", test_bit_string_invalid_empty);
2508 1 : g_test_add_func ("/asn1/oid", test_oid);
2509 1 : g_test_add_func ("/asn1/oid/set-invalid", test_oid_set_invalid);
2510 1 : g_test_add_func ("/asn1/oid/get-no-value", test_oid_get_no_value);
2511 1 : g_test_add_func ("/asn1/oid/decode-bad", test_oid_decode_bad);
2512 1 : g_test_add_func ("/asn1/have", test_have);
2513 1 : g_test_add_func ("/asn1/any-raw", test_any_raw);
2514 1 : g_test_add_func ("/asn1/any-raw/explicit", test_any_raw_explicit);
2515 1 : g_test_add_func ("/asn1/any-raw/invalid", test_any_raw_invalid);
2516 1 : g_test_add_func ("/asn1/any-raw/not-set", test_any_raw_not_set);
2517 1 : g_test_add_func ("/asn1/any-into", test_any_into);
2518 1 : g_test_add_func ("/asn1/any-into/explicit", test_any_into_explicit);
2519 1 : g_test_add_func ("/asn1/any-into/explicit-not-set", test_any_into_explicit_not_set);
2520 1 : g_test_add_func ("/asn1/choice_not_chosen", test_choice_not_chosen);
2521 1 : g_test_add_func ("/asn1/any_choice_set_raw_short_tag", test_any_choice_set_raw_short_tag);
2522 1 : g_test_add_func ("/asn1/any_choice_set_raw_long_tag", test_any_choice_set_raw_long_tag);
2523 1 : g_test_add_func ("/asn1/seq-of-any", test_seq_of_any);\
2524 1 : g_test_add_func ("/asn1/seq-of-invalid", test_seq_of_invalid);
2525 1 : g_test_add_func ("/asn1/seq-of-different", test_seq_of_different);
2526 1 : g_test_add_func ("/asn1/set-order", test_set_order);
2527 1 : g_test_add_func ("/asn1/append", test_append);
2528 1 : g_test_add_func ("/asn1/append_and_clear", test_append_and_clear);
2529 1 : g_test_add_func ("/asn1/setof", test_setof);
2530 1 : g_test_add_func ("/asn1/setof_empty", test_setof_empty);
2531 1 : g_test_add_func ("/asn1/enumerated", test_enumerated);
2532 1 : g_test_add_func ("/asn1/enumerated-bad", test_enumerated_decode_bad);
2533 1 : g_test_add_func ("/asn1/enumerated-not-in-list", test_enumerated_not_in_list);
2534 1 : g_test_add_func ("/asn1/enumerated-not-set", test_enumerated_not_set);
2535 1 : g_test_add_func ("/asn1/nested-fails-with-extra", test_nested_fails_with_extra);
2536 1 : g_test_add_func ("/asn1/nested-unexpected", test_nested_unexpected);
2537 1 : g_test_add_func ("/asn1/create-and-decode-invalid", test_create_and_decode_invalid);
2538 1 : g_test_add_func ("/asn1/create-quark", test_create_quark);
2539 1 : g_test_add_func ("/asn1/validate-default", test_validate_default);
2540 1 : g_test_add_func ("/asn1/validate-missing", test_validate_missing);
2541 1 : g_test_add_func ("/asn1/validate-seq-of-child-invalid", test_validate_seq_of_child_invalid);
2542 1 : g_test_add_func ("/asn1/validate-optional-seq", test_validate_optional_seq);
2543 1 : g_test_add_func ("/asn1/get-element/not-set", test_element_get_not_set);
2544 1 : g_test_add ("/asn1/node_name", Test, NULL, setup, test_node_name, teardown);
2545 1 : g_test_add ("/asn1/asn1_integers", Test, NULL, setup, test_asn1_integers, teardown);
2546 1 : g_test_add ("/asn1/boolean_seq", Test, NULL, setup, test_boolean_seq, teardown);
2547 1 : g_test_add ("/asn1/write_value", Test, NULL, setup, test_write_value, teardown);
2548 1 : g_test_add ("/asn1/element_length_content", Test, NULL, setup, test_element_length_content, teardown);
2549 1 : g_test_add ("/asn1/read_element", Test, NULL, setup, test_read_element, teardown);
2550 1 : g_test_add ("/asn1/general_time", Test, NULL, setup, test_general_time, teardown);
2551 1 : g_test_add ("/asn1/utc_time", Test, NULL, setup, test_utc_time, teardown);
2552 1 : g_test_add ("/asn1/read_time", Test, NULL, setup, test_read_time, teardown);
2553 1 : g_test_add ("/asn1/read_date", Test, NULL, setup, test_read_date, teardown);
2554 1 : g_test_add ("/asn1/create_by_oid", Test, NULL, setup, test_create_by_oid, teardown);
2555 1 : g_test_add ("/asn1/create_by_oid_invalid", Test, NULL, setup, test_create_by_oid_invalid, teardown);
2556 1 : g_test_add ("/asn1/create_by_bad_order", Test, NULL, setup, test_create_by_bad_order, teardown);
2557 1 : g_test_add ("/asn1/count", Test, NULL, setup, test_count, teardown);
2558 :
2559 1 : return g_test_run ();
2560 : }
|
