1 /* Copyright (c) 2016-2021, The Tor Project, Inc. */
2 /* See LICENSE for licensing information */
3
4 #define PROTOVER_PRIVATE
5 #define DIRVOTE_PRIVATE
6
7 #include "orconfig.h"
8 #include "test/test.h"
9
10 #include "lib/tls/tortls.h"
11
12 #include "core/or/or.h"
13
14 #include "core/or/connection_or.h"
15 #include "core/or/protover.h"
16 #include "core/or/versions.h"
17
18 #include "feature/dirauth/dirvote.h"
19
20 #include "feature/relay/relay_handshake.h"
21
22 static void
test_protover_parse(void * arg)23 test_protover_parse(void *arg)
24 {
25 (void) arg;
26 #ifdef HAVE_RUST
27 /** This test is disabled on rust builds, because it only exists to test
28 * internal C functions. */
29 tt_skip();
30 done:
31 ;
32 #else /* !defined(HAVE_RUST) */
33 char *re_encoded = NULL;
34
35 const char *orig = "Foo=1,3 Bar=3 Baz= Quux=9-12,14,15-16";
36 smartlist_t *elts = parse_protocol_list(orig);
37
38 tt_assert(elts);
39 tt_int_op(smartlist_len(elts), OP_EQ, 4);
40
41 const proto_entry_t *e;
42 e = smartlist_get(elts, 0);
43 tt_str_op(e->name, OP_EQ, "Foo");
44 tt_int_op(e->bitmask, OP_EQ, 0x0a);
45
46 e = smartlist_get(elts, 1);
47 tt_str_op(e->name, OP_EQ, "Bar");
48 tt_int_op(e->bitmask, OP_EQ, 0x08);
49
50 e = smartlist_get(elts, 2);
51 tt_str_op(e->name, OP_EQ, "Baz");
52 tt_int_op(e->bitmask, OP_EQ, 0x00);
53
54 e = smartlist_get(elts, 3);
55 tt_str_op(e->name, OP_EQ, "Quux");
56 tt_int_op(e->bitmask, OP_EQ, 0x1de00);
57
58 re_encoded = encode_protocol_list(elts);
59 tt_assert(re_encoded);
60 tt_str_op(re_encoded, OP_EQ, "Foo=1,3 Bar=3 Baz= Quux=9-12,14-16");
61
62 done:
63 if (elts)
64 SMARTLIST_FOREACH(elts, proto_entry_t *, ent, proto_entry_free(ent));
65 smartlist_free(elts);
66 tor_free(re_encoded);
67 #endif /* defined(HAVE_RUST) */
68 }
69
70 static void
test_protover_parse_fail(void * arg)71 test_protover_parse_fail(void *arg)
72 {
73 (void)arg;
74 #ifdef HAVE_RUST
75 /** This test is disabled on rust builds, because it only exists to test
76 * internal C functions. */
77 tt_skip();
78 #else
79 smartlist_t *elts;
80
81 /* random junk */
82 elts = parse_protocol_list("!!3@*");
83 tt_ptr_op(elts, OP_EQ, NULL);
84
85 /* Missing equals sign in an entry */
86 elts = parse_protocol_list("Link=4 Haprauxymatyve Desc=9");
87 tt_ptr_op(elts, OP_EQ, NULL);
88
89 /* Missing word. */
90 elts = parse_protocol_list("Link=4 =3 Desc=9");
91 tt_ptr_op(elts, OP_EQ, NULL);
92
93 /* Broken numbers */
94 elts = parse_protocol_list("Link=fred");
95 tt_ptr_op(elts, OP_EQ, NULL);
96 elts = parse_protocol_list("Link=1,fred");
97 tt_ptr_op(elts, OP_EQ, NULL);
98 elts = parse_protocol_list("Link=1,fred,3");
99 tt_ptr_op(elts, OP_EQ, NULL);
100
101 /* Broken range */
102 elts = parse_protocol_list("Link=1,9-8,3");
103 tt_ptr_op(elts, OP_EQ, NULL);
104
105 /* Protocol name too long */
106 elts = parse_protocol_list("DoSaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
107 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
108 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
109 tt_ptr_op(elts, OP_EQ, NULL);
110
111 #endif /* defined(HAVE_RUST) */
112 done:
113 ;
114 }
115
116 static void
test_protover_vote(void * arg)117 test_protover_vote(void *arg)
118 {
119 (void) arg;
120
121 smartlist_t *lst = smartlist_new();
122 char *result = protover_compute_vote(lst, 1);
123
124 tt_str_op(result, OP_EQ, "");
125 tor_free(result);
126
127 smartlist_add(lst, (void*) "Foo=1-10,63 Bar=1,3-7,8");
128 result = protover_compute_vote(lst, 1);
129 tt_str_op(result, OP_EQ, "Bar=1,3-8 Foo=1-10,63");
130 tor_free(result);
131
132 smartlist_add(lst, (void*) "Quux=12-45 Bar=2-6,8 Foo=9");
133 result = protover_compute_vote(lst, 1);
134 tt_str_op(result, OP_EQ, "Bar=1-8 Foo=1-10,63 Quux=12-45");
135 tor_free(result);
136
137 result = protover_compute_vote(lst, 2);
138 tt_str_op(result, OP_EQ, "Bar=3-6,8 Foo=9");
139 tor_free(result);
140
141 /* High threshold */
142 result = protover_compute_vote(lst, 3);
143 tt_str_op(result, OP_EQ, "");
144 tor_free(result);
145
146 /* Don't count double-voting. */
147 smartlist_clear(lst);
148 smartlist_add(lst, (void*) "Foo=1 Foo=1");
149 smartlist_add(lst, (void*) "Bar=1-2,2-3");
150 result = protover_compute_vote(lst, 2);
151 tt_str_op(result, OP_EQ, "");
152 tor_free(result);
153
154 /* Bad votes: the result must be empty */
155 smartlist_clear(lst);
156 smartlist_add(lst, (void*) "Faux=10-5");
157 result = protover_compute_vote(lst, 1);
158 tt_str_op(result, OP_EQ, "");
159 tor_free(result);
160
161 /* This fails, since "-0" is not valid. */
162 smartlist_clear(lst);
163 smartlist_add(lst, (void*) "Faux=-0");
164 result = protover_compute_vote(lst, 1);
165 tt_str_op(result, OP_EQ, "");
166 tor_free(result);
167
168 /* Vote large protover lists that are just below the threshold */
169
170 /* Just below the threshold: Rust */
171 smartlist_clear(lst);
172 smartlist_add(lst, (void*) "Sleen=1-50");
173 result = protover_compute_vote(lst, 1);
174 tt_str_op(result, OP_EQ, "Sleen=1-50");
175 tor_free(result);
176
177 /* Just below the threshold: C */
178 smartlist_clear(lst);
179 smartlist_add(lst, (void*) "Sleen=1-63");
180 result = protover_compute_vote(lst, 1);
181 tt_str_op(result, OP_EQ, "Sleen=1-63");
182 tor_free(result);
183
184 /* Protocol name too long */
185 smartlist_clear(lst);
186 smartlist_add(lst, (void*) "DoSaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
187 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
188 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
189 result = protover_compute_vote(lst, 1);
190 tt_str_op(result, OP_EQ, "");
191 tor_free(result);
192
193 done:
194 tor_free(result);
195 smartlist_free(lst);
196 }
197
198 static void
test_protover_all_supported(void * arg)199 test_protover_all_supported(void *arg)
200 {
201 (void)arg;
202 char *msg = NULL;
203
204 tt_assert(protover_all_supported(NULL, &msg));
205 tt_ptr_op(msg, OP_EQ, NULL);
206
207 tt_assert(protover_all_supported("", &msg));
208 tt_ptr_op(msg, OP_EQ, NULL);
209
210 // Some things that we do support
211 tt_assert(protover_all_supported("Link=3-4", &msg));
212 tt_ptr_op(msg, OP_EQ, NULL);
213 tt_assert(protover_all_supported("Link=3-4 Desc=2", &msg));
214 tt_ptr_op(msg, OP_EQ, NULL);
215
216 // Some things we don't support
217 tt_assert(! protover_all_supported("Wombat=9", NULL));
218 tt_assert(! protover_all_supported("Wombat=9", &msg));
219 tt_str_op(msg, OP_EQ, "Wombat=9");
220 tor_free(msg);
221 tt_assert(! protover_all_supported("Link=60", &msg));
222 tt_str_op(msg, OP_EQ, "Link=60");
223 tor_free(msg);
224
225 // Mix of things we support and things we don't
226 tt_assert(! protover_all_supported("Link=3-4 Wombat=9", &msg));
227 tt_str_op(msg, OP_EQ, "Wombat=9");
228 tor_free(msg);
229
230 /* Mix of things we support and don't support within a single protocol
231 * which we do support */
232 tt_assert(! protover_all_supported("Link=3-60", &msg));
233 tt_str_op(msg, OP_EQ, "Link=6-60");
234 tor_free(msg);
235 tt_assert(! protover_all_supported("Link=1-3,50-63", &msg));
236 tt_str_op(msg, OP_EQ, "Link=50-63");
237 tor_free(msg);
238 tt_assert(! protover_all_supported("Link=1-3,5-12", &msg));
239 tt_str_op(msg, OP_EQ, "Link=6-12");
240 tor_free(msg);
241
242 /* Mix of protocols we do support and some we don't, where the protocols
243 * we do support have some versions we don't support. */
244 tt_assert(! protover_all_supported("Link=1-3,5-12 Quokka=40-41", &msg));
245 tt_str_op(msg, OP_EQ, "Link=6-12 Quokka=40-41");
246 tor_free(msg);
247
248 /* If we get a (barely) valid (but unsupported list, we say "yes, that's
249 * supported." */
250 tt_assert(protover_all_supported("Fribble=", &msg));
251 tt_ptr_op(msg, OP_EQ, NULL);
252
253 #ifndef ALL_BUGS_ARE_FATAL
254 /* If we get a completely unparseable list, protover_all_supported should
255 * hit a fatal assertion for BUG(entries == NULL). */
256 tor_capture_bugs_(1);
257 tt_assert(protover_all_supported("Fribble", &msg));
258 tor_end_capture_bugs_();
259
260 /* If we get a completely unparseable list, protover_all_supported should
261 * hit a fatal assertion for BUG(entries == NULL). */
262 tor_capture_bugs_(1);
263 tt_assert(protover_all_supported("Sleen=1-4294967295", &msg));
264 tor_end_capture_bugs_();
265 #endif /* !defined(ALL_BUGS_ARE_FATAL) */
266
267 /* Protocol name too long */
268 #if !defined(HAVE_RUST) && !defined(ALL_BUGS_ARE_FATAL)
269 tor_capture_bugs_(1);
270 tt_assert(protover_all_supported(
271 "DoSaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
272 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
273 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
274 "aaaaaaaaaaaa=1-65536", &msg));
275 tor_end_capture_bugs_();
276 #endif /* !defined(HAVE_RUST) && !defined(ALL_BUGS_ARE_FATAL) */
277
278 done:
279 tor_end_capture_bugs_();
280 tor_free(msg);
281 }
282
283 static void
test_protover_list_supports_protocol_returns_true(void * arg)284 test_protover_list_supports_protocol_returns_true(void *arg)
285 {
286 (void)arg;
287
288 const char *protocols = "Link=1";
289 int is_supported = protocol_list_supports_protocol(protocols, PRT_LINK, 1);
290 tt_int_op(is_supported, OP_EQ, 1);
291
292 done:
293 ;
294 }
295
296 static void
test_protover_list_supports_protocol_for_unsupported_returns_false(void * arg)297 test_protover_list_supports_protocol_for_unsupported_returns_false(void *arg)
298 {
299 (void)arg;
300
301 const char *protocols = "Link=1";
302 int is_supported = protocol_list_supports_protocol(protocols, PRT_LINK, 10);
303 tt_int_op(is_supported, OP_EQ, 0);
304
305 done:
306 ;
307 }
308
309 static void
test_protover_supports_version(void * arg)310 test_protover_supports_version(void *arg)
311 {
312 (void)arg;
313
314 tt_assert(protocol_list_supports_protocol("Link=3-6", PRT_LINK, 3));
315 tt_assert(protocol_list_supports_protocol("Link=3-6", PRT_LINK, 6));
316 tt_assert(!protocol_list_supports_protocol("Link=3-6", PRT_LINK, 7));
317 tt_assert(!protocol_list_supports_protocol("Link=3-6", PRT_LINKAUTH, 3));
318
319 tt_assert(!protocol_list_supports_protocol("Link=4-6 LinkAuth=3",
320 PRT_LINKAUTH, 2));
321 tt_assert(protocol_list_supports_protocol("Link=4-6 LinkAuth=3",
322 PRT_LINKAUTH, 3));
323 tt_assert(!protocol_list_supports_protocol("Link=4-6 LinkAuth=3",
324 PRT_LINKAUTH, 4));
325 tt_assert(!protocol_list_supports_protocol_or_later("Link=4-6 LinkAuth=3",
326 PRT_LINKAUTH, 4));
327 tt_assert(protocol_list_supports_protocol_or_later("Link=4-6 LinkAuth=3",
328 PRT_LINKAUTH, 3));
329 tt_assert(protocol_list_supports_protocol_or_later("Link=4-6 LinkAuth=3",
330 PRT_LINKAUTH, 2));
331
332 tt_assert(!protocol_list_supports_protocol_or_later("Link=4-6 LinkAuth=3",
333 PRT_DESC, 2));
334 done:
335 ;
336 }
337
338 /* This could be MAX_PROTOCOLS_TO_EXPAND, but that's not exposed by protover */
339 #define MAX_PROTOCOLS_TO_TEST 1024
340
341 /* LinkAuth and Relay protocol versions.
342 * Hard-coded here, because they are not in the code, or not exposed in the
343 * headers. */
344 #define PROTOVER_LINKAUTH_V1 1
345 #define PROTOVER_LINKAUTH_V2 2
346 #define PROTOVER_RELAY_V1 1
347
348 /* Deprecated HSIntro versions */
349 #define PROTOVER_HS_INTRO_DEPRECATED_1 1
350 #define PROTOVER_HS_INTRO_DEPRECATED_2 2
351 /* Highest supported HSv2 introduce protocol version.
352 * It's not clear if we actually support version 2, see #25068. */
353 #define PROTOVER_HS_INTRO_V2 3
354
355 /* HSv2 Rend and HSDir protocol versions. */
356 #define PROTOVER_HS_RENDEZVOUS_POINT_V2 1
357 #define PROTOVER_HSDIR_V2 1
358
359 /* DirCache, Desc, Microdesc, and Cons protocol versions. */
360 #define PROTOVER_DIRCACHE_V1 1
361 #define PROTOVER_DIRCACHE_V2 2
362
363 #define PROTOVER_DESC_V1 1
364 #define PROTOVER_DESC_V2 2
365
366 #define PROTOVER_MICRODESC_V1 1
367 #define PROTOVER_MICRODESC_V2 2
368
369 #define PROTOVER_CONS_V1 1
370 #define PROTOVER_CONS_V2 2
371
372 #define PROTOVER_PADDING_V1 1
373
374 #define PROTOVER_FLOWCTRL_V1 1
375
376 /* Make sure we haven't forgotten any supported protocols */
377 static void
test_protover_supported_protocols(void * arg)378 test_protover_supported_protocols(void *arg)
379 {
380 (void)arg;
381
382 const char *supported_protocols = protover_get_supported_protocols();
383
384 /* Test for new Link in the code, that hasn't been added to supported
385 * protocols */
386 tt_assert(protocol_list_supports_protocol(supported_protocols,
387 PRT_LINK,
388 MAX_LINK_PROTO));
389 for (uint16_t i = 0; i < MAX_PROTOCOLS_TO_TEST; i++) {
390 tt_int_op(protocol_list_supports_protocol(supported_protocols,
391 PRT_LINK,
392 i),
393 OP_EQ,
394 is_or_protocol_version_known(i));
395 }
396
397 /* Legacy LinkAuth is only supported on OpenSSL and similar. */
398 tt_int_op(protocol_list_supports_protocol(supported_protocols,
399 PRT_LINKAUTH,
400 PROTOVER_LINKAUTH_V1),
401 OP_EQ,
402 authchallenge_type_is_supported(AUTHTYPE_RSA_SHA256_TLSSECRET));
403 /* LinkAuth=2 is unused */
404 tt_assert(!protocol_list_supports_protocol(supported_protocols,
405 PRT_LINKAUTH,
406 PROTOVER_LINKAUTH_V2));
407 tt_assert(
408 protocol_list_supports_protocol(supported_protocols,
409 PRT_LINKAUTH,
410 PROTOVER_LINKAUTH_ED25519_HANDSHAKE));
411
412 /* Relay protovers do not appear anywhere in the code. */
413 tt_assert(protocol_list_supports_protocol(supported_protocols,
414 PRT_RELAY,
415 PROTOVER_RELAY_V1));
416 tt_assert(protocol_list_supports_protocol(supported_protocols,
417 PRT_RELAY,
418 PROTOVER_RELAY_EXTEND2));
419 tt_assert(protocol_list_supports_protocol(supported_protocols,
420 PRT_RELAY,
421 PROTOVER_RELAY_ACCEPT_IPV6));
422 tt_assert(protocol_list_supports_protocol(supported_protocols,
423 PRT_RELAY,
424 PROTOVER_RELAY_EXTEND_IPV6));
425 tt_assert(protocol_list_supports_protocol(supported_protocols,
426 PRT_RELAY,
427 PROTOVER_RELAY_CANONICAL_IPV6));
428
429 /* These HSIntro versions are deprecated */
430 tt_assert(!protocol_list_supports_protocol(supported_protocols,
431 PRT_HSINTRO,
432 PROTOVER_HS_INTRO_DEPRECATED_1));
433 tt_assert(!protocol_list_supports_protocol(supported_protocols,
434 PRT_HSINTRO,
435 PROTOVER_HS_INTRO_DEPRECATED_2));
436 /* We could test legacy HSIntro by calling rend_service_update_descriptor(),
437 * and checking the protocols field. But that's unlikely to change, so
438 * we just use a hard-coded value. */
439 tt_assert(protocol_list_supports_protocol(supported_protocols,
440 PRT_HSINTRO,
441 PROTOVER_HS_INTRO_V2));
442 /* Test for HSv3 HSIntro */
443 tt_assert(protocol_list_supports_protocol(supported_protocols,
444 PRT_HSINTRO,
445 PROTOVER_HS_INTRO_V3));
446 /* Test for HSIntro DoS */
447 tt_assert(protocol_list_supports_protocol(supported_protocols,
448 PRT_HSINTRO,
449 PROTOVER_HS_INTRO_DOS));
450
451 /* Legacy HSRend does not appear anywhere in the code. */
452 tt_assert(protocol_list_supports_protocol(supported_protocols,
453 PRT_HSREND,
454 PROTOVER_HS_RENDEZVOUS_POINT_V2));
455 /* Test for HSv3 HSRend */
456 tt_assert(protocol_list_supports_protocol(supported_protocols,
457 PRT_HSREND,
458 PROTOVER_HS_RENDEZVOUS_POINT_V3));
459
460 /* Legacy HSDir does not appear anywhere in the code. */
461 tt_assert(protocol_list_supports_protocol(supported_protocols,
462 PRT_HSDIR,
463 PROTOVER_HSDIR_V2));
464 /* Test for HSv3 HSDir */
465 tt_assert(protocol_list_supports_protocol(supported_protocols,
466 PRT_HSDIR,
467 PROTOVER_HSDIR_V3));
468
469 /* No DirCache versions appear anywhere in the code. */
470 tt_assert(protocol_list_supports_protocol(supported_protocols,
471 PRT_DIRCACHE,
472 PROTOVER_DIRCACHE_V2));
473
474 /* No Desc versions appear anywhere in the code. */
475 tt_assert(protocol_list_supports_protocol(supported_protocols,
476 PRT_DESC,
477 PROTOVER_DESC_V1));
478 tt_assert(protocol_list_supports_protocol(supported_protocols,
479 PRT_DESC,
480 PROTOVER_DESC_V2));
481 /* Is there any way to test for new Desc? */
482
483 /* No Microdesc versions appear anywhere in the code. */
484 tt_assert(protocol_list_supports_protocol(supported_protocols,
485 PRT_MICRODESC,
486 PROTOVER_MICRODESC_V1));
487 tt_assert(protocol_list_supports_protocol(supported_protocols,
488 PRT_MICRODESC,
489 PROTOVER_MICRODESC_V2));
490
491 /* No Cons versions appear anywhere in the code. */
492 tt_assert(protocol_list_supports_protocol(supported_protocols,
493 PRT_CONS,
494 PROTOVER_CONS_V1));
495 tt_assert(protocol_list_supports_protocol(supported_protocols,
496 PRT_CONS,
497 PROTOVER_CONS_V2));
498
499 /* Padding=1 is deprecated. */
500 tt_assert(!protocol_list_supports_protocol(supported_protocols,
501 PRT_PADDING,
502 PROTOVER_PADDING_V1));
503 tt_assert(protocol_list_supports_protocol(supported_protocols,
504 PRT_PADDING,
505 PROTOVER_HS_SETUP_PADDING));
506
507 /* FlowCtrl */
508 tt_assert(protocol_list_supports_protocol(supported_protocols,
509 PRT_FLOWCTRL,
510 PROTOVER_FLOWCTRL_V1));
511
512 done:
513 ;
514 }
515
516 static void
test_protover_vote_roundtrip(void * args)517 test_protover_vote_roundtrip(void *args)
518 {
519 (void) args;
520 static const struct {
521 const char *input;
522 const char *expected_output;
523 } examples[] = {
524 { "Risqu\u00e9=1", NULL },
525 { ",,,=1", NULL },
526 { "\xc1=1", NULL },
527 { "Foo_Bar=1", NULL },
528 { "Fkrkljdsf", NULL },
529 { "Zn=4294967295", NULL },
530 { "Zn=4294967295-1", NULL },
531 { "Zn=4294967293-4294967295", NULL },
532 /* Will fail because of 4294967295. */
533 { "Foo=1,3 Bar=3 Baz= Quux=9-12,14,15-16,900 Zn=1,4294967295",
534 NULL },
535 { "Foo=1,3 Bar=3 Baz= Quux=9-12,14,15-16,50 Zn=1,42",
536 "Bar=3 Foo=1,3 Quux=9-12,14-16,50 Zn=1,42" },
537 { "Zu16=1,63", "Zu16=1,63" },
538 { "N-1=1,2", "N-1=1-2" },
539 { "-1=4294967295", NULL },
540 { "-1=3", "-1=3" },
541 { "Foo=,", NULL },
542 { "Foo=,1", NULL },
543 { "Foo=1,,3", NULL },
544 { "Foo=1,3,", NULL },
545 /* junk. */
546 { "!!3@*", NULL },
547 /* Missing equals sign */
548 { "Link=4 Haprauxymatyve Desc=9", NULL },
549 { "Link=4 Haprauxymatyve=7 Desc=9",
550 "Desc=9 Haprauxymatyve=7 Link=4" },
551 { "=10-11", NULL },
552 { "X=10-11", "X=10-11" },
553 { "Link=4 =3 Desc=9", NULL },
554 { "Link=4 Z=3 Desc=9", "Desc=9 Link=4 Z=3" },
555 { "Link=fred", NULL },
556 { "Link=1,fred", NULL },
557 { "Link=1,fred,3", NULL },
558 { "Link=1,9-8,3", NULL },
559 { "Faux=-0", NULL },
560 { "Faux=0--0", NULL },
561 { "Faux=-1", NULL },
562 { "Faux=-1-3", NULL },
563 { "Faux=1--1", NULL },
564 { "Link=1-2-", NULL },
565 { "Link=1-2-3", NULL },
566 { "Faux=1-2-", NULL },
567 { "Faux=1-2-3", NULL },
568 { "Link=\t1,3", NULL },
569 { "Link=1\n,3", NULL },
570 { "Faux=1,\r3", NULL },
571 { "Faux=1,3\f", NULL },
572 /* Large integers */
573 { "Link=4294967296", NULL },
574 /* Large range */
575 { "Sleen=1-63", "Sleen=1-63" },
576 { "Sleen=1-65537", NULL },
577 };
578 unsigned u;
579 smartlist_t *votes = smartlist_new();
580 char *result = NULL;
581
582 for (u = 0; u < ARRAY_LENGTH(examples); ++u) {
583 const char *input = examples[u].input;
584 const char *expected_output = examples[u].expected_output;
585
586 smartlist_add(votes, (void*)input);
587 result = protover_compute_vote(votes, 1);
588 if (expected_output != NULL) {
589 tt_str_op(result, OP_EQ, expected_output);
590 } else {
591 tt_str_op(result, OP_EQ, "");
592 }
593
594 smartlist_clear(votes);
595 tor_free(result);
596 }
597
598 done:
599 smartlist_free(votes);
600 tor_free(result);
601 }
602
603 static void
test_protover_vote_roundtrip_ours(void * args)604 test_protover_vote_roundtrip_ours(void *args)
605 {
606 (void) args;
607 const char *examples[] = {
608 protover_get_supported_protocols(),
609 DIRVOTE_RECOMMEND_RELAY_PROTO,
610 DIRVOTE_RECOMMEND_CLIENT_PROTO,
611 DIRVOTE_REQUIRE_RELAY_PROTO,
612 DIRVOTE_REQUIRE_CLIENT_PROTO,
613 };
614 unsigned u;
615 smartlist_t *votes = smartlist_new();
616 char *result = NULL;
617
618 for (u = 0; u < ARRAY_LENGTH(examples); ++u) {
619 tt_assert(examples[u]);
620 const char *input = examples[u];
621 const char *expected_output = examples[u];
622
623 smartlist_add(votes, (void*)input);
624 result = protover_compute_vote(votes, 1);
625 if (expected_output != NULL) {
626 tt_str_op(result, OP_EQ, expected_output);
627 } else {
628 tt_str_op(result, OP_EQ, "");
629 }
630
631 smartlist_clear(votes);
632 tor_free(result);
633 }
634
635 done:
636 smartlist_free(votes);
637 tor_free(result);
638 }
639
640 /* Stringifies its argument.
641 * 4 -> "4" */
642 #define STR(x) #x
643
644 #ifdef COCCI
645 #define PROTOVER(proto_string, version_macro)
646 #else
647 /* Generate a protocol version string using proto_string and version_macro.
648 * PROTOVER("HSIntro", PROTOVER_HS_INTRO_DOS) -> "HSIntro" "=" "5"
649 * Uses two levels of macros to turn PROTOVER_HS_INTRO_DOS into "5".
650 */
651 #define PROTOVER(proto_string, version_macro) \
652 (proto_string "=" STR(version_macro))
653 #endif /* defined(COCCI) */
654
655 #define DEBUG_PROTOVER(flags) \
656 STMT_BEGIN \
657 log_debug(LD_GENERAL, \
658 "protovers:\n" \
659 "protocols_known: %d,\n" \
660 "supports_extend2_cells: %d,\n" \
661 "supports_accepting_ipv6_extends: %d,\n" \
662 "supports_initiating_ipv6_extends: %d,\n" \
663 "supports_canonical_ipv6_conns: %d,\n" \
664 "supports_ed25519_link_handshake_compat: %d,\n" \
665 "supports_ed25519_link_handshake_any: %d,\n" \
666 "supports_ed25519_hs_intro: %d,\n" \
667 "supports_establish_intro_dos_extension: %d,\n" \
668 "supports_v3_hsdir: %d,\n" \
669 "supports_v3_rendezvous_point: %d,\n" \
670 "supports_hs_setup_padding: %d.", \
671 (flags).protocols_known, \
672 (flags).supports_extend2_cells, \
673 (flags).supports_accepting_ipv6_extends, \
674 (flags).supports_initiating_ipv6_extends, \
675 (flags).supports_canonical_ipv6_conns, \
676 (flags).supports_ed25519_link_handshake_compat, \
677 (flags).supports_ed25519_link_handshake_any, \
678 (flags).supports_ed25519_hs_intro, \
679 (flags).supports_establish_intro_dos_extension, \
680 (flags).supports_v3_hsdir, \
681 (flags).supports_v3_rendezvous_point, \
682 (flags).supports_hs_setup_padding); \
683 STMT_END
684
685 /* Test that the proto_string version version_macro sets summary_flag. */
686 #define TEST_PROTOVER(proto_string, version_macro, summary_flag) \
687 STMT_BEGIN \
688 memset(&flags, 0, sizeof(flags)); \
689 summarize_protover_flags(&flags, \
690 PROTOVER(proto_string, version_macro), \
691 NULL); \
692 DEBUG_PROTOVER(flags); \
693 tt_int_op(flags.protocols_known, OP_EQ, 1); \
694 tt_int_op(flags.summary_flag, OP_EQ, 1); \
695 flags.protocols_known = 0; \
696 flags.summary_flag = 0; \
697 tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags)); \
698 STMT_END
699
700 static void
test_protover_summarize_flags(void * args)701 test_protover_summarize_flags(void *args)
702 {
703 (void) args;
704 char pv[30];
705 memset(&pv, 0, sizeof(pv));
706
707 protover_summary_cache_free_all();
708
709 protover_summary_flags_t zero_flags;
710 memset(&zero_flags, 0, sizeof(zero_flags));
711 protover_summary_flags_t flags;
712
713 memset(&flags, 0, sizeof(flags));
714 summarize_protover_flags(&flags, NULL, NULL);
715 DEBUG_PROTOVER(flags);
716 tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags));
717
718 memset(&flags, 0, sizeof(flags));
719 summarize_protover_flags(&flags, "", "");
720 DEBUG_PROTOVER(flags);
721 tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags));
722
723 /* Now check version exceptions */
724
725 /* EXTEND2 cell support */
726 memset(&flags, 0, sizeof(flags));
727 summarize_protover_flags(&flags, NULL, "Tor 0.2.4.8-alpha");
728 DEBUG_PROTOVER(flags);
729 tt_int_op(flags.protocols_known, OP_EQ, 1);
730 tt_int_op(flags.supports_extend2_cells, OP_EQ, 1);
731 /* Now clear those flags, and check the rest are zero */
732 flags.protocols_known = 0;
733 flags.supports_extend2_cells = 0;
734 tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags));
735
736 /* disabling HSDir v3 support for buggy versions */
737 memset(&flags, 0, sizeof(flags));
738 summarize_protover_flags(&flags,
739 PROTOVER("HSDir", PROTOVER_HSDIR_V3),
740 NULL);
741 DEBUG_PROTOVER(flags);
742 tt_int_op(flags.protocols_known, OP_EQ, 1);
743 tt_int_op(flags.supports_v3_hsdir, OP_EQ, 1);
744 /* Now clear those flags, and check the rest are zero */
745 flags.protocols_known = 0;
746 flags.supports_v3_hsdir = 0;
747 tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags));
748
749 memset(&flags, 0, sizeof(flags));
750 summarize_protover_flags(&flags,
751 PROTOVER("HSDir", PROTOVER_HSDIR_V3),
752 "Tor 0.3.0.7");
753 DEBUG_PROTOVER(flags);
754 tt_int_op(flags.protocols_known, OP_EQ, 1);
755 /* Now clear that flag, and check the rest are zero */
756 flags.protocols_known = 0;
757 tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags));
758
759 /* Now check standard summaries */
760
761 /* LinkAuth */
762 memset(&flags, 0, sizeof(flags));
763 summarize_protover_flags(&flags,
764 PROTOVER("LinkAuth",
765 PROTOVER_LINKAUTH_ED25519_HANDSHAKE),
766 NULL);
767 DEBUG_PROTOVER(flags);
768 tt_int_op(flags.protocols_known, OP_EQ, 1);
769 tt_int_op(flags.supports_ed25519_link_handshake_compat, OP_EQ, 1);
770 tt_int_op(flags.supports_ed25519_link_handshake_any, OP_EQ, 1);
771 /* Now clear those flags, and check the rest are zero */
772 flags.protocols_known = 0;
773 flags.supports_ed25519_link_handshake_compat = 0;
774 flags.supports_ed25519_link_handshake_any = 0;
775 tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags));
776
777 /* Test one greater */
778 memset(&flags, 0, sizeof(flags));
779 snprintf(pv, sizeof(pv),
780 "%s=%d", "LinkAuth", PROTOVER_LINKAUTH_ED25519_HANDSHAKE + 1);
781 summarize_protover_flags(&flags, pv, NULL);
782 DEBUG_PROTOVER(flags);
783 tt_int_op(flags.protocols_known, OP_EQ, 1);
784 tt_int_op(flags.supports_ed25519_link_handshake_compat, OP_EQ, 0);
785 tt_int_op(flags.supports_ed25519_link_handshake_any, OP_EQ, 1);
786 /* Now clear those flags, and check the rest are zero */
787 flags.protocols_known = 0;
788 flags.supports_ed25519_link_handshake_compat = 0;
789 flags.supports_ed25519_link_handshake_any = 0;
790 tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags));
791
792 /* Test one less */
793 memset(&flags, 0, sizeof(flags));
794 snprintf(pv, sizeof(pv),
795 "%s=%d", "LinkAuth", PROTOVER_LINKAUTH_ED25519_HANDSHAKE - 1);
796 summarize_protover_flags(&flags, pv, NULL);
797 DEBUG_PROTOVER(flags);
798 tt_int_op(flags.protocols_known, OP_EQ, 1);
799 tt_int_op(flags.supports_ed25519_link_handshake_compat, OP_EQ, 0);
800 tt_int_op(flags.supports_ed25519_link_handshake_any, OP_EQ, 0);
801 /* Now clear those flags, and check the rest are zero */
802 flags.protocols_known = 0;
803 flags.supports_ed25519_link_handshake_compat = 0;
804 flags.supports_ed25519_link_handshake_any = 0;
805 tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags));
806
807 /* We don't test "one more" and "one less" for each protocol version.
808 * But that could be a useful thing to add. */
809
810 /* Relay */
811 memset(&flags, 0, sizeof(flags));
812 /* This test relies on these versions being equal */
813 tt_int_op(PROTOVER_RELAY_EXTEND2, OP_EQ, PROTOVER_RELAY_ACCEPT_IPV6);
814 summarize_protover_flags(&flags,
815 PROTOVER("Relay", PROTOVER_RELAY_EXTEND2), NULL);
816 DEBUG_PROTOVER(flags);
817 tt_int_op(flags.protocols_known, OP_EQ, 1);
818 tt_int_op(flags.supports_extend2_cells, OP_EQ, 1);
819 tt_int_op(flags.supports_accepting_ipv6_extends, OP_EQ, 1);
820 /* Now clear those flags, and check the rest are zero */
821 flags.protocols_known = 0;
822 flags.supports_extend2_cells = 0;
823 flags.supports_accepting_ipv6_extends = 0;
824 tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags));
825
826 memset(&flags, 0, sizeof(flags));
827 /* This test relies on these versions being equal */
828 tt_int_op(PROTOVER_RELAY_EXTEND_IPV6, OP_EQ, PROTOVER_RELAY_CANONICAL_IPV6);
829 summarize_protover_flags(&flags,
830 PROTOVER("Relay", PROTOVER_RELAY_EXTEND_IPV6),
831 NULL);
832 DEBUG_PROTOVER(flags);
833 tt_int_op(flags.protocols_known, OP_EQ, 1);
834 tt_int_op(flags.supports_accepting_ipv6_extends, OP_EQ, 1);
835 tt_int_op(flags.supports_initiating_ipv6_extends, OP_EQ, 1);
836 tt_int_op(flags.supports_canonical_ipv6_conns, OP_EQ, 1);
837 /* Now clear those flags, and check the rest are zero */
838 flags.protocols_known = 0;
839 flags.supports_accepting_ipv6_extends = 0;
840 flags.supports_initiating_ipv6_extends = 0;
841 flags.supports_canonical_ipv6_conns = 0;
842 tt_mem_op(&flags, OP_EQ, &zero_flags, sizeof(flags));
843
844 TEST_PROTOVER("HSIntro", PROTOVER_HS_INTRO_V3,
845 supports_ed25519_hs_intro);
846 TEST_PROTOVER("HSIntro", PROTOVER_HS_INTRO_DOS,
847 supports_establish_intro_dos_extension);
848
849 TEST_PROTOVER("HSRend", PROTOVER_HS_RENDEZVOUS_POINT_V3,
850 supports_v3_rendezvous_point);
851
852 TEST_PROTOVER("HSDir", PROTOVER_HSDIR_V3,
853 supports_v3_hsdir);
854
855 TEST_PROTOVER("Padding", PROTOVER_HS_SETUP_PADDING,
856 supports_hs_setup_padding);
857
858 done:
859 ;
860 }
861
862 #define PV_TEST(name, flags) \
863 { #name, test_protover_ ##name, (flags), NULL, NULL }
864
865 struct testcase_t protover_tests[] = {
866 PV_TEST(parse, 0),
867 PV_TEST(parse_fail, 0),
868 PV_TEST(vote, 0),
869 PV_TEST(all_supported, 0),
870 PV_TEST(list_supports_protocol_for_unsupported_returns_false, 0),
871 PV_TEST(list_supports_protocol_returns_true, 0),
872 PV_TEST(supports_version, 0),
873 PV_TEST(supported_protocols, 0),
874 PV_TEST(vote_roundtrip, 0),
875 PV_TEST(vote_roundtrip_ours, 0),
876 /* fork, because we memoize flags internally */
877 PV_TEST(summarize_flags, TT_FORK),
878 END_OF_TESTCASES
879 };
880