Line data Source code
1 : /* Copyright (c) 2001-2004, Roger Dingledine.
2 : * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
3 : * Copyright (c) 2007-2021, The Tor Project, Inc. */
4 : /* See LICENSE for licensing information */
5 :
6 : #include "core/or/or.h"
7 : #include "test/test.h"
8 : #include "lib/memarea/memarea.h"
9 : #include "lib/encoding/binascii.h"
10 : #include "feature/dirparse/parsecommon.h"
11 : #include "test/log_test_helpers.h"
12 :
13 : static void
14 1 : test_parsecommon_tokenize_string_null(void *arg)
15 : {
16 :
17 1 : memarea_t *area = memarea_new();
18 1 : smartlist_t *tokens = smartlist_new();
19 :
20 1 : (void)arg;
21 :
22 1 : const char *str_with_null = "a\0bccccccccc";
23 :
24 1 : int retval =
25 1 : tokenize_string(area, str_with_null,
26 : str_with_null + 3,
27 : tokens, NULL, 0);
28 :
29 1 : tt_int_op(retval, OP_EQ, -1);
30 :
31 1 : done:
32 1 : memarea_drop_all(area);
33 1 : smartlist_free(tokens);
34 1 : return;
35 : }
36 :
37 : static void
38 1 : test_parsecommon_tokenize_string_multiple_lines(void *arg)
39 : {
40 1 : memarea_t *area = memarea_new();
41 1 : smartlist_t *tokens = smartlist_new();
42 :
43 1 : (void)arg;
44 :
45 1 : token_rule_t table[] = {
46 : T01("uptime", K_UPTIME, GE(1), NO_OBJ),
47 : T01("hibernating", K_HIBERNATING, GE(1), NO_OBJ),
48 : T1( "published", K_PUBLISHED, CONCAT_ARGS, NO_OBJ),
49 : END_OF_TABLE,
50 : };
51 :
52 1 : char *str = tor_strdup(
53 : "hibernating 0\nuptime 1024\n"
54 : "published 2018-10-15 10:00:00\n");
55 :
56 1 : int retval =
57 1 : tokenize_string(area, str, NULL,
58 : tokens, table, 0);
59 :
60 1 : tt_int_op(smartlist_len(tokens), OP_EQ, 3);
61 1 : directory_token_t *token = smartlist_get(tokens, 0);
62 :
63 1 : tt_int_op(token->tp, OP_EQ, K_HIBERNATING);
64 :
65 1 : token = smartlist_get(tokens, 1);
66 :
67 1 : tt_int_op(token->tp, OP_EQ, K_UPTIME);
68 :
69 1 : token = smartlist_get(tokens, 2);
70 :
71 1 : tt_int_op(token->tp, OP_EQ, K_PUBLISHED);
72 :
73 1 : tt_int_op(retval, OP_EQ, 0);
74 :
75 1 : done:
76 1 : tor_free(str);
77 1 : memarea_drop_all(area);
78 1 : smartlist_free(tokens);
79 1 : return;
80 : }
81 :
82 : static void
83 1 : test_parsecommon_tokenize_string_min_cnt(void *arg)
84 : {
85 1 : memarea_t *area = memarea_new();
86 1 : smartlist_t *tokens = smartlist_new();
87 :
88 1 : (void)arg;
89 :
90 1 : token_rule_t table[] = {
91 : T01("uptime", K_UPTIME, EQ(2), NO_OBJ),
92 : T01("hibernating", K_HIBERNATING, GE(1), NO_OBJ),
93 : END_OF_TABLE,
94 : };
95 :
96 : // Missing "uptime"
97 1 : char *str = tor_strdup("uptime 1024\nhibernating 0\n");
98 :
99 1 : int retval =
100 1 : tokenize_string(area, str, NULL,
101 : tokens, table, 0);
102 :
103 1 : tt_int_op(retval, OP_EQ, -1);
104 :
105 1 : done:
106 1 : tor_free(str);
107 1 : memarea_drop_all(area);
108 1 : smartlist_free(tokens);
109 1 : return;
110 : }
111 :
112 : static void
113 1 : test_parsecommon_tokenize_string_max_cnt(void *arg)
114 : {
115 1 : memarea_t *area = memarea_new();
116 1 : smartlist_t *tokens = smartlist_new();
117 :
118 1 : (void)arg;
119 :
120 1 : token_rule_t table[] = {
121 : T01("uptime", K_UPTIME, EQ(1), NO_OBJ),
122 : T01("hibernating", K_HIBERNATING, GE(1), NO_OBJ),
123 : END_OF_TABLE,
124 : };
125 :
126 : // "uptime" expected once, but occurs twice in input.
127 1 : char *str = tor_strdup(
128 : "uptime 1024\nuptime 2048\nhibernating 0\n");
129 :
130 1 : int retval =
131 1 : tokenize_string(area, str, NULL,
132 : tokens, table, 0);
133 :
134 1 : tt_int_op(retval, OP_EQ, -1);
135 :
136 1 : done:
137 1 : tor_free(str);
138 1 : memarea_drop_all(area);
139 1 : smartlist_free(tokens);
140 1 : return;
141 : }
142 :
143 : static void
144 1 : test_parsecommon_tokenize_string_at_start(void *arg)
145 : {
146 1 : memarea_t *area = memarea_new();
147 1 : smartlist_t *tokens = smartlist_new();
148 :
149 1 : (void)arg;
150 :
151 1 : token_rule_t table[] = {
152 : T1_START("client-name", C_CLIENT_NAME, CONCAT_ARGS, NO_OBJ),
153 : T01("uptime", K_UPTIME, EQ(1), NO_OBJ),
154 : END_OF_TABLE,
155 : };
156 :
157 : // "client-name" is not the first line.
158 1 : char *str = tor_strdup(
159 : "uptime 1024\nclient-name Alice\n");
160 :
161 1 : int retval =
162 1 : tokenize_string(area, str, NULL, tokens, table, 0);
163 :
164 1 : tt_int_op(retval, OP_EQ, -1);
165 :
166 1 : done:
167 1 : tor_free(str);
168 1 : memarea_drop_all(area);
169 1 : smartlist_free(tokens);
170 1 : return;
171 : }
172 :
173 : static void
174 1 : test_parsecommon_tokenize_string_at_end(void *arg)
175 : {
176 1 : memarea_t *area = memarea_new();
177 1 : smartlist_t *tokens = smartlist_new();
178 :
179 1 : (void)arg;
180 :
181 1 : token_rule_t table[] = {
182 : T1_END("client-name", C_CLIENT_NAME, CONCAT_ARGS, NO_OBJ),
183 : T01("uptime", K_UPTIME, EQ(1), NO_OBJ),
184 : END_OF_TABLE,
185 : };
186 :
187 : // "client-name" is not the last line.
188 1 : char *str = tor_strdup(
189 : "client-name Alice\nuptime 1024\n");
190 :
191 1 : int retval =
192 1 : tokenize_string(area, str, NULL, tokens, table, 0);
193 :
194 1 : tt_int_op(retval, OP_EQ, -1);
195 :
196 1 : done:
197 1 : tor_free(str);
198 1 : memarea_drop_all(area);
199 1 : smartlist_free(tokens);
200 1 : return;
201 : }
202 :
203 : static void
204 1 : test_parsecommon_tokenize_string_no_annotations(void *arg)
205 : {
206 1 : memarea_t *area = memarea_new();
207 1 : smartlist_t *tokens = smartlist_new();
208 :
209 1 : (void)arg;
210 :
211 1 : token_rule_t table[] = {
212 : A01("@last-listed", A_LAST_LISTED, CONCAT_ARGS, NO_OBJ),
213 : END_OF_TABLE,
214 : };
215 :
216 1 : char *str = tor_strdup("@last-listed 2018-09-21 15:30:03\n");
217 :
218 1 : int retval =
219 1 : tokenize_string(area, str, NULL, tokens, table, 0);
220 :
221 1 : tt_int_op(retval, OP_EQ, -1);
222 :
223 1 : done:
224 1 : tor_free(str);
225 1 : memarea_drop_all(area);
226 1 : smartlist_free(tokens);
227 1 : return;
228 : }
229 :
230 : static void
231 1 : test_parsecommon_get_next_token_success(void *arg)
232 : {
233 1 : memarea_t *area = memarea_new();
234 1 : const char *str = "uptime 1024";
235 1 : const char *end = str + strlen(str);
236 1 : const char **s = &str;
237 1 : token_rule_t table = T01("uptime", K_UPTIME, GE(1), NO_OBJ);
238 1 : (void)arg;
239 :
240 1 : directory_token_t *token = get_next_token(area, s, end, &table);
241 :
242 1 : tt_int_op(token->tp, OP_EQ, K_UPTIME);
243 1 : tt_int_op(token->n_args, OP_EQ, 1);
244 1 : tt_str_op(*(token->args), OP_EQ, "1024");
245 1 : tt_assert(!token->object_type);
246 1 : tt_int_op(token->object_size, OP_EQ, 0);
247 1 : tt_assert(!token->object_body);
248 :
249 1 : tt_ptr_op(*s, OP_EQ, end);
250 :
251 1 : done:
252 1 : memarea_drop_all(area);
253 1 : return;
254 : }
255 :
256 : static void
257 1 : test_parsecommon_get_next_token_concat_args(void *arg)
258 : {
259 1 : memarea_t *area = memarea_new();
260 1 : const char *str = "proto A=1 B=2";
261 1 : const char *end = str + strlen(str);
262 1 : const char **s = &str;
263 1 : token_rule_t rule = T01("proto", K_PROTO, CONCAT_ARGS, NO_OBJ);
264 1 : (void)arg;
265 :
266 1 : directory_token_t *token = get_next_token(area, s, end, &rule);
267 :
268 1 : tt_int_op(token->tp, OP_EQ, K_PROTO);
269 1 : tt_int_op(token->n_args, OP_EQ, 1);
270 1 : tt_str_op(*(token->args), OP_EQ, "A=1 B=2");
271 :
272 1 : done:
273 1 : memarea_drop_all(area);
274 1 : }
275 :
276 : static void
277 1 : test_parsecommon_get_next_token_parse_keys(void *arg)
278 : {
279 1 : (void)arg;
280 :
281 1 : memarea_t *area = memarea_new();
282 1 : const char *str =
283 : "onion-key\n"
284 : "-----BEGIN RSA PUBLIC KEY-----\n"
285 : "MIGJAoGBAMDdIya33BfNlHOkzoTKSTT8EjD64waMfUr372syVHiFjHhObwKwGA5u\n"
286 : "sHaMIe9r+Ij/4C1dKyuXkcz3DOl6gWNhTD7dZ89I+Okoh1jWe30jxCiAcywC22p5\n"
287 : "XLhrDkX1A63Z7XCH9ltwU2WMqWsVM98N2GR6MTujP7wtqdLExYN1AgMBAAE=\n"
288 : "-----END RSA PUBLIC KEY-----\n";
289 :
290 1 : const char *end = str + strlen(str);
291 1 : const char **s = (const char **)&str;
292 1 : directory_token_t *token = NULL;
293 1 : directory_token_t *token2 = NULL;
294 :
295 1 : token_rule_t rule = T1("onion-key", R_IPO_ONION_KEY, NO_ARGS, NEED_KEY_1024);
296 :
297 1 : token = get_next_token(area, s, end, &rule);
298 1 : tt_assert(token);
299 :
300 1 : tt_int_op(token->tp, OP_EQ, R_IPO_ONION_KEY);
301 1 : tt_int_op(token->n_args, OP_EQ, 0);
302 1 : tt_str_op(token->object_type, OP_EQ, "RSA PUBLIC KEY");
303 1 : tt_int_op(token->object_size, OP_EQ, 140);
304 1 : tt_assert(token->object_body);
305 1 : tt_assert(token->key);
306 1 : tt_assert(!token->error);
307 :
308 1 : const char *str2 =
309 : "client-key\n"
310 : "-----BEGIN RSA PRIVATE KEY-----\n"
311 : "MIICXAIBAAKBgQCwS810a2auH2PQchOBz9smNgjlDu31aq0IYlUohSYbhcv5AJ+d\n"
312 : "DY0nfZWzS+mZPwzL3UiEnTt6PVv7AgoZ5V9ZJWJTKIURjJpkK0mstfJKHKIZhf84\n"
313 : "pmFfRej9GQViB6NLtp1obOXJgJixSlMfw9doDI4NoAnEISCyH/tD77Qs2wIDAQAB\n"
314 : "AoGAbDg8CKkdQOnX9c7xFpCnsE8fKqz9eddgHHNwXw1NFTwOt+2gDWKSMZmv2X5S\n"
315 : "CVZg3owZxf5W0nT0D6Ny2+6nliak7foYAvkD0BsCiBhgftwC0zAo6k5rIbUKB3PJ\n"
316 : "QLFXgpJhqWuXkODyt/hS/GTernR437WVSEGp1bnALqiFabECQQDaqHOxzoWY/nvH\n"
317 : "KrfUi8EhqCnqERlRHwrW0MQZ1RPvF16OPPma+xa+ht/amfh3vYN5tZY82Zm43gGl\n"
318 : "XWL5cZhNAkEAzmdSootYVnqLLLRMfHKXnO1XbaEcA/08MDNKGlSclBJixFenE8jX\n"
319 : "iQsUbHwMJuGONvzWpRGPBP2f8xBd28ZtxwJARY+LZshtpfNniz/ixYJESaHG28je\n"
320 : "xfjbKOW3TQSFV+2WTifFvHEeljQwKMoMyoMGvYRwLCGJjs9JtMLVxsdFjQJBAKwD\n"
321 : "3BBvBQ39TuPQ1zWX4tb7zjMlY83HTFP3Sriq71tP/1QWoL2SUl56B2lp8E6vB/C3\n"
322 : "wsMK4SCNprHRYAd7VZ0CQDKn6Zhd11P94PLs0msybFEh1VXr6CEW/BrxBgbL4ls6\n"
323 : "dbX5XO0z4Ra8gYXgObgimhyMDYO98Idt5+Z3HIdyrSc=\n"
324 : "-----END RSA PRIVATE KEY-----\n";
325 :
326 1 : const char *end2 = str2 + strlen(str2);
327 1 : const char **s2 = (const char **)&str2;
328 :
329 1 : token_rule_t rule2 = T01("client-key", C_CLIENT_KEY, NO_ARGS, OBJ_OK);
330 1 : token2 = get_next_token(area, s2, end2, &rule2);
331 1 : tt_assert(token2);
332 1 : tt_int_op(token2->tp, OP_EQ, C_CLIENT_KEY);
333 1 : tt_int_op(token2->n_args, OP_EQ, 0);
334 1 : tt_str_op(token2->object_type, OP_EQ, "RSA PRIVATE KEY");
335 1 : tt_int_op(token2->object_size, OP_EQ, 608);
336 1 : tt_assert(token2->object_body);
337 1 : tt_assert(token2->key == NULL);
338 1 : tt_assert(!token->error);
339 :
340 1 : done:
341 1 : if (token) token_clear(token);
342 1 : if (token2) token_clear(token2);
343 1 : memarea_drop_all(area);
344 1 : }
345 :
346 : static void
347 1 : test_parsecommon_get_next_token_object(void *arg)
348 : {
349 1 : memarea_t *area = memarea_new();
350 :
351 1 : const char *str =
352 : "directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
353 : "CD1FD971855430880D3C31E0331C5C55800C2F79\n"
354 : "-----BEGIN SIGNATURE-----\n"
355 : "dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
356 : "A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
357 : "cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
358 : "uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
359 : "I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
360 : "Ua9DEZB9KbJHVX1rGShrLA==\n"
361 : "-----END SIGNATURE-----\n";
362 :
363 1 : const char *end = str + strlen(str);
364 1 : const char **s = &str;
365 1 : token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
366 : GE(2), NEED_OBJ);
367 1 : (void)arg;
368 :
369 1 : directory_token_t *token = get_next_token(area, s, end, &rule);
370 :
371 1 : tt_int_op(token->tp, OP_EQ, K_DIRECTORY_SIGNATURE);
372 1 : tt_int_op(token->n_args, OP_EQ, 2);
373 1 : tt_str_op(token->args[0], OP_EQ,
374 : "0232AF901C31A04EE9848595AF9BB7620D4C5B2E");
375 1 : tt_str_op(token->args[1], OP_EQ,
376 : "CD1FD971855430880D3C31E0331C5C55800C2F79");
377 :
378 1 : tt_assert(!token->error);
379 :
380 1 : char decoded[256];
381 1 : const char *signature =
382 : "dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
383 : "A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
384 : "cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
385 : "uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
386 : "I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
387 : "Ua9DEZB9KbJHVX1rGShrLA==\n";
388 1 : tt_assert(signature);
389 1 : size_t signature_len = strlen(signature);
390 1 : base64_decode(decoded, sizeof(decoded), signature, signature_len);
391 :
392 1 : tt_str_op(token->object_type, OP_EQ, "SIGNATURE");
393 1 : tt_int_op(token->object_size, OP_EQ, 256);
394 1 : tt_mem_op(token->object_body, OP_EQ, decoded, 256);
395 :
396 1 : tt_assert(!token->key);
397 :
398 1 : done:
399 1 : memarea_drop_all(area);
400 1 : }
401 :
402 : static void
403 1 : test_parsecommon_get_next_token_err_too_many_args(void *arg)
404 : {
405 1 : memarea_t *area = memarea_new();
406 1 : const char *str = "uptime 1024 1024 1024";
407 1 : const char *end = str + strlen(str);
408 1 : const char **s = &str;
409 1 : token_rule_t table = T01("uptime", K_UPTIME, EQ(1), NO_OBJ);
410 1 : (void)arg;
411 :
412 1 : directory_token_t *token = get_next_token(area, s, end, &table);
413 :
414 1 : tt_int_op(token->tp, OP_EQ, ERR_);
415 1 : tt_str_op(token->error, OP_EQ, "Too many arguments to uptime");
416 :
417 1 : done:
418 1 : memarea_drop_all(area);
419 1 : return;
420 : }
421 :
422 : static void
423 1 : test_parsecommon_get_next_token_err_too_few_args(void *arg)
424 : {
425 1 : memarea_t *area = memarea_new();
426 1 : const char *str = "uptime";
427 1 : const char *end = str + strlen(str);
428 1 : const char **s = &str;
429 1 : token_rule_t table = T01("uptime", K_UPTIME, EQ(1), NO_OBJ);
430 1 : (void)arg;
431 :
432 1 : directory_token_t *token = get_next_token(area, s, end, &table);
433 :
434 1 : tt_int_op(token->tp, OP_EQ, ERR_);
435 1 : tt_str_op(token->error, OP_EQ, "Too few arguments to uptime");
436 :
437 1 : done:
438 1 : memarea_drop_all(area);
439 1 : return;
440 : }
441 :
442 : static void
443 1 : test_parsecommon_get_next_token_err_obj_missing_endline(void *arg)
444 : {
445 1 : memarea_t *area = memarea_new();
446 :
447 1 : const char *str =
448 : "directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
449 : "CD1FD971855430880D3C31E0331C5C55800C2F79\n"
450 : "-----BEGIN SIGNATURE-----\n"
451 : "dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
452 : "A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
453 : "cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
454 : "uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
455 : "I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
456 : "Ua9DEZB9KbJHVX1rGShrLA==\n";
457 :
458 1 : const char *end = str + strlen(str);
459 1 : const char **s = &str;
460 1 : token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
461 : GE(2), NEED_OBJ);
462 1 : (void)arg;
463 :
464 1 : directory_token_t *token = get_next_token(area, s, end, &rule);
465 :
466 1 : tt_int_op(token->tp, OP_EQ, ERR_);
467 1 : tt_str_op(token->error, OP_EQ, "Malformed object: missing object end line");
468 :
469 1 : done:
470 1 : memarea_drop_all(area);
471 1 : return;
472 : }
473 :
474 : static void
475 1 : test_parsecommon_get_next_token_err_bad_beginline(void *arg)
476 : {
477 1 : memarea_t *area = memarea_new();
478 :
479 1 : const char *str =
480 : "directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
481 : "CD1FD971855430880D3C31E0331C5C55800C2F79\n"
482 : "-----BEGIN SIGNATURE-Z---\n"
483 : "dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
484 : "A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
485 : "cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
486 : "uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
487 : "I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
488 : "Ua9DEZB9KbJHVX1rGShrLA==\n"
489 : "-----END SIGNATURE-----\n";
490 :
491 1 : const char *end = str + strlen(str);
492 1 : const char **s = &str;
493 1 : token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
494 : GE(2), NEED_OBJ);
495 1 : (void)arg;
496 :
497 1 : directory_token_t *token = get_next_token(area, s, end, &rule);
498 :
499 1 : tt_int_op(token->tp, OP_EQ, ERR_);
500 1 : tt_str_op(token->error, OP_EQ, "Malformed object: bad begin line");
501 :
502 1 : done:
503 1 : memarea_drop_all(area);
504 1 : return;
505 : }
506 :
507 : static void
508 1 : test_parsecommon_get_next_token_err_tag_mismatch(void *arg)
509 : {
510 1 : memarea_t *area = memarea_new();
511 :
512 1 : const char *str =
513 : "directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
514 : "CD1FD971855430880D3C31E0331C5C55800C2F79\n"
515 : "-----BEGIN SIGNATURE-----\n"
516 : "dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
517 : "A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
518 : "cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
519 : "uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
520 : "I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
521 : "Ua9DEZB9KbJHVX1rGShrLA==\n"
522 : "-----END SOMETHINGELSE-----\n";
523 :
524 1 : const char *end = str + strlen(str);
525 1 : const char **s = &str;
526 1 : token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
527 : GE(2), NEED_OBJ);
528 1 : (void)arg;
529 :
530 1 : directory_token_t *token = get_next_token(area, s, end, &rule);
531 :
532 1 : tt_int_op(token->tp, OP_EQ, ERR_);
533 1 : tt_str_op(token->error, OP_EQ,
534 : "Malformed object: mismatched end tag SIGNATURE");
535 :
536 1 : done:
537 1 : memarea_drop_all(area);
538 1 : return;
539 : }
540 :
541 : static void
542 1 : test_parsecommon_get_next_token_err_bad_base64(void *arg)
543 : {
544 1 : memarea_t *area = memarea_new();
545 :
546 1 : const char *str =
547 : "directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
548 : "CD1FD971855430880D3C31E0331C5C55800C2F79\n"
549 : "-----BEGIN SIGNATURE-----\n"
550 : "%%@%%%%%%%!!!'\n"
551 : "-----END SIGNATURE-----\n";
552 :
553 1 : const char *end = str + strlen(str);
554 1 : const char **s = &str;
555 1 : token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
556 : GE(2), NEED_OBJ);
557 1 : (void)arg;
558 :
559 1 : directory_token_t *token = get_next_token(area, s, end, &rule);
560 :
561 1 : tt_int_op(token->tp, OP_EQ, ERR_);
562 1 : tt_str_op(token->error, OP_EQ, "Malformed object: bad base64-encoded data");
563 :
564 1 : done:
565 1 : memarea_drop_all(area);
566 1 : return;
567 : }
568 :
569 : #define PARSECOMMON_TEST(name) \
570 : { #name, test_parsecommon_ ## name, 0, NULL, NULL }
571 :
572 : struct testcase_t parsecommon_tests[] = {
573 : PARSECOMMON_TEST(tokenize_string_null),
574 : PARSECOMMON_TEST(tokenize_string_multiple_lines),
575 : PARSECOMMON_TEST(tokenize_string_min_cnt),
576 : PARSECOMMON_TEST(tokenize_string_max_cnt),
577 : PARSECOMMON_TEST(tokenize_string_at_start),
578 : PARSECOMMON_TEST(tokenize_string_at_end),
579 : PARSECOMMON_TEST(tokenize_string_no_annotations),
580 : PARSECOMMON_TEST(get_next_token_success),
581 : PARSECOMMON_TEST(get_next_token_concat_args),
582 : PARSECOMMON_TEST(get_next_token_parse_keys),
583 : PARSECOMMON_TEST(get_next_token_object),
584 : PARSECOMMON_TEST(get_next_token_err_too_many_args),
585 : PARSECOMMON_TEST(get_next_token_err_too_few_args),
586 : PARSECOMMON_TEST(get_next_token_err_obj_missing_endline),
587 : PARSECOMMON_TEST(get_next_token_err_bad_beginline),
588 : PARSECOMMON_TEST(get_next_token_err_tag_mismatch),
589 : PARSECOMMON_TEST(get_next_token_err_bad_base64),
590 : END_OF_TESTCASES
591 : };
|
