[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [tor/master] Merge branch 'maint-0.3.2' into maint-0.3.3



commit f7eff2f8c53dacb7c375bbe6bc9cced95103307d
Merge: d489e4847 d01abb934
Author: Nick Mathewson <nickm@xxxxxxxxxxxxxx>
Date:   Thu Mar 1 16:10:43 2018 -0500

    Merge branch 'maint-0.3.2' into maint-0.3.3

 changes/bug25249         |   3 +
 changes/bug25249.2       |   3 +
 changes/trove-2018-001.1 |   6 ++
 changes/trove-2018-004   |   8 +++
 src/or/protover.c        |  35 ++++++++--
 src/test/test_protover.c | 171 +++++++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 220 insertions(+), 6 deletions(-)

diff --cc src/test/test_protover.c
index d3d146256,9b94044b9..c343e9957
--- a/src/test/test_protover.c
+++ b/src/test/test_protover.c
@@@ -199,208 -276,82 +292,285 @@@ test_protover_all_supported(void *arg
  }
  
  static void
 +test_protover_list_supports_protocol_returns_true(void *arg)
 +{
 +  (void)arg;
 +
 +  const char *protocols = "Link=1";
 +  int is_supported = protocol_list_supports_protocol(protocols, PRT_LINK, 1);
 +  tt_int_op(is_supported, OP_EQ, 1);
 +
 + done:
 +  ;
 +}
 +
 +static void
 +test_protover_list_supports_protocol_for_unsupported_returns_false(void *arg)
 +{
 +  (void)arg;
 +
 +  const char *protocols = "Link=1";
 +  int is_supported = protocol_list_supports_protocol(protocols, PRT_LINK, 10);
 +  tt_int_op(is_supported, OP_EQ, 0);
 +
 + done:
 +  ;
 +}
 +
 +static void
 +test_protover_supports_version(void *arg)
 +{
 +  (void)arg;
 +
 +  tt_assert(protocol_list_supports_protocol("Link=3-6", PRT_LINK, 3));
 +  tt_assert(protocol_list_supports_protocol("Link=3-6", PRT_LINK, 6));
 +  tt_assert(!protocol_list_supports_protocol("Link=3-6", PRT_LINK, 7));
 +  tt_assert(!protocol_list_supports_protocol("Link=3-6", PRT_LINKAUTH, 3));
 +
 +  tt_assert(!protocol_list_supports_protocol("Link=4-6 LinkAuth=3",
 +                                            PRT_LINKAUTH, 2));
 +  tt_assert(protocol_list_supports_protocol("Link=4-6 LinkAuth=3",
 +                                            PRT_LINKAUTH, 3));
 +  tt_assert(!protocol_list_supports_protocol("Link=4-6 LinkAuth=3",
 +                                             PRT_LINKAUTH, 4));
 +  tt_assert(!protocol_list_supports_protocol_or_later("Link=4-6 LinkAuth=3",
 +                                             PRT_LINKAUTH, 4));
 +  tt_assert(protocol_list_supports_protocol_or_later("Link=4-6 LinkAuth=3",
 +                                             PRT_LINKAUTH, 3));
 +  tt_assert(protocol_list_supports_protocol_or_later("Link=4-6 LinkAuth=3",
 +                                             PRT_LINKAUTH, 2));
 +
 +  tt_assert(!protocol_list_supports_protocol_or_later("Link=4-6 LinkAuth=3",
 +                                                      PRT_DESC, 2));
 + done:
 + ;
 +}
 +
 +/* This could be MAX_PROTOCOLS_TO_EXPAND, but that's not exposed by protover */
 +#define MAX_PROTOCOLS_TO_TEST 1024
 +
 +/* LinkAuth and Relay protocol versions.
 + * Hard-coded here, because they are not in the code, or not exposed in the
 + * headers. */
 +#define PROTOVER_LINKAUTH_V1 1
 +#define PROTOVER_LINKAUTH_V3 3
 +
 +#define PROTOVER_RELAY_V1 1
 +#define PROTOVER_RELAY_V2 2
 +
 +/* Highest supported HSv2 introduce protocol version.
 + * Hard-coded here, because it does not appear anywhere in the code.
 + * It's not clear if we actually support version 2, see #25068. */
 +#define PROTOVER_HSINTRO_V2 3
 +
 +/* HSv2 Rend and HSDir protocol versions.
 + * Hard-coded here, because they do not appear anywhere in the code. */
 +#define PROTOVER_HS_RENDEZVOUS_POINT_V2 1
 +#define PROTOVER_HSDIR_V2 1
 +
 +/* DirCache, Desc, Microdesc, and Cons protocol versions.
 + * Hard-coded here, because they do not appear anywhere in the code. */
 +#define PROTOVER_DIRCACHE_V1 1
 +#define PROTOVER_DIRCACHE_V2 2
 +
 +#define PROTOVER_DESC_V1 1
 +#define PROTOVER_DESC_V2 2
 +
 +#define PROTOVER_MICRODESC_V1 1
 +#define PROTOVER_MICRODESC_V2 2
 +
 +#define PROTOVER_CONS_V1 1
 +#define PROTOVER_CONS_V2 2
 +
 +/* Make sure we haven't forgotten any supported protocols */
 +static void
 +test_protover_supported_protocols(void *arg)
 +{
 +  (void)arg;
 +
 +  const char *supported_protocols = protover_get_supported_protocols();
 +
 +  /* Test for new Link in the code, that hasn't been added to supported
 +   * protocols */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_LINK,
 +                                            MAX_LINK_PROTO));
 +  for (uint16_t i = 0; i < MAX_PROTOCOLS_TO_TEST; i++) {
 +    if (is_or_protocol_version_known(i)) {
 +      tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                                PRT_LINK,
 +                                                i));
 +    }
 +  }
 +
 +  /* Legacy LinkAuth does not appear anywhere in the code. */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_LINKAUTH,
 +                                            PROTOVER_LINKAUTH_V1));
 +  /* Latest LinkAuth is not exposed in the headers. */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_LINKAUTH,
 +                                            PROTOVER_LINKAUTH_V3));
 +  /* Is there any way to test for new LinkAuth? */
 +
 +  /* Relay protovers do not appear anywhere in the code. */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_RELAY,
 +                                            PROTOVER_RELAY_V1));
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_RELAY,
 +                                            PROTOVER_RELAY_V2));
 +  /* Is there any way to test for new Relay? */
 +
 +  /* We could test legacy HSIntro by calling rend_service_update_descriptor(),
 +   * and checking the protocols field. But that's unlikely to change, so
 +   * we just use a hard-coded value. */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_HSINTRO,
 +                                            PROTOVER_HSINTRO_V2));
 +  /* Test for HSv3 HSIntro */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_HSINTRO,
 +                                            PROTOVER_HS_INTRO_V3));
 +  /* Is there any way to test for new HSIntro? */
 +
 +  /* Legacy HSRend does not appear anywhere in the code. */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_HSREND,
 +                                            PROTOVER_HS_RENDEZVOUS_POINT_V2));
 +  /* Test for HSv3 HSRend */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_HSREND,
 +                                            PROTOVER_HS_RENDEZVOUS_POINT_V3));
 +  /* Is there any way to test for new HSRend? */
 +
 +  /* Legacy HSDir does not appear anywhere in the code. */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_HSDIR,
 +                                            PROTOVER_HSDIR_V2));
 +  /* Test for HSv3 HSDir */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_HSDIR,
 +                                            PROTOVER_HSDIR_V3));
 +  /* Is there any way to test for new HSDir? */
 +
 +  /* No DirCache versions appear anywhere in the code. */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_DIRCACHE,
 +                                            PROTOVER_DIRCACHE_V1));
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_DIRCACHE,
 +                                            PROTOVER_DIRCACHE_V2));
 +  /* Is there any way to test for new DirCache? */
 +
 +  /* No Desc versions appear anywhere in the code. */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_DESC,
 +                                            PROTOVER_DESC_V1));
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_DESC,
 +                                            PROTOVER_DESC_V2));
 +  /* Is there any way to test for new Desc? */
 +
 +  /* No Microdesc versions appear anywhere in the code. */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_MICRODESC,
 +                                            PROTOVER_MICRODESC_V1));
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_MICRODESC,
 +                                            PROTOVER_MICRODESC_V2));
 +  /* Is there any way to test for new Microdesc? */
 +
 +  /* No Cons versions appear anywhere in the code. */
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_CONS,
 +                                            PROTOVER_CONS_V1));
 +  tt_assert(protocol_list_supports_protocol(supported_protocols,
 +                                            PRT_CONS,
 +                                            PROTOVER_CONS_V2));
 +  /* Is there any way to test for new Cons? */
 +
 + done:
 + ;
 +}
 +
++static void
+ test_protover_vote_roundtrip(void *args)
+ {
+   (void) args;
+   static const struct {
+     const char *input;
+     const char *expected_output;
+   } examples[] = {
+     { "Fkrkljdsf", NULL },
+     { "Zn=4294967295", NULL },
+     { "Zn=4294967295-1", NULL },
+     { "Zn=4294967293-4294967295", NULL },
+     /* Will fail because of 4294967295. */
+     { "Foo=1,3 Bar=3 Baz= Quux=9-12,14,15-16,900 Zn=0,4294967295",
+        NULL },
+     { "Foo=1,3 Bar=3 Baz= Quux=9-12,14,15-16,900 Zn=0,4294967294",
+       "Bar=3 Foo=1,3 Quux=9-12,14-16,900 Zn=0,4294967294" },
+     { "Zu16=0,65536", "Zu16=0,65536" },
+     { "N-1=1,2", "N-1=1-2" },
+     { "-1=4294967295", NULL },
+     { "-1=3", "-1=3" },
+     /* junk. */
+     { "!!3@*", NULL },
+     /* Missing equals sign */
+     { "Link=4 Haprauxymatyve Desc=9", NULL },
+     { "Link=4 Haprauxymatyve=7 Desc=9",
+       "Desc=9 Haprauxymatyve=7 Link=4" },
+     { "=10-11", NULL },
+     { "X=10-11", "X=10-11" },
+     { "Link=4 =3 Desc=9", NULL },
+     { "Link=4 Z=3 Desc=9", "Desc=9 Link=4 Z=3" },
+     { "Link=fred", NULL },
+     { "Link=1,fred", NULL },
+     { "Link=1,fred,3", NULL },
+     { "Link=1,9-8,3", NULL },
+     { "Faux=-0", NULL },
+     { "Faux=0--0", NULL },
+     // "These fail at the splitting stage in Rust, but the number parsing
+     // stage in C."
+     { "Faux=-1", NULL },
+     { "Faux=-1-3", NULL },
+     { "Faux=1--1", NULL },
+     /* Large integers */
+     { "Link=4294967296", NULL },
+     /* Large range */
+     { "Sleen=1-501", "Sleen=1-501" },
+     { "Sleen=1-65537", NULL },
+     /* CPU/RAM DoS Loop: Rust only. */
+     { "Sleen=0-2147483648", NULL },
+     /* Rust seems to experience an internal error here. */
+     { "Sleen=0-4294967295", NULL },
+   };
+   unsigned u;
+   smartlist_t *votes = smartlist_new();
+   char *result = NULL;
+ 
+   for (u = 0; u < ARRAY_LENGTH(examples); ++u) {
+     const char *input = examples[u].input;
+     const char *expected_output = examples[u].expected_output;
+ 
+     smartlist_add(votes, (void*)input);
+     result = protover_compute_vote(votes, 1);
+     if (expected_output != NULL) {
+       tt_str_op(result, OP_EQ, expected_output);
+     } else {
+       tt_str_op(result, OP_EQ, "");
+     }
+ 
+     smartlist_clear(votes);
+     tor_free(result);
+   }
+ 
+  done:
+   smartlist_free(votes);
+   tor_free(result);
+ }
+ 
  #define PV_TEST(name, flags)                       \
    { #name, test_protover_ ##name, (flags), NULL, NULL }
  
@@@ -409,10 -360,7 +579,11 @@@ struct testcase_t protover_tests[] = 
    PV_TEST(parse_fail, 0),
    PV_TEST(vote, 0),
    PV_TEST(all_supported, 0),
 +  PV_TEST(list_supports_protocol_for_unsupported_returns_false, 0),
 +  PV_TEST(list_supports_protocol_returns_true, 0),
 +  PV_TEST(supports_version, 0),
 +  PV_TEST(supported_protocols, 0),
+   PV_TEST(vote_roundtrip, 0),
    END_OF_TESTCASES
  };
  



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits